]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/gtk/_misc_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
reSWIGged
[wxWidgets.git] / wxPython / src / gtk / _misc_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 /* for raw pointers */
989 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
990 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
991 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
992 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
993 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
994 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
995 #define swig_owntype int
996
997 /* for raw packed data */
998 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
999 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1000
1001 /* for class or struct pointers */
1002 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1003 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1004
1005 /* for C or C++ function pointers */
1006 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1007 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1008
1009 /* for C++ member pointers, ie, member methods */
1010 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1011 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1012
1013
1014 /* Runtime API */
1015
1016 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1017 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1018 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1019
1020 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1021 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1022 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1023 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1024 #define SWIG_fail goto fail
1025
1026
1027 /* Runtime API implementation */
1028
1029 /* Error manipulation */
1030
1031 SWIGINTERN void
1032 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1033 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1034 PyErr_SetObject(errtype, obj);
1035 Py_DECREF(obj);
1036 SWIG_PYTHON_THREAD_END_BLOCK;
1037 }
1038
1039 SWIGINTERN void
1040 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1041 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1042 PyErr_SetString(errtype, (char *) msg);
1043 SWIG_PYTHON_THREAD_END_BLOCK;
1044 }
1045
1046 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1047
1048 /* Set a constant value */
1049
1050 SWIGINTERN void
1051 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1052 PyDict_SetItemString(d, (char*) name, obj);
1053 Py_DECREF(obj);
1054 }
1055
1056 /* Append a value to the result obj */
1057
1058 SWIGINTERN PyObject*
1059 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1060 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1061 if (!result) {
1062 result = obj;
1063 } else if (result == Py_None) {
1064 Py_DECREF(result);
1065 result = obj;
1066 } else {
1067 if (!PyList_Check(result)) {
1068 PyObject *o2 = result;
1069 result = PyList_New(1);
1070 PyList_SetItem(result, 0, o2);
1071 }
1072 PyList_Append(result,obj);
1073 Py_DECREF(obj);
1074 }
1075 return result;
1076 #else
1077 PyObject* o2;
1078 PyObject* o3;
1079 if (!result) {
1080 result = obj;
1081 } else if (result == Py_None) {
1082 Py_DECREF(result);
1083 result = obj;
1084 } else {
1085 if (!PyTuple_Check(result)) {
1086 o2 = result;
1087 result = PyTuple_New(1);
1088 PyTuple_SET_ITEM(result, 0, o2);
1089 }
1090 o3 = PyTuple_New(1);
1091 PyTuple_SET_ITEM(o3, 0, obj);
1092 o2 = result;
1093 result = PySequence_Concat(o2, o3);
1094 Py_DECREF(o2);
1095 Py_DECREF(o3);
1096 }
1097 return result;
1098 #endif
1099 }
1100
1101 /* Unpack the argument tuple */
1102
1103 SWIGINTERN int
1104 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1105 {
1106 if (!args) {
1107 if (!min && !max) {
1108 return 1;
1109 } else {
1110 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1111 name, (min == max ? "" : "at least "), min);
1112 return 0;
1113 }
1114 }
1115 if (!PyTuple_Check(args)) {
1116 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1117 return 0;
1118 } else {
1119 register int l = PyTuple_GET_SIZE(args);
1120 if (l < min) {
1121 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1122 name, (min == max ? "" : "at least "), min, l);
1123 return 0;
1124 } else if (l > max) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at most "), max, l);
1127 return 0;
1128 } else {
1129 register int i;
1130 for (i = 0; i < l; ++i) {
1131 objs[i] = PyTuple_GET_ITEM(args, i);
1132 }
1133 for (; l < max; ++l) {
1134 objs[l] = 0;
1135 }
1136 return i + 1;
1137 }
1138 }
1139 }
1140
1141 /* A functor is a function object with one single object argument */
1142 #if PY_VERSION_HEX >= 0x02020000
1143 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1144 #else
1145 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1146 #endif
1147
1148 /*
1149 Helper for static pointer initialization for both C and C++ code, for example
1150 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1151 */
1152 #ifdef __cplusplus
1153 #define SWIG_STATIC_POINTER(var) var
1154 #else
1155 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1156 #endif
1157
1158 /* -----------------------------------------------------------------------------
1159 * Pointer declarations
1160 * ----------------------------------------------------------------------------- */
1161
1162 /* Flags for new pointer objects */
1163 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1164 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1165
1166 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1167
1168 #ifdef __cplusplus
1169 extern "C" {
1170 #if 0
1171 } /* cc-mode */
1172 #endif
1173 #endif
1174
1175 /* How to access Py_None */
1176 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1177 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1178 # ifndef SWIG_PYTHON_BUILD_NONE
1179 # define SWIG_PYTHON_BUILD_NONE
1180 # endif
1181 # endif
1182 #endif
1183
1184 #ifdef SWIG_PYTHON_BUILD_NONE
1185 # ifdef Py_None
1186 # undef Py_None
1187 # define Py_None SWIG_Py_None()
1188 # endif
1189 SWIGRUNTIMEINLINE PyObject *
1190 _SWIG_Py_None(void)
1191 {
1192 PyObject *none = Py_BuildValue("");
1193 Py_DECREF(none);
1194 return none;
1195 }
1196 SWIGRUNTIME PyObject *
1197 SWIG_Py_None(void)
1198 {
1199 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1200 return none;
1201 }
1202 #endif
1203
1204 /* The python void return value */
1205
1206 SWIGRUNTIMEINLINE PyObject *
1207 SWIG_Py_Void(void)
1208 {
1209 PyObject *none = Py_None;
1210 Py_INCREF(none);
1211 return none;
1212 }
1213
1214 /* PySwigClientData */
1215
1216 typedef struct {
1217 PyObject *klass;
1218 PyObject *newraw;
1219 PyObject *newargs;
1220 PyObject *destroy;
1221 int delargs;
1222 int implicitconv;
1223 } PySwigClientData;
1224
1225 SWIGRUNTIMEINLINE int
1226 SWIG_Python_CheckImplicit(swig_type_info *ty)
1227 {
1228 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1229 return data ? data->implicitconv : 0;
1230 }
1231
1232 SWIGRUNTIMEINLINE PyObject *
1233 SWIG_Python_ExceptionType(swig_type_info *desc) {
1234 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1235 PyObject *klass = data ? data->klass : 0;
1236 return (klass ? klass : PyExc_RuntimeError);
1237 }
1238
1239
1240 SWIGRUNTIME PySwigClientData *
1241 PySwigClientData_New(PyObject* obj)
1242 {
1243 if (!obj) {
1244 return 0;
1245 } else {
1246 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1247 /* the klass element */
1248 data->klass = obj;
1249 Py_INCREF(data->klass);
1250 /* the newraw method and newargs arguments used to create a new raw instance */
1251 if (PyClass_Check(obj)) {
1252 data->newraw = 0;
1253 data->newargs = obj;
1254 Py_INCREF(obj);
1255 } else {
1256 #if (PY_VERSION_HEX < 0x02020000)
1257 data->newraw = 0;
1258 #else
1259 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1260 #endif
1261 if (data->newraw) {
1262 Py_INCREF(data->newraw);
1263 data->newargs = PyTuple_New(1);
1264 PyTuple_SetItem(data->newargs, 0, obj);
1265 } else {
1266 data->newargs = obj;
1267 }
1268 Py_INCREF(data->newargs);
1269 }
1270 /* the destroy method, aka as the C++ delete method */
1271 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1272 if (PyErr_Occurred()) {
1273 PyErr_Clear();
1274 data->destroy = 0;
1275 }
1276 if (data->destroy) {
1277 int flags;
1278 Py_INCREF(data->destroy);
1279 flags = PyCFunction_GET_FLAGS(data->destroy);
1280 #ifdef METH_O
1281 data->delargs = !(flags & (METH_O));
1282 #else
1283 data->delargs = 0;
1284 #endif
1285 } else {
1286 data->delargs = 0;
1287 }
1288 data->implicitconv = 0;
1289 return data;
1290 }
1291 }
1292
1293 SWIGRUNTIME void
1294 PySwigClientData_Del(PySwigClientData* data)
1295 {
1296 Py_XDECREF(data->newraw);
1297 Py_XDECREF(data->newargs);
1298 Py_XDECREF(data->destroy);
1299 }
1300
1301 /* =============== PySwigObject =====================*/
1302
1303 typedef struct {
1304 PyObject_HEAD
1305 void *ptr;
1306 swig_type_info *ty;
1307 int own;
1308 PyObject *next;
1309 } PySwigObject;
1310
1311 SWIGRUNTIME PyObject *
1312 PySwigObject_long(PySwigObject *v)
1313 {
1314 return PyLong_FromVoidPtr(v->ptr);
1315 }
1316
1317 SWIGRUNTIME PyObject *
1318 PySwigObject_format(const char* fmt, PySwigObject *v)
1319 {
1320 PyObject *res = NULL;
1321 PyObject *args = PyTuple_New(1);
1322 if (args) {
1323 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1324 PyObject *ofmt = PyString_FromString(fmt);
1325 if (ofmt) {
1326 res = PyString_Format(ofmt,args);
1327 Py_DECREF(ofmt);
1328 }
1329 Py_DECREF(args);
1330 }
1331 }
1332 return res;
1333 }
1334
1335 SWIGRUNTIME PyObject *
1336 PySwigObject_oct(PySwigObject *v)
1337 {
1338 return PySwigObject_format("%o",v);
1339 }
1340
1341 SWIGRUNTIME PyObject *
1342 PySwigObject_hex(PySwigObject *v)
1343 {
1344 return PySwigObject_format("%x",v);
1345 }
1346
1347 SWIGRUNTIME PyObject *
1348 #ifdef METH_NOARGS
1349 PySwigObject_repr(PySwigObject *v)
1350 #else
1351 PySwigObject_repr(PySwigObject *v, PyObject *args)
1352 #endif
1353 {
1354 const char *name = SWIG_TypePrettyName(v->ty);
1355 PyObject *hex = PySwigObject_hex(v);
1356 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1357 Py_DECREF(hex);
1358 if (v->next) {
1359 #ifdef METH_NOARGS
1360 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1361 #else
1362 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1363 #endif
1364 PyString_ConcatAndDel(&repr,nrep);
1365 }
1366 return repr;
1367 }
1368
1369 SWIGRUNTIME int
1370 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1371 {
1372 #ifdef METH_NOARGS
1373 PyObject *repr = PySwigObject_repr(v);
1374 #else
1375 PyObject *repr = PySwigObject_repr(v, NULL);
1376 #endif
1377 if (repr) {
1378 fputs(PyString_AsString(repr), fp);
1379 Py_DECREF(repr);
1380 return 0;
1381 } else {
1382 return 1;
1383 }
1384 }
1385
1386 SWIGRUNTIME PyObject *
1387 PySwigObject_str(PySwigObject *v)
1388 {
1389 char result[SWIG_BUFFER_SIZE];
1390 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1391 PyString_FromString(result) : 0;
1392 }
1393
1394 SWIGRUNTIME int
1395 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1396 {
1397 void *i = v->ptr;
1398 void *j = w->ptr;
1399 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1400 }
1401
1402 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1403
1404 SWIGRUNTIME PyTypeObject*
1405 PySwigObject_type(void) {
1406 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1407 return type;
1408 }
1409
1410 SWIGRUNTIMEINLINE int
1411 PySwigObject_Check(PyObject *op) {
1412 return ((op)->ob_type == PySwigObject_type())
1413 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1414 }
1415
1416 SWIGRUNTIME PyObject *
1417 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1418
1419 SWIGRUNTIME void
1420 PySwigObject_dealloc(PyObject *v)
1421 {
1422 PySwigObject *sobj = (PySwigObject *) v;
1423 PyObject *next = sobj->next;
1424 if (sobj->own) {
1425 swig_type_info *ty = sobj->ty;
1426 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1427 PyObject *destroy = data ? data->destroy : 0;
1428 if (destroy) {
1429 /* destroy is always a VARARGS method */
1430 PyObject *res;
1431 if (data->delargs) {
1432 /* we need to create a temporal object to carry the destroy operation */
1433 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1434 res = SWIG_Python_CallFunctor(destroy, tmp);
1435 Py_DECREF(tmp);
1436 } else {
1437 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1438 PyObject *mself = PyCFunction_GET_SELF(destroy);
1439 res = ((*meth)(mself, v));
1440 }
1441 Py_XDECREF(res);
1442 } else {
1443 const char *name = SWIG_TypePrettyName(ty);
1444 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1445 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1446 #endif
1447 }
1448 }
1449 Py_XDECREF(next);
1450 PyObject_DEL(v);
1451 }
1452
1453 SWIGRUNTIME PyObject*
1454 PySwigObject_append(PyObject* v, PyObject* next)
1455 {
1456 PySwigObject *sobj = (PySwigObject *) v;
1457 #ifndef METH_O
1458 PyObject *tmp = 0;
1459 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1460 next = tmp;
1461 #endif
1462 if (!PySwigObject_Check(next)) {
1463 return NULL;
1464 }
1465 sobj->next = next;
1466 Py_INCREF(next);
1467 return SWIG_Py_Void();
1468 }
1469
1470 SWIGRUNTIME PyObject*
1471 #ifdef METH_NOARGS
1472 PySwigObject_next(PyObject* v)
1473 #else
1474 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1475 #endif
1476 {
1477 PySwigObject *sobj = (PySwigObject *) v;
1478 if (sobj->next) {
1479 Py_INCREF(sobj->next);
1480 return sobj->next;
1481 } else {
1482 return SWIG_Py_Void();
1483 }
1484 }
1485
1486 SWIGINTERN PyObject*
1487 #ifdef METH_NOARGS
1488 PySwigObject_disown(PyObject *v)
1489 #else
1490 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1491 #endif
1492 {
1493 PySwigObject *sobj = (PySwigObject *)v;
1494 sobj->own = 0;
1495 return SWIG_Py_Void();
1496 }
1497
1498 SWIGINTERN PyObject*
1499 #ifdef METH_NOARGS
1500 PySwigObject_acquire(PyObject *v)
1501 #else
1502 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1503 #endif
1504 {
1505 PySwigObject *sobj = (PySwigObject *)v;
1506 sobj->own = SWIG_POINTER_OWN;
1507 return SWIG_Py_Void();
1508 }
1509
1510 SWIGINTERN PyObject*
1511 PySwigObject_own(PyObject *v, PyObject *args)
1512 {
1513 PyObject *val = 0;
1514 #if (PY_VERSION_HEX < 0x02020000)
1515 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1516 #else
1517 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1518 #endif
1519 {
1520 return NULL;
1521 }
1522 else
1523 {
1524 PySwigObject *sobj = (PySwigObject *)v;
1525 PyObject *obj = PyBool_FromLong(sobj->own);
1526 if (val) {
1527 #ifdef METH_NOARGS
1528 if (PyObject_IsTrue(val)) {
1529 PySwigObject_acquire(v);
1530 } else {
1531 PySwigObject_disown(v);
1532 }
1533 #else
1534 if (PyObject_IsTrue(val)) {
1535 PySwigObject_acquire(v,args);
1536 } else {
1537 PySwigObject_disown(v,args);
1538 }
1539 #endif
1540 }
1541 return obj;
1542 }
1543 }
1544
1545 #ifdef METH_O
1546 static PyMethodDef
1547 swigobject_methods[] = {
1548 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1549 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1550 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1551 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1552 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1553 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1554 {0, 0, 0, 0}
1555 };
1556 #else
1557 static PyMethodDef
1558 swigobject_methods[] = {
1559 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1560 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1561 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1562 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1563 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1564 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1565 {0, 0, 0, 0}
1566 };
1567 #endif
1568
1569 #if PY_VERSION_HEX < 0x02020000
1570 SWIGINTERN PyObject *
1571 PySwigObject_getattr(PySwigObject *sobj,char *name)
1572 {
1573 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1574 }
1575 #endif
1576
1577 SWIGRUNTIME PyTypeObject*
1578 _PySwigObject_type(void) {
1579 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1580
1581 static PyNumberMethods PySwigObject_as_number = {
1582 (binaryfunc)0, /*nb_add*/
1583 (binaryfunc)0, /*nb_subtract*/
1584 (binaryfunc)0, /*nb_multiply*/
1585 (binaryfunc)0, /*nb_divide*/
1586 (binaryfunc)0, /*nb_remainder*/
1587 (binaryfunc)0, /*nb_divmod*/
1588 (ternaryfunc)0,/*nb_power*/
1589 (unaryfunc)0, /*nb_negative*/
1590 (unaryfunc)0, /*nb_positive*/
1591 (unaryfunc)0, /*nb_absolute*/
1592 (inquiry)0, /*nb_nonzero*/
1593 0, /*nb_invert*/
1594 0, /*nb_lshift*/
1595 0, /*nb_rshift*/
1596 0, /*nb_and*/
1597 0, /*nb_xor*/
1598 0, /*nb_or*/
1599 (coercion)0, /*nb_coerce*/
1600 (unaryfunc)PySwigObject_long, /*nb_int*/
1601 (unaryfunc)PySwigObject_long, /*nb_long*/
1602 (unaryfunc)0, /*nb_float*/
1603 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1604 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1605 #if PY_VERSION_HEX >= 0x02020000
1606 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1607 #elif PY_VERSION_HEX >= 0x02000000
1608 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1609 #endif
1610 };
1611
1612 static PyTypeObject pyswigobject_type;
1613 static int type_init = 0;
1614 if (!type_init) {
1615 const PyTypeObject tmp
1616 = {
1617 PyObject_HEAD_INIT(NULL)
1618 0, /* ob_size */
1619 (char *)"PySwigObject", /* tp_name */
1620 sizeof(PySwigObject), /* tp_basicsize */
1621 0, /* tp_itemsize */
1622 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1623 (printfunc)PySwigObject_print, /* tp_print */
1624 #if PY_VERSION_HEX < 0x02020000
1625 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1626 #else
1627 (getattrfunc)0, /* tp_getattr */
1628 #endif
1629 (setattrfunc)0, /* tp_setattr */
1630 (cmpfunc)PySwigObject_compare, /* tp_compare */
1631 (reprfunc)PySwigObject_repr, /* tp_repr */
1632 &PySwigObject_as_number, /* tp_as_number */
1633 0, /* tp_as_sequence */
1634 0, /* tp_as_mapping */
1635 (hashfunc)0, /* tp_hash */
1636 (ternaryfunc)0, /* tp_call */
1637 (reprfunc)PySwigObject_str, /* tp_str */
1638 PyObject_GenericGetAttr, /* tp_getattro */
1639 0, /* tp_setattro */
1640 0, /* tp_as_buffer */
1641 Py_TPFLAGS_DEFAULT, /* tp_flags */
1642 swigobject_doc, /* tp_doc */
1643 0, /* tp_traverse */
1644 0, /* tp_clear */
1645 0, /* tp_richcompare */
1646 0, /* tp_weaklistoffset */
1647 #if PY_VERSION_HEX >= 0x02020000
1648 0, /* tp_iter */
1649 0, /* tp_iternext */
1650 swigobject_methods, /* tp_methods */
1651 0, /* tp_members */
1652 0, /* tp_getset */
1653 0, /* tp_base */
1654 0, /* tp_dict */
1655 0, /* tp_descr_get */
1656 0, /* tp_descr_set */
1657 0, /* tp_dictoffset */
1658 0, /* tp_init */
1659 0, /* tp_alloc */
1660 0, /* tp_new */
1661 0, /* tp_free */
1662 0, /* tp_is_gc */
1663 0, /* tp_bases */
1664 0, /* tp_mro */
1665 0, /* tp_cache */
1666 0, /* tp_subclasses */
1667 0, /* tp_weaklist */
1668 #endif
1669 #if PY_VERSION_HEX >= 0x02030000
1670 0, /* tp_del */
1671 #endif
1672 #ifdef COUNT_ALLOCS
1673 0,0,0,0 /* tp_alloc -> tp_next */
1674 #endif
1675 };
1676 pyswigobject_type = tmp;
1677 pyswigobject_type.ob_type = &PyType_Type;
1678 type_init = 1;
1679 }
1680 return &pyswigobject_type;
1681 }
1682
1683 SWIGRUNTIME PyObject *
1684 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1685 {
1686 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1687 if (sobj) {
1688 sobj->ptr = ptr;
1689 sobj->ty = ty;
1690 sobj->own = own;
1691 sobj->next = 0;
1692 }
1693 return (PyObject *)sobj;
1694 }
1695
1696 /* -----------------------------------------------------------------------------
1697 * Implements a simple Swig Packed type, and use it instead of string
1698 * ----------------------------------------------------------------------------- */
1699
1700 typedef struct {
1701 PyObject_HEAD
1702 void *pack;
1703 swig_type_info *ty;
1704 size_t size;
1705 } PySwigPacked;
1706
1707 SWIGRUNTIME int
1708 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1709 {
1710 char result[SWIG_BUFFER_SIZE];
1711 fputs("<Swig Packed ", fp);
1712 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1713 fputs("at ", fp);
1714 fputs(result, fp);
1715 }
1716 fputs(v->ty->name,fp);
1717 fputs(">", fp);
1718 return 0;
1719 }
1720
1721 SWIGRUNTIME PyObject *
1722 PySwigPacked_repr(PySwigPacked *v)
1723 {
1724 char result[SWIG_BUFFER_SIZE];
1725 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1726 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1727 } else {
1728 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1729 }
1730 }
1731
1732 SWIGRUNTIME PyObject *
1733 PySwigPacked_str(PySwigPacked *v)
1734 {
1735 char result[SWIG_BUFFER_SIZE];
1736 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1737 return PyString_FromFormat("%s%s", result, v->ty->name);
1738 } else {
1739 return PyString_FromString(v->ty->name);
1740 }
1741 }
1742
1743 SWIGRUNTIME int
1744 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1745 {
1746 size_t i = v->size;
1747 size_t j = w->size;
1748 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1749 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1750 }
1751
1752 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1753
1754 SWIGRUNTIME PyTypeObject*
1755 PySwigPacked_type(void) {
1756 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1757 return type;
1758 }
1759
1760 SWIGRUNTIMEINLINE int
1761 PySwigPacked_Check(PyObject *op) {
1762 return ((op)->ob_type == _PySwigPacked_type())
1763 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1764 }
1765
1766 SWIGRUNTIME void
1767 PySwigPacked_dealloc(PyObject *v)
1768 {
1769 if (PySwigPacked_Check(v)) {
1770 PySwigPacked *sobj = (PySwigPacked *) v;
1771 free(sobj->pack);
1772 }
1773 PyObject_DEL(v);
1774 }
1775
1776 SWIGRUNTIME PyTypeObject*
1777 _PySwigPacked_type(void) {
1778 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1779 static PyTypeObject pyswigpacked_type;
1780 static int type_init = 0;
1781 if (!type_init) {
1782 const PyTypeObject tmp
1783 = {
1784 PyObject_HEAD_INIT(NULL)
1785 0, /* ob_size */
1786 (char *)"PySwigPacked", /* tp_name */
1787 sizeof(PySwigPacked), /* tp_basicsize */
1788 0, /* tp_itemsize */
1789 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1790 (printfunc)PySwigPacked_print, /* tp_print */
1791 (getattrfunc)0, /* tp_getattr */
1792 (setattrfunc)0, /* tp_setattr */
1793 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1794 (reprfunc)PySwigPacked_repr, /* tp_repr */
1795 0, /* tp_as_number */
1796 0, /* tp_as_sequence */
1797 0, /* tp_as_mapping */
1798 (hashfunc)0, /* tp_hash */
1799 (ternaryfunc)0, /* tp_call */
1800 (reprfunc)PySwigPacked_str, /* tp_str */
1801 PyObject_GenericGetAttr, /* tp_getattro */
1802 0, /* tp_setattro */
1803 0, /* tp_as_buffer */
1804 Py_TPFLAGS_DEFAULT, /* tp_flags */
1805 swigpacked_doc, /* tp_doc */
1806 0, /* tp_traverse */
1807 0, /* tp_clear */
1808 0, /* tp_richcompare */
1809 0, /* tp_weaklistoffset */
1810 #if PY_VERSION_HEX >= 0x02020000
1811 0, /* tp_iter */
1812 0, /* tp_iternext */
1813 0, /* tp_methods */
1814 0, /* tp_members */
1815 0, /* tp_getset */
1816 0, /* tp_base */
1817 0, /* tp_dict */
1818 0, /* tp_descr_get */
1819 0, /* tp_descr_set */
1820 0, /* tp_dictoffset */
1821 0, /* tp_init */
1822 0, /* tp_alloc */
1823 0, /* tp_new */
1824 0, /* tp_free */
1825 0, /* tp_is_gc */
1826 0, /* tp_bases */
1827 0, /* tp_mro */
1828 0, /* tp_cache */
1829 0, /* tp_subclasses */
1830 0, /* tp_weaklist */
1831 #endif
1832 #if PY_VERSION_HEX >= 0x02030000
1833 0, /* tp_del */
1834 #endif
1835 #ifdef COUNT_ALLOCS
1836 0,0,0,0 /* tp_alloc -> tp_next */
1837 #endif
1838 };
1839 pyswigpacked_type = tmp;
1840 pyswigpacked_type.ob_type = &PyType_Type;
1841 type_init = 1;
1842 }
1843 return &pyswigpacked_type;
1844 }
1845
1846 SWIGRUNTIME PyObject *
1847 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1848 {
1849 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1850 if (sobj) {
1851 void *pack = malloc(size);
1852 if (pack) {
1853 memcpy(pack, ptr, size);
1854 sobj->pack = pack;
1855 sobj->ty = ty;
1856 sobj->size = size;
1857 } else {
1858 PyObject_DEL((PyObject *) sobj);
1859 sobj = 0;
1860 }
1861 }
1862 return (PyObject *) sobj;
1863 }
1864
1865 SWIGRUNTIME swig_type_info *
1866 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1867 {
1868 if (PySwigPacked_Check(obj)) {
1869 PySwigPacked *sobj = (PySwigPacked *)obj;
1870 if (sobj->size != size) return 0;
1871 memcpy(ptr, sobj->pack, size);
1872 return sobj->ty;
1873 } else {
1874 return 0;
1875 }
1876 }
1877
1878 /* -----------------------------------------------------------------------------
1879 * pointers/data manipulation
1880 * ----------------------------------------------------------------------------- */
1881
1882 SWIGRUNTIMEINLINE PyObject *
1883 _SWIG_This(void)
1884 {
1885 return PyString_FromString("this");
1886 }
1887
1888 SWIGRUNTIME PyObject *
1889 SWIG_This(void)
1890 {
1891 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1892 return swig_this;
1893 }
1894
1895 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1896
1897 SWIGRUNTIME PySwigObject *
1898 SWIG_Python_GetSwigThis(PyObject *pyobj)
1899 {
1900 if (PySwigObject_Check(pyobj)) {
1901 return (PySwigObject *) pyobj;
1902 } else {
1903 PyObject *obj = 0;
1904 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1905 if (PyInstance_Check(pyobj)) {
1906 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1907 } else {
1908 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1909 if (dictptr != NULL) {
1910 PyObject *dict = *dictptr;
1911 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1912 } else {
1913 #ifdef PyWeakref_CheckProxy
1914 if (PyWeakref_CheckProxy(pyobj)) {
1915 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1916 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1917 }
1918 #endif
1919 obj = PyObject_GetAttr(pyobj,SWIG_This());
1920 if (obj) {
1921 Py_DECREF(obj);
1922 } else {
1923 if (PyErr_Occurred()) PyErr_Clear();
1924 return 0;
1925 }
1926 }
1927 }
1928 #else
1929 obj = PyObject_GetAttr(pyobj,SWIG_This());
1930 if (obj) {
1931 Py_DECREF(obj);
1932 } else {
1933 if (PyErr_Occurred()) PyErr_Clear();
1934 return 0;
1935 }
1936 #endif
1937 if (obj && !PySwigObject_Check(obj)) {
1938 /* a PyObject is called 'this', try to get the 'real this'
1939 PySwigObject from it */
1940 return SWIG_Python_GetSwigThis(obj);
1941 }
1942 return (PySwigObject *)obj;
1943 }
1944 }
1945
1946 /* Acquire a pointer value */
1947
1948 SWIGRUNTIME int
1949 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1950 if (own) {
1951 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1952 if (sobj) {
1953 int oldown = sobj->own;
1954 sobj->own = own;
1955 return oldown;
1956 }
1957 }
1958 return 0;
1959 }
1960
1961 /* Convert a pointer value */
1962
1963 SWIGRUNTIME int
1964 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1965 if (!obj) return SWIG_ERROR;
1966 if (obj == Py_None) {
1967 if (ptr) *ptr = 0;
1968 return SWIG_OK;
1969 } else {
1970 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1971 while (sobj) {
1972 void *vptr = sobj->ptr;
1973 if (ty) {
1974 swig_type_info *to = sobj->ty;
1975 if (to == ty) {
1976 /* no type cast needed */
1977 if (ptr) *ptr = vptr;
1978 break;
1979 } else {
1980 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1981 if (!tc) {
1982 sobj = (PySwigObject *)sobj->next;
1983 } else {
1984 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1985 break;
1986 }
1987 }
1988 } else {
1989 if (ptr) *ptr = vptr;
1990 break;
1991 }
1992 }
1993 if (sobj) {
1994 if (own) *own = sobj->own;
1995 if (flags & SWIG_POINTER_DISOWN) {
1996 sobj->own = 0;
1997 }
1998 return SWIG_OK;
1999 } else {
2000 int res = SWIG_ERROR;
2001 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2002 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2003 if (data && !data->implicitconv) {
2004 PyObject *klass = data->klass;
2005 if (klass) {
2006 PyObject *impconv;
2007 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2008 impconv = SWIG_Python_CallFunctor(klass, obj);
2009 data->implicitconv = 0;
2010 if (PyErr_Occurred()) {
2011 PyErr_Clear();
2012 impconv = 0;
2013 }
2014 if (impconv) {
2015 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2016 if (iobj) {
2017 void *vptr;
2018 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2019 if (SWIG_IsOK(res)) {
2020 if (ptr) {
2021 *ptr = vptr;
2022 /* transfer the ownership to 'ptr' */
2023 iobj->own = 0;
2024 res = SWIG_AddCast(res);
2025 res = SWIG_AddNewMask(res);
2026 } else {
2027 res = SWIG_AddCast(res);
2028 }
2029 }
2030 }
2031 Py_DECREF(impconv);
2032 }
2033 }
2034 }
2035 }
2036 return res;
2037 }
2038 }
2039 }
2040
2041 /* Convert a function ptr value */
2042
2043 SWIGRUNTIME int
2044 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2045 if (!PyCFunction_Check(obj)) {
2046 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2047 } else {
2048 void *vptr = 0;
2049
2050 /* here we get the method pointer for callbacks */
2051 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2052 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2053 if (desc) {
2054 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2055 if (!desc) return SWIG_ERROR;
2056 }
2057 if (ty) {
2058 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2059 if (!tc) return SWIG_ERROR;
2060 *ptr = SWIG_TypeCast(tc,vptr);
2061 } else {
2062 *ptr = vptr;
2063 }
2064 return SWIG_OK;
2065 }
2066 }
2067
2068 /* Convert a packed value value */
2069
2070 SWIGRUNTIME int
2071 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2072 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2073 if (!to) return SWIG_ERROR;
2074 if (ty) {
2075 if (to != ty) {
2076 /* check type cast? */
2077 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2078 if (!tc) return SWIG_ERROR;
2079 }
2080 }
2081 return SWIG_OK;
2082 }
2083
2084 /* -----------------------------------------------------------------------------
2085 * Create a new pointer object
2086 * ----------------------------------------------------------------------------- */
2087
2088 /*
2089 Create a new instance object, whitout calling __init__, and set the
2090 'this' attribute.
2091 */
2092
2093 SWIGRUNTIME PyObject*
2094 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2095 {
2096 #if (PY_VERSION_HEX >= 0x02020000)
2097 PyObject *inst = 0;
2098 PyObject *newraw = data->newraw;
2099 if (newraw) {
2100 inst = PyObject_Call(newraw, data->newargs, NULL);
2101 if (inst) {
2102 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2103 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2104 if (dictptr != NULL) {
2105 PyObject *dict = *dictptr;
2106 if (dict == NULL) {
2107 dict = PyDict_New();
2108 *dictptr = dict;
2109 PyDict_SetItem(dict, SWIG_This(), swig_this);
2110 }
2111 }
2112 #else
2113 PyObject *key = SWIG_This();
2114 PyObject_SetAttr(inst, key, swig_this);
2115 #endif
2116 }
2117 } else {
2118 PyObject *dict = PyDict_New();
2119 PyDict_SetItem(dict, SWIG_This(), swig_this);
2120 inst = PyInstance_NewRaw(data->newargs, dict);
2121 Py_DECREF(dict);
2122 }
2123 return inst;
2124 #else
2125 #if (PY_VERSION_HEX >= 0x02010000)
2126 PyObject *inst;
2127 PyObject *dict = PyDict_New();
2128 PyDict_SetItem(dict, SWIG_This(), swig_this);
2129 inst = PyInstance_NewRaw(data->newargs, dict);
2130 Py_DECREF(dict);
2131 return (PyObject *) inst;
2132 #else
2133 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2134 if (inst == NULL) {
2135 return NULL;
2136 }
2137 inst->in_class = (PyClassObject *)data->newargs;
2138 Py_INCREF(inst->in_class);
2139 inst->in_dict = PyDict_New();
2140 if (inst->in_dict == NULL) {
2141 Py_DECREF(inst);
2142 return NULL;
2143 }
2144 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2145 inst->in_weakreflist = NULL;
2146 #endif
2147 #ifdef Py_TPFLAGS_GC
2148 PyObject_GC_Init(inst);
2149 #endif
2150 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2151 return (PyObject *) inst;
2152 #endif
2153 #endif
2154 }
2155
2156 SWIGRUNTIME void
2157 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2158 {
2159 PyObject *dict;
2160 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2161 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2162 if (dictptr != NULL) {
2163 dict = *dictptr;
2164 if (dict == NULL) {
2165 dict = PyDict_New();
2166 *dictptr = dict;
2167 }
2168 PyDict_SetItem(dict, SWIG_This(), swig_this);
2169 return;
2170 }
2171 #endif
2172 dict = PyObject_GetAttrString(inst, "__dict__");
2173 PyDict_SetItem(dict, SWIG_This(), swig_this);
2174 Py_DECREF(dict);
2175 }
2176
2177
2178 SWIGINTERN PyObject *
2179 SWIG_Python_InitShadowInstance(PyObject *args) {
2180 PyObject *obj[2];
2181 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2182 return NULL;
2183 } else {
2184 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2185 if (sthis) {
2186 PySwigObject_append((PyObject*) sthis, obj[1]);
2187 } else {
2188 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2189 }
2190 return SWIG_Py_Void();
2191 }
2192 }
2193
2194 /* Create a new pointer object */
2195
2196 SWIGRUNTIME PyObject *
2197 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2198 if (!ptr) {
2199 return SWIG_Py_Void();
2200 } else {
2201 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2202 PyObject *robj = PySwigObject_New(ptr, type, own);
2203 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2204 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2205 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2206 if (inst) {
2207 Py_DECREF(robj);
2208 robj = inst;
2209 }
2210 }
2211 return robj;
2212 }
2213 }
2214
2215 /* Create a new packed object */
2216
2217 SWIGRUNTIMEINLINE PyObject *
2218 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2219 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2220 }
2221
2222 /* -----------------------------------------------------------------------------*
2223 * Get type list
2224 * -----------------------------------------------------------------------------*/
2225
2226 #ifdef SWIG_LINK_RUNTIME
2227 void *SWIG_ReturnGlobalTypeList(void *);
2228 #endif
2229
2230 SWIGRUNTIME swig_module_info *
2231 SWIG_Python_GetModule(void) {
2232 static void *type_pointer = (void *)0;
2233 /* first check if module already created */
2234 if (!type_pointer) {
2235 #ifdef SWIG_LINK_RUNTIME
2236 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2237 #else
2238 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2239 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2240 if (PyErr_Occurred()) {
2241 PyErr_Clear();
2242 type_pointer = (void *)0;
2243 }
2244 #endif
2245 }
2246 return (swig_module_info *) type_pointer;
2247 }
2248
2249 #if PY_MAJOR_VERSION < 2
2250 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2251 is copied out of Python/modsupport.c in python version 2.3.4 */
2252 SWIGINTERN int
2253 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2254 {
2255 PyObject *dict;
2256 if (!PyModule_Check(m)) {
2257 PyErr_SetString(PyExc_TypeError,
2258 "PyModule_AddObject() needs module as first arg");
2259 return SWIG_ERROR;
2260 }
2261 if (!o) {
2262 PyErr_SetString(PyExc_TypeError,
2263 "PyModule_AddObject() needs non-NULL value");
2264 return SWIG_ERROR;
2265 }
2266
2267 dict = PyModule_GetDict(m);
2268 if (dict == NULL) {
2269 /* Internal error -- modules must have a dict! */
2270 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2271 PyModule_GetName(m));
2272 return SWIG_ERROR;
2273 }
2274 if (PyDict_SetItemString(dict, name, o))
2275 return SWIG_ERROR;
2276 Py_DECREF(o);
2277 return SWIG_OK;
2278 }
2279 #endif
2280
2281 SWIGRUNTIME void
2282 SWIG_Python_DestroyModule(void *vptr)
2283 {
2284 swig_module_info *swig_module = (swig_module_info *) vptr;
2285 swig_type_info **types = swig_module->types;
2286 size_t i;
2287 for (i =0; i < swig_module->size; ++i) {
2288 swig_type_info *ty = types[i];
2289 if (ty->owndata) {
2290 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2291 if (data) PySwigClientData_Del(data);
2292 }
2293 }
2294 Py_DECREF(SWIG_This());
2295 }
2296
2297 SWIGRUNTIME void
2298 SWIG_Python_SetModule(swig_module_info *swig_module) {
2299 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2300
2301 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2302 swig_empty_runtime_method_table);
2303 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2304 if (pointer && module) {
2305 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2306 } else {
2307 Py_XDECREF(pointer);
2308 }
2309 }
2310
2311 /* The python cached type query */
2312 SWIGRUNTIME PyObject *
2313 SWIG_Python_TypeCache() {
2314 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2315 return cache;
2316 }
2317
2318 SWIGRUNTIME swig_type_info *
2319 SWIG_Python_TypeQuery(const char *type)
2320 {
2321 PyObject *cache = SWIG_Python_TypeCache();
2322 PyObject *key = PyString_FromString(type);
2323 PyObject *obj = PyDict_GetItem(cache, key);
2324 swig_type_info *descriptor;
2325 if (obj) {
2326 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2327 } else {
2328 swig_module_info *swig_module = SWIG_Python_GetModule();
2329 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2330 if (descriptor) {
2331 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2332 PyDict_SetItem(cache, key, obj);
2333 Py_DECREF(obj);
2334 }
2335 }
2336 Py_DECREF(key);
2337 return descriptor;
2338 }
2339
2340 /*
2341 For backward compatibility only
2342 */
2343 #define SWIG_POINTER_EXCEPTION 0
2344 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2345 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2346
2347 SWIGRUNTIME int
2348 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2349 {
2350 if (PyErr_Occurred()) {
2351 PyObject *type = 0;
2352 PyObject *value = 0;
2353 PyObject *traceback = 0;
2354 PyErr_Fetch(&type, &value, &traceback);
2355 if (value) {
2356 PyObject *old_str = PyObject_Str(value);
2357 Py_XINCREF(type);
2358 PyErr_Clear();
2359 if (infront) {
2360 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2361 } else {
2362 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2363 }
2364 Py_DECREF(old_str);
2365 }
2366 return 1;
2367 } else {
2368 return 0;
2369 }
2370 }
2371
2372 SWIGRUNTIME int
2373 SWIG_Python_ArgFail(int argnum)
2374 {
2375 if (PyErr_Occurred()) {
2376 /* add information about failing argument */
2377 char mesg[256];
2378 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2379 return SWIG_Python_AddErrMesg(mesg, 1);
2380 } else {
2381 return 0;
2382 }
2383 }
2384
2385 SWIGRUNTIMEINLINE const char *
2386 PySwigObject_GetDesc(PyObject *self)
2387 {
2388 PySwigObject *v = (PySwigObject *)self;
2389 swig_type_info *ty = v ? v->ty : 0;
2390 return ty ? ty->str : (char*)"";
2391 }
2392
2393 SWIGRUNTIME void
2394 SWIG_Python_TypeError(const char *type, PyObject *obj)
2395 {
2396 if (type) {
2397 #if defined(SWIG_COBJECT_TYPES)
2398 if (obj && PySwigObject_Check(obj)) {
2399 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2400 if (otype) {
2401 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2402 type, otype);
2403 return;
2404 }
2405 } else
2406 #endif
2407 {
2408 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2409 if (otype) {
2410 PyObject *str = PyObject_Str(obj);
2411 const char *cstr = str ? PyString_AsString(str) : 0;
2412 if (cstr) {
2413 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2414 type, otype, cstr);
2415 } else {
2416 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2417 type, otype);
2418 }
2419 Py_XDECREF(str);
2420 return;
2421 }
2422 }
2423 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2424 } else {
2425 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2426 }
2427 }
2428
2429
2430 /* Convert a pointer value, signal an exception on a type mismatch */
2431 SWIGRUNTIME void *
2432 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2433 void *result;
2434 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2435 PyErr_Clear();
2436 if (flags & SWIG_POINTER_EXCEPTION) {
2437 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2438 SWIG_Python_ArgFail(argnum);
2439 }
2440 }
2441 return result;
2442 }
2443
2444
2445 #ifdef __cplusplus
2446 #if 0
2447 { /* cc-mode */
2448 #endif
2449 }
2450 #endif
2451
2452
2453
2454 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2455
2456 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2457
2458
2459
2460 /* -------- TYPES TABLE (BEGIN) -------- */
2461
2462 #define SWIGTYPE_p_char swig_types[0]
2463 #define SWIGTYPE_p_form_ops_t swig_types[1]
2464 #define SWIGTYPE_p_int swig_types[2]
2465 #define SWIGTYPE_p_unsigned_char swig_types[3]
2466 #define SWIGTYPE_p_unsigned_int swig_types[4]
2467 #define SWIGTYPE_p_unsigned_long swig_types[5]
2468 #define SWIGTYPE_p_void swig_types[6]
2469 #define SWIGTYPE_p_wxANIHandler swig_types[7]
2470 #define SWIGTYPE_p_wxAcceleratorTable swig_types[8]
2471 #define SWIGTYPE_p_wxActivateEvent swig_types[9]
2472 #define SWIGTYPE_p_wxArrayString swig_types[10]
2473 #define SWIGTYPE_p_wxBMPHandler swig_types[11]
2474 #define SWIGTYPE_p_wxBitmap swig_types[12]
2475 #define SWIGTYPE_p_wxBitmapDataObject swig_types[13]
2476 #define SWIGTYPE_p_wxBoxSizer swig_types[14]
2477 #define SWIGTYPE_p_wxBusyCursor swig_types[15]
2478 #define SWIGTYPE_p_wxBusyInfo swig_types[16]
2479 #define SWIGTYPE_p_wxCURHandler swig_types[17]
2480 #define SWIGTYPE_p_wxCaret swig_types[18]
2481 #define SWIGTYPE_p_wxChar swig_types[19]
2482 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
2483 #define SWIGTYPE_p_wxClipboard swig_types[21]
2484 #define SWIGTYPE_p_wxClipboardLocker swig_types[22]
2485 #define SWIGTYPE_p_wxCloseEvent swig_types[23]
2486 #define SWIGTYPE_p_wxColour swig_types[24]
2487 #define SWIGTYPE_p_wxCommandEvent swig_types[25]
2488 #define SWIGTYPE_p_wxConfig swig_types[26]
2489 #define SWIGTYPE_p_wxConfigBase swig_types[27]
2490 #define SWIGTYPE_p_wxConfigPathChanger swig_types[28]
2491 #define SWIGTYPE_p_wxContextMenuEvent swig_types[29]
2492 #define SWIGTYPE_p_wxControl swig_types[30]
2493 #define SWIGTYPE_p_wxControlWithItems swig_types[31]
2494 #define SWIGTYPE_p_wxCursor swig_types[32]
2495 #define SWIGTYPE_p_wxCustomDataObject swig_types[33]
2496 #define SWIGTYPE_p_wxDC swig_types[34]
2497 #define SWIGTYPE_p_wxDataFormat swig_types[35]
2498 #define SWIGTYPE_p_wxDataObject swig_types[36]
2499 #define SWIGTYPE_p_wxDataObjectComposite swig_types[37]
2500 #define SWIGTYPE_p_wxDataObjectSimple swig_types[38]
2501 #define SWIGTYPE_p_wxDateEvent swig_types[39]
2502 #define SWIGTYPE_p_wxDateSpan swig_types[40]
2503 #define SWIGTYPE_p_wxDateTime swig_types[41]
2504 #define SWIGTYPE_p_wxDateTime__TimeZone swig_types[42]
2505 #define SWIGTYPE_p_wxDisplay swig_types[43]
2506 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[44]
2507 #define SWIGTYPE_p_wxDropFilesEvent swig_types[45]
2508 #define SWIGTYPE_p_wxDuplexMode swig_types[46]
2509 #define SWIGTYPE_p_wxEraseEvent swig_types[47]
2510 #define SWIGTYPE_p_wxEvent swig_types[48]
2511 #define SWIGTYPE_p_wxEvtHandler swig_types[49]
2512 #define SWIGTYPE_p_wxFSFile swig_types[50]
2513 #define SWIGTYPE_p_wxFileConfig swig_types[51]
2514 #define SWIGTYPE_p_wxFileDataObject swig_types[52]
2515 #define SWIGTYPE_p_wxFileHistory swig_types[53]
2516 #define SWIGTYPE_p_wxFileSystem swig_types[54]
2517 #define SWIGTYPE_p_wxFileType swig_types[55]
2518 #define SWIGTYPE_p_wxFileTypeInfo swig_types[56]
2519 #define SWIGTYPE_p_wxFlexGridSizer swig_types[57]
2520 #define SWIGTYPE_p_wxFocusEvent swig_types[58]
2521 #define SWIGTYPE_p_wxFont swig_types[59]
2522 #define SWIGTYPE_p_wxFrame swig_types[60]
2523 #define SWIGTYPE_p_wxGBSizerItem swig_types[61]
2524 #define SWIGTYPE_p_wxGIFHandler swig_types[62]
2525 #define SWIGTYPE_p_wxGridBagSizer swig_types[63]
2526 #define SWIGTYPE_p_wxGridSizer swig_types[64]
2527 #define SWIGTYPE_p_wxICOHandler swig_types[65]
2528 #define SWIGTYPE_p_wxIcon swig_types[66]
2529 #define SWIGTYPE_p_wxIconizeEvent swig_types[67]
2530 #define SWIGTYPE_p_wxIdleEvent swig_types[68]
2531 #define SWIGTYPE_p_wxImage swig_types[69]
2532 #define SWIGTYPE_p_wxImageHandler swig_types[70]
2533 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[71]
2534 #define SWIGTYPE_p_wxInitDialogEvent swig_types[72]
2535 #define SWIGTYPE_p_wxJPEGHandler swig_types[73]
2536 #define SWIGTYPE_p_wxJoystick swig_types[74]
2537 #define SWIGTYPE_p_wxJoystickEvent swig_types[75]
2538 #define SWIGTYPE_p_wxKeyEvent swig_types[76]
2539 #define SWIGTYPE_p_wxKillError swig_types[77]
2540 #define SWIGTYPE_p_wxLayoutConstraints swig_types[78]
2541 #define SWIGTYPE_p_wxLog swig_types[79]
2542 #define SWIGTYPE_p_wxLogBuffer swig_types[80]
2543 #define SWIGTYPE_p_wxLogChain swig_types[81]
2544 #define SWIGTYPE_p_wxLogGui swig_types[82]
2545 #define SWIGTYPE_p_wxLogNull swig_types[83]
2546 #define SWIGTYPE_p_wxLogStderr swig_types[84]
2547 #define SWIGTYPE_p_wxLogTextCtrl swig_types[85]
2548 #define SWIGTYPE_p_wxLogWindow swig_types[86]
2549 #define SWIGTYPE_p_wxMaximizeEvent swig_types[87]
2550 #define SWIGTYPE_p_wxMemorySize swig_types[88]
2551 #define SWIGTYPE_p_wxMenu swig_types[89]
2552 #define SWIGTYPE_p_wxMenuBar swig_types[90]
2553 #define SWIGTYPE_p_wxMenuEvent swig_types[91]
2554 #define SWIGTYPE_p_wxMenuItem swig_types[92]
2555 #define SWIGTYPE_p_wxMetafileDataObject swig_types[93]
2556 #define SWIGTYPE_p_wxMimeTypesManager swig_types[94]
2557 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[95]
2558 #define SWIGTYPE_p_wxMouseEvent swig_types[96]
2559 #define SWIGTYPE_p_wxMouseState swig_types[97]
2560 #define SWIGTYPE_p_wxMoveEvent swig_types[98]
2561 #define SWIGTYPE_p_wxMutexGuiLocker swig_types[99]
2562 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[100]
2563 #define SWIGTYPE_p_wxNcPaintEvent swig_types[101]
2564 #define SWIGTYPE_p_wxNotifyEvent swig_types[102]
2565 #define SWIGTYPE_p_wxObject swig_types[103]
2566 #define SWIGTYPE_p_wxOutputStream swig_types[104]
2567 #define SWIGTYPE_p_wxPCXHandler swig_types[105]
2568 #define SWIGTYPE_p_wxPNGHandler swig_types[106]
2569 #define SWIGTYPE_p_wxPNMHandler swig_types[107]
2570 #define SWIGTYPE_p_wxPaintEvent swig_types[108]
2571 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[109]
2572 #define SWIGTYPE_p_wxPaperSize swig_types[110]
2573 #define SWIGTYPE_p_wxPoint swig_types[111]
2574 #define SWIGTYPE_p_wxProcessEvent swig_types[112]
2575 #define SWIGTYPE_p_wxPyApp swig_types[113]
2576 #define SWIGTYPE_p_wxPyArtProvider swig_types[114]
2577 #define SWIGTYPE_p_wxPyBitmapDataObject swig_types[115]
2578 #define SWIGTYPE_p_wxPyCommandEvent swig_types[116]
2579 #define SWIGTYPE_p_wxPyDataObjectSimple swig_types[117]
2580 #define SWIGTYPE_p_wxPyDropSource swig_types[118]
2581 #define SWIGTYPE_p_wxPyDropTarget swig_types[119]
2582 #define SWIGTYPE_p_wxPyEvent swig_types[120]
2583 #define SWIGTYPE_p_wxPyFileDropTarget swig_types[121]
2584 #define SWIGTYPE_p_wxPyImageHandler swig_types[122]
2585 #define SWIGTYPE_p_wxPyLog swig_types[123]
2586 #define SWIGTYPE_p_wxPyProcess swig_types[124]
2587 #define SWIGTYPE_p_wxPySizer swig_types[125]
2588 #define SWIGTYPE_p_wxPyTextDataObject swig_types[126]
2589 #define SWIGTYPE_p_wxPyTextDropTarget swig_types[127]
2590 #define SWIGTYPE_p_wxPyTimer swig_types[128]
2591 #define SWIGTYPE_p_wxPyTipProvider swig_types[129]
2592 #define SWIGTYPE_p_wxPyValidator swig_types[130]
2593 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[131]
2594 #define SWIGTYPE_p_wxRect swig_types[132]
2595 #define SWIGTYPE_p_wxScrollEvent swig_types[133]
2596 #define SWIGTYPE_p_wxScrollWinEvent swig_types[134]
2597 #define SWIGTYPE_p_wxSetCursorEvent swig_types[135]
2598 #define SWIGTYPE_p_wxShowEvent swig_types[136]
2599 #define SWIGTYPE_p_wxSingleInstanceChecker swig_types[137]
2600 #define SWIGTYPE_p_wxSize swig_types[138]
2601 #define SWIGTYPE_p_wxSizeEvent swig_types[139]
2602 #define SWIGTYPE_p_wxSizer swig_types[140]
2603 #define SWIGTYPE_p_wxSizerItem swig_types[141]
2604 #define SWIGTYPE_p_wxSound swig_types[142]
2605 #define SWIGTYPE_p_wxStandardPaths swig_types[143]
2606 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[144]
2607 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[145]
2608 #define SWIGTYPE_p_wxStopWatch swig_types[146]
2609 #define SWIGTYPE_p_wxString swig_types[147]
2610 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[148]
2611 #define SWIGTYPE_p_wxSystemOptions swig_types[149]
2612 #define SWIGTYPE_p_wxSystemSettings swig_types[150]
2613 #define SWIGTYPE_p_wxTIFFHandler swig_types[151]
2614 #define SWIGTYPE_p_wxTextCtrl swig_types[152]
2615 #define SWIGTYPE_p_wxTextDataObject swig_types[153]
2616 #define SWIGTYPE_p_wxTimeSpan swig_types[154]
2617 #define SWIGTYPE_p_wxTimer swig_types[155]
2618 #define SWIGTYPE_p_wxTimerEvent swig_types[156]
2619 #define SWIGTYPE_p_wxTimerRunner swig_types[157]
2620 #define SWIGTYPE_p_wxTipProvider swig_types[158]
2621 #define SWIGTYPE_p_wxToolTip swig_types[159]
2622 #define SWIGTYPE_p_wxURLDataObject swig_types[160]
2623 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[161]
2624 #define SWIGTYPE_p_wxValidator swig_types[162]
2625 #define SWIGTYPE_p_wxVideoMode swig_types[163]
2626 #define SWIGTYPE_p_wxWindow swig_types[164]
2627 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[165]
2628 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[166]
2629 #define SWIGTYPE_p_wxWindowDisabler swig_types[167]
2630 #define SWIGTYPE_p_wxXPMHandler swig_types[168]
2631 static swig_type_info *swig_types[170];
2632 static swig_module_info swig_module = {swig_types, 169, 0, 0, 0, 0};
2633 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2634 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2635
2636 /* -------- TYPES TABLE (END) -------- */
2637
2638 #if (PY_VERSION_HEX <= 0x02000000)
2639 # if !defined(SWIG_PYTHON_CLASSIC)
2640 # error "This python version requires to use swig with the '-classic' option"
2641 # endif
2642 #endif
2643 #if (PY_VERSION_HEX <= 0x02020000)
2644 # error "This python version requires to use swig with the '-nomodern' option"
2645 #endif
2646 #if (PY_VERSION_HEX <= 0x02020000)
2647 # error "This python version requires to use swig with the '-nomodernargs' option"
2648 #endif
2649 #ifndef METH_O
2650 # error "This python version requires to use swig with the '-nofastunpack' option"
2651 #endif
2652
2653 /*-----------------------------------------------
2654 @(target):= _misc_.so
2655 ------------------------------------------------*/
2656 #define SWIG_init init_misc_
2657
2658 #define SWIG_name "_misc_"
2659
2660 #define SWIGVERSION 0x010329
2661
2662
2663 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2664 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2665
2666
2667 #include <stdexcept>
2668
2669
2670 namespace swig {
2671 class PyObject_ptr {
2672 protected:
2673 PyObject *_obj;
2674
2675 public:
2676 PyObject_ptr() :_obj(0)
2677 {
2678 }
2679
2680 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2681 {
2682 Py_XINCREF(_obj);
2683 }
2684
2685 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2686 {
2687 if (initial_ref) Py_XINCREF(_obj);
2688 }
2689
2690 PyObject_ptr & operator=(const PyObject_ptr& item)
2691 {
2692 Py_XINCREF(item._obj);
2693 Py_XDECREF(_obj);
2694 _obj = item._obj;
2695 return *this;
2696 }
2697
2698 ~PyObject_ptr()
2699 {
2700 Py_XDECREF(_obj);
2701 }
2702
2703 operator PyObject *() const
2704 {
2705 return _obj;
2706 }
2707
2708 PyObject *operator->() const
2709 {
2710 return _obj;
2711 }
2712 };
2713 }
2714
2715
2716 namespace swig {
2717 struct PyObject_var : PyObject_ptr {
2718 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2719
2720 PyObject_var & operator = (PyObject* obj)
2721 {
2722 Py_XDECREF(_obj);
2723 _obj = obj;
2724 return *this;
2725 }
2726 };
2727 }
2728
2729
2730 #include "wx/wxPython/wxPython.h"
2731 #include "wx/wxPython/pyclasses.h"
2732 #include "wx/wxPython/pyistream.h"
2733
2734 static const wxString wxPyEmptyString(wxEmptyString);
2735
2736
2737
2738 #define SWIG_From_long PyInt_FromLong
2739
2740
2741 SWIGINTERNINLINE PyObject *
2742 SWIG_From_int (int value)
2743 {
2744 return SWIG_From_long (value);
2745 }
2746
2747
2748 #include <limits.h>
2749 #ifndef LLONG_MIN
2750 # define LLONG_MIN LONG_LONG_MIN
2751 #endif
2752 #ifndef LLONG_MAX
2753 # define LLONG_MAX LONG_LONG_MAX
2754 #endif
2755 #ifndef ULLONG_MAX
2756 # define ULLONG_MAX ULONG_LONG_MAX
2757 #endif
2758
2759
2760 SWIGINTERN int
2761 SWIG_AsVal_long (PyObject* obj, long* val)
2762 {
2763 if (PyNumber_Check(obj)) {
2764 if (val) *val = PyInt_AsLong(obj);
2765 return SWIG_OK;
2766 }
2767 return SWIG_TypeError;
2768 }
2769
2770
2771 SWIGINTERN int
2772 SWIG_AsVal_int (PyObject * obj, int *val)
2773 {
2774 long v;
2775 int res = SWIG_AsVal_long (obj, &v);
2776 if (SWIG_IsOK(res)) {
2777 if ((v < INT_MIN || v > INT_MAX)) {
2778 return SWIG_OverflowError;
2779 } else {
2780 if (val) *val = static_cast< int >(v);
2781 }
2782 }
2783 return res;
2784 }
2785
2786 static const wxString wxPyWINDOW_DEFAULT_VARIANT(wxWINDOW_DEFAULT_VARIANT);
2787
2788 #include <wx/stockitem.h>
2789
2790 static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
2791 static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
2792 static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
2793
2794 SWIGINTERN int
2795 SWIG_AsVal_bool (PyObject *obj, bool *val)
2796 {
2797 if (obj == Py_True) {
2798 if (val) *val = true;
2799 return SWIG_OK;
2800 } else if (obj == Py_False) {
2801 if (val) *val = false;
2802 return SWIG_OK;
2803 } else {
2804 long v = 0;
2805 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
2806 if (SWIG_IsOK(res) && val) *val = v ? true : false;
2807 return res;
2808 }
2809 }
2810
2811
2812 wxMemorySize wxGetFreeMemory()
2813 { wxPyRaiseNotImplemented(); return 0; }
2814
2815
2816 SWIGINTERN int
2817 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
2818 {
2819 long v = 0;
2820 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2821 return SWIG_TypeError;
2822 }
2823 else if (val)
2824 *val = (unsigned long)v;
2825 return SWIG_OK;
2826 }
2827
2828
2829 SWIGINTERNINLINE PyObject*
2830 SWIG_From_unsigned_SS_long (unsigned long value)
2831 {
2832 return (value > LONG_MAX) ?
2833 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
2834 }
2835
2836
2837 void* wxGetXDisplay()
2838 {
2839 #ifdef __WXGTK__
2840 return wxGetDisplay();
2841 #else
2842 return NULL;
2843 #endif
2844 }
2845
2846
2847 wxWindow* FindWindowAtPointer() {
2848 wxPoint unused;
2849 return wxFindWindowAtPointer(unused);
2850 }
2851
2852
2853 void wxWakeUpMainThread() {}
2854
2855
2856 bool wxThread_IsMain() {
2857 #ifdef WXP_WITH_THREAD
2858 return wxThread::IsMain();
2859 #else
2860 return true;
2861 #endif
2862 }
2863
2864 SWIGINTERN void wxCaret_Destroy(wxCaret *self){
2865 delete self;
2866 }
2867
2868 #include <wx/snglinst.h>
2869
2870
2871 #ifdef __WXMSW__
2872 #include <wx/msw/private.h>
2873 #include <wx/dynload.h>
2874 #endif
2875
2876
2877
2878 bool wxDrawWindowOnDC(wxWindow* window, const wxDC& dc
2879 #if 0
2880 , int method
2881 #endif
2882 )
2883 {
2884 #ifdef __WXMSW__
2885 #if 0
2886 switch (method)
2887 {
2888 case 1:
2889 // This one only partially works. Appears to be an undocumented
2890 // "standard" convention that not all widgets adhear to. For
2891 // example, for some widgets backgrounds or non-client areas may
2892 // not be painted.
2893 ::SendMessage(GetHwndOf(window), WM_PAINT, (long)GetHdcOf(dc), 0);
2894 break;
2895
2896 case 2:
2897 #endif
2898 // This one works much better, nearly all widgets and their
2899 // children are captured correctly[**]. Prior to the big
2900 // background erase changes that Vadim did in 2004-2005 this
2901 // method failed badly on XP with Themes activated, most native
2902 // widgets draw only partially, if at all. Without themes it
2903 // worked just like on Win2k. After those changes this method
2904 // works very well.
2905 //
2906 // ** For example the radio buttons in a wxRadioBox are not its
2907 // children by default, but you can capture it via the panel
2908 // instead, or change RADIOBTN_PARENT_IS_RADIOBOX in radiobox.cpp.
2909 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2910 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2911 PRF_ERASEBKGND | PRF_OWNED );
2912 return true;
2913 #if 0
2914 break;
2915
2916 case 3:
2917 // This one is only defined in the latest SDK and is only
2918 // available on XP. MSDN says it is similar to sending WM_PRINT
2919 // so I expect that it will work similar to the above. Since it
2920 // is avaialble only on XP, it can't be compiled like this and
2921 // will have to be loaded dynamically.
2922 // //::PrintWindow(GetHwndOf(window), GetHdcOf(dc), 0); //break;
2923
2924 // fall through
2925
2926 case 4:
2927 // Use PrintWindow if available, or fallback to WM_PRINT
2928 // otherwise. Unfortunately using PrintWindow is even worse than
2929 // WM_PRINT. For most native widgets nothing is drawn to the dc
2930 // at all, with or without Themes.
2931 typedef BOOL (WINAPI *PrintWindow_t)(HWND, HDC, UINT);
2932 static bool s_triedToLoad = false;
2933 static PrintWindow_t pfnPrintWindow = NULL;
2934 if ( !s_triedToLoad )
2935 {
2936
2937 s_triedToLoad = true;
2938 wxDynamicLibrary dllUser32(_T("user32.dll"));
2939 if ( dllUser32.IsLoaded() )
2940 {
2941 wxLogNull nolog; // Don't report errors here
2942 pfnPrintWindow = (PrintWindow_t)dllUser32.GetSymbol(_T("PrintWindow"));
2943 }
2944 }
2945 if (pfnPrintWindow)
2946 {
2947 //printf("Using PrintWindow\n");
2948 pfnPrintWindow(GetHwndOf(window), GetHdcOf(dc), 0);
2949 }
2950 else
2951 {
2952 //printf("Using WM_PRINT\n");
2953 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2954 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2955 PRF_ERASEBKGND | PRF_OWNED );
2956 }
2957 }
2958 #endif // 0
2959 #else
2960 return false;
2961 #endif // __WXMSW__
2962 }
2963
2964
2965
2966 #include <wx/tipdlg.h>
2967
2968
2969 SWIGINTERNINLINE PyObject *
2970 SWIG_From_size_t (size_t value)
2971 {
2972 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
2973 }
2974
2975
2976 class wxPyTipProvider : public wxTipProvider {
2977 public:
2978 wxPyTipProvider(size_t currentTip)
2979 : wxTipProvider(currentTip) {}
2980
2981 DEC_PYCALLBACK_STRING__pure(GetTip);
2982 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
2983 PYPRIVATE;
2984 };
2985
2986 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
2987 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
2988
2989
2990 SWIGINTERNINLINE int
2991 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
2992 {
2993 unsigned long v;
2994 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
2995 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
2996 return res;
2997 }
2998
2999
3000 IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
3001
3002 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
3003
3004 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
3005 : wxTimer(owner, id)
3006 {
3007 if (owner == NULL)
3008 SetOwner(this);
3009 }
3010
3011
3012 SWIGINTERN swig_type_info*
3013 SWIG_pchar_descriptor()
3014 {
3015 static int init = 0;
3016 static swig_type_info* info = 0;
3017 if (!init) {
3018 info = SWIG_TypeQuery("_p_char");
3019 init = 1;
3020 }
3021 return info;
3022 }
3023
3024
3025 SWIGINTERNINLINE PyObject *
3026 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3027 {
3028 if (carray) {
3029 if (size > INT_MAX) {
3030 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3031 return pchar_descriptor ?
3032 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3033 } else {
3034 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3035 }
3036 } else {
3037 return SWIG_Py_Void();
3038 }
3039 }
3040
3041
3042 SWIGINTERNINLINE PyObject *
3043 SWIG_FromCharPtr(const char *cptr)
3044 {
3045 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3046 }
3047
3048
3049 SWIGINTERN int
3050 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3051 {
3052 unsigned long v;
3053 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3054 if (SWIG_IsOK(res)) {
3055 if ((v > UINT_MAX)) {
3056 return SWIG_OverflowError;
3057 } else {
3058 if (val) *val = static_cast< unsigned int >(v);
3059 }
3060 }
3061 return res;
3062 }
3063
3064 SWIGINTERN wxString wxLog_TimeStamp(){
3065 wxString msg;
3066 wxLog::TimeStamp(&msg);
3067 return msg;
3068 }
3069 SWIGINTERN void wxLog_Destroy(wxLog *self){ delete self; }
3070 // Make some wrappers that double any % signs so they are 'escaped'
3071 void wxPyLogFatalError(const wxString& msg)
3072 {
3073 wxString m(msg);
3074 m.Replace(wxT("%"), wxT("%%"));
3075 wxLogFatalError(m);
3076 }
3077
3078 void wxPyLogError(const wxString& msg)
3079 {
3080 wxString m(msg);
3081 m.Replace(wxT("%"), wxT("%%"));
3082 wxLogError(m);
3083 }
3084
3085 void wxPyLogWarning(const wxString& msg)
3086 {
3087 wxString m(msg);
3088 m.Replace(wxT("%"), wxT("%%"));
3089 wxLogWarning(m);
3090 }
3091
3092 void wxPyLogMessage(const wxString& msg)
3093 {
3094 wxString m(msg);
3095 m.Replace(wxT("%"), wxT("%%"));
3096 wxLogMessage(m);
3097 }
3098
3099 void wxPyLogInfo(const wxString& msg)
3100 {
3101 wxString m(msg);
3102 m.Replace(wxT("%"), wxT("%%"));
3103 wxLogInfo(m);
3104 }
3105
3106 void wxPyLogDebug(const wxString& msg)
3107 {
3108 wxString m(msg);
3109 m.Replace(wxT("%"), wxT("%%"));
3110 wxLogDebug(m);
3111 }
3112
3113 void wxPyLogVerbose(const wxString& msg)
3114 {
3115 wxString m(msg);
3116 m.Replace(wxT("%"), wxT("%%"));
3117 wxLogVerbose(m);
3118 }
3119
3120 void wxPyLogStatus(const wxString& msg)
3121 {
3122 wxString m(msg);
3123 m.Replace(wxT("%"), wxT("%%"));
3124 wxLogStatus(m);
3125 }
3126
3127 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
3128 {
3129 wxString m(msg);
3130 m.Replace(wxT("%"), wxT("%%"));
3131 wxLogStatus(pFrame, m);
3132 }
3133
3134 void wxPyLogSysError(const wxString& msg)
3135 {
3136 wxString m(msg);
3137 m.Replace(wxT("%"), wxT("%%"));
3138 wxLogSysError(m);
3139 }
3140
3141 void wxPyLogGeneric(unsigned long level, const wxString& msg)
3142 {
3143 wxString m(msg);
3144 m.Replace(wxT("%"), wxT("%%"));
3145 wxLogGeneric(level, m);
3146 }
3147
3148 void wxPyLogTrace(unsigned long mask, const wxString& msg)
3149 {
3150 wxString m(msg);
3151 m.Replace(wxT("%"), wxT("%%"));
3152 wxLogTrace(mask, m);
3153 }
3154
3155 void wxPyLogTrace(const wxString& mask, const wxString& msg)
3156 {
3157 wxString m(msg);
3158 m.Replace(wxT("%"), wxT("%%"));
3159 wxLogTrace(mask, m);
3160 }
3161
3162
3163
3164 // A wxLog class that can be derived from in wxPython
3165 class wxPyLog : public wxLog {
3166 public:
3167 wxPyLog() : wxLog() {}
3168
3169 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
3170 bool found;
3171 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3172 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
3173 PyObject* s = wx2PyString(szString);
3174 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
3175 Py_DECREF(s);
3176 }
3177 wxPyEndBlockThreads(blocked);
3178 if (! found)
3179 wxLog::DoLog(level, szString, t);
3180 }
3181
3182 virtual void DoLogString(const wxChar *szString, time_t t) {
3183 bool found;
3184 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3185 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
3186 PyObject* s = wx2PyString(szString);
3187 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
3188 Py_DECREF(s);
3189 }
3190 wxPyEndBlockThreads(blocked);
3191 if (! found)
3192 wxLog::DoLogString(szString, t);
3193 }
3194
3195 DEC_PYCALLBACK_VOID_(Flush);
3196 PYPRIVATE;
3197 };
3198 IMP_PYCALLBACK_VOID_(wxPyLog, wxLog, Flush);
3199
3200
3201
3202
3203 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
3204
3205
3206 #include <wx/joystick.h>
3207
3208
3209 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
3210 // A C++ stub class for wxJoystick for platforms that don't have it.
3211 class wxJoystick : public wxObject {
3212 public:
3213 wxJoystick(int joystick = wxJOYSTICK1) {
3214 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3215 PyErr_SetString(PyExc_NotImplementedError,
3216 "wxJoystick is not available on this platform.");
3217 wxPyEndBlockThreads(blocked);
3218 }
3219 wxPoint GetPosition() { return wxPoint(-1,-1); }
3220 int GetZPosition() { return -1; }
3221 int GetButtonState() { return -1; }
3222 int GetPOVPosition() { return -1; }
3223 int GetPOVCTSPosition() { return -1; }
3224 int GetRudderPosition() { return -1; }
3225 int GetUPosition() { return -1; }
3226 int GetVPosition() { return -1; }
3227 int GetMovementThreshold() { return -1; }
3228 void SetMovementThreshold(int threshold) {}
3229
3230 bool IsOk(void) { return false; }
3231 int GetNumberJoysticks() { return -1; }
3232 int GetManufacturerId() { return -1; }
3233 int GetProductId() { return -1; }
3234 wxString GetProductName() { return wxEmptyString; }
3235 int GetXMin() { return -1; }
3236 int GetYMin() { return -1; }
3237 int GetZMin() { return -1; }
3238 int GetXMax() { return -1; }
3239 int GetYMax() { return -1; }
3240 int GetZMax() { return -1; }
3241 int GetNumberButtons() { return -1; }
3242 int GetNumberAxes() { return -1; }
3243 int GetMaxButtons() { return -1; }
3244 int GetMaxAxes() { return -1; }
3245 int GetPollingMin() { return -1; }
3246 int GetPollingMax() { return -1; }
3247 int GetRudderMin() { return -1; }
3248 int GetRudderMax() { return -1; }
3249 int GetUMin() { return -1; }
3250 int GetUMax() { return -1; }
3251 int GetVMin() { return -1; }
3252 int GetVMax() { return -1; }
3253
3254 bool HasRudder() { return false; }
3255 bool HasZ() { return false; }
3256 bool HasU() { return false; }
3257 bool HasV() { return false; }
3258 bool HasPOV() { return false; }
3259 bool HasPOV4Dir() { return false; }
3260 bool HasPOVCTS() { return false; }
3261
3262 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
3263 bool ReleaseCapture() { return false; }
3264 };
3265 #endif
3266
3267
3268 #include <wx/sound.h>
3269
3270
3271 #if !wxUSE_SOUND
3272 // A C++ stub class for wxWave for platforms that don't have it.
3273 class wxSound : public wxObject
3274 {
3275 public:
3276 wxSound() {
3277 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3278 PyErr_SetString(PyExc_NotImplementedError,
3279 "wxSound is not available on this platform.");
3280 wxPyEndBlockThreads(blocked);
3281 }
3282 wxSound(const wxString&/*, bool*/) {
3283 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3284 PyErr_SetString(PyExc_NotImplementedError,
3285 "wxSound is not available on this platform.");
3286 wxPyEndBlockThreads(blocked);
3287 }
3288 wxSound(int, const wxByte*) {
3289 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3290 PyErr_SetString(PyExc_NotImplementedError,
3291 "wxSound is not available on this platform.");
3292 wxPyEndBlockThreads(blocked);
3293 }
3294
3295 ~wxSound() {};
3296
3297 bool Create(const wxString&/*, bool*/) { return false; }
3298 bool Create(int, const wxByte*) { return false; };
3299 bool IsOk() { return false; };
3300 bool Play(unsigned) const { return false; }
3301 static bool Play(const wxString&, unsigned) { return false; }
3302 static void Stop() {}
3303 };
3304
3305 #endif
3306
3307 SWIGINTERN wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
3308 if (fileName.Length() == 0)
3309 return new wxSound;
3310 else
3311 return new wxSound(fileName);
3312 }
3313 SWIGINTERN wxSound *new_wxSound(PyObject *data){
3314 unsigned char* buffer; int size;
3315 wxSound *sound = NULL;
3316
3317 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3318 if (!PyArg_Parse(data, "t#", &buffer, &size))
3319 goto done;
3320 sound = new wxSound(size, buffer);
3321 done:
3322 wxPyEndBlockThreads(blocked);
3323 return sound;
3324 }
3325 SWIGINTERN bool wxSound_CreateFromData(wxSound *self,PyObject *data){
3326 #ifndef __WXMAC__
3327 unsigned char* buffer;
3328 int size;
3329 bool rv = false;
3330
3331 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3332 if (!PyArg_Parse(data, "t#", &buffer, &size))
3333 goto done;
3334 rv = self->Create(size, buffer);
3335 done:
3336 wxPyEndBlockThreads(blocked);
3337 return rv;
3338 #else
3339 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3340 PyErr_SetString(PyExc_NotImplementedError,
3341 "Create from data is not available on this platform.");
3342 wxPyEndBlockThreads(blocked);
3343 return false;
3344 #endif
3345 }
3346
3347 #include <wx/mimetype.h>
3348
3349 SWIGINTERN PyObject *wxFileType_GetMimeType(wxFileType *self){
3350 wxString str;
3351 if (self->GetMimeType(&str))
3352 return wx2PyString(str);
3353 else
3354 RETURN_NONE();
3355 }
3356 SWIGINTERN PyObject *wxFileType_GetMimeTypes(wxFileType *self){
3357 wxArrayString arr;
3358 if (self->GetMimeTypes(arr))
3359 return wxArrayString2PyList_helper(arr);
3360 else
3361 RETURN_NONE();
3362 }
3363 SWIGINTERN PyObject *wxFileType_GetExtensions(wxFileType *self){
3364 wxArrayString arr;
3365 if (self->GetExtensions(arr))
3366 return wxArrayString2PyList_helper(arr);
3367 else
3368 RETURN_NONE();
3369 }
3370 SWIGINTERN wxIcon *wxFileType_GetIcon(wxFileType *self){
3371 wxIconLocation loc;
3372 if (self->GetIcon(&loc))
3373 return new wxIcon(loc);
3374 else
3375 return NULL;
3376 }
3377 SWIGINTERN PyObject *wxFileType_GetIconInfo(wxFileType *self){
3378 wxIconLocation loc;
3379 if (self->GetIcon(&loc)) {
3380 wxString iconFile = loc.GetFileName();
3381 int iconIndex = -1;
3382
3383
3384
3385 // Make a tuple and put the values in it
3386 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3387 PyObject* tuple = PyTuple_New(3);
3388 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
3389 wxT("wxIcon"), true));
3390 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
3391 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
3392 wxPyEndBlockThreads(blocked);
3393 return tuple;
3394 }
3395 else
3396 RETURN_NONE();
3397 }
3398 SWIGINTERN PyObject *wxFileType_GetDescription(wxFileType *self){
3399 wxString str;
3400 if (self->GetDescription(&str))
3401 return wx2PyString(str);
3402 else
3403 RETURN_NONE();
3404 }
3405 SWIGINTERN PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3406 wxString str;
3407 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3408 return wx2PyString(str);
3409 else
3410 RETURN_NONE();
3411 }
3412 SWIGINTERN PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3413 wxString str;
3414 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3415 return wx2PyString(str);
3416 else
3417 RETURN_NONE();
3418 }
3419 SWIGINTERN PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3420 wxArrayString verbs;
3421 wxArrayString commands;
3422 if (self->GetAllCommands(&verbs, &commands,
3423 wxFileType::MessageParameters(filename, mimetype))) {
3424 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3425 PyObject* tuple = PyTuple_New(2);
3426 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
3427 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
3428 wxPyEndBlockThreads(blocked);
3429 return tuple;
3430 }
3431 else
3432 RETURN_NONE();
3433 }
3434 SWIGINTERN wxString wxFileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3435 return wxFileType::ExpandCommand(command,
3436 wxFileType::MessageParameters(filename, mimetype));
3437 }
3438 SWIGINTERN PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
3439 wxArrayString arr;
3440 self->EnumAllFileTypes(arr);
3441 return wxArrayString2PyList_helper(arr);
3442 }
3443
3444 #include <wx/artprov.h>
3445
3446 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
3447 static const wxString wxPyART_MENU(wxART_MENU);
3448 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
3449 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
3450 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
3451 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
3452 static const wxString wxPyART_BUTTON(wxART_BUTTON);
3453 static const wxString wxPyART_OTHER(wxART_OTHER);
3454 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
3455 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
3456 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
3457 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
3458 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
3459 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
3460 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
3461 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
3462 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
3463 static const wxString wxPyART_GO_UP(wxART_GO_UP);
3464 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
3465 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
3466 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
3467 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
3468 static const wxString wxPyART_FILE_SAVE(wxART_FILE_SAVE);
3469 static const wxString wxPyART_FILE_SAVE_AS(wxART_FILE_SAVE_AS);
3470 static const wxString wxPyART_PRINT(wxART_PRINT);
3471 static const wxString wxPyART_HELP(wxART_HELP);
3472 static const wxString wxPyART_TIP(wxART_TIP);
3473 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
3474 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
3475 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
3476 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
3477 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
3478 static const wxString wxPyART_CDROM(wxART_CDROM);
3479 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
3480 static const wxString wxPyART_FOLDER(wxART_FOLDER);
3481 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
3482 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
3483 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
3484 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
3485 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
3486 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
3487 static const wxString wxPyART_ERROR(wxART_ERROR);
3488 static const wxString wxPyART_QUESTION(wxART_QUESTION);
3489 static const wxString wxPyART_WARNING(wxART_WARNING);
3490 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
3491 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
3492 static const wxString wxPyART_COPY(wxART_COPY);
3493 static const wxString wxPyART_CUT(wxART_CUT);
3494 static const wxString wxPyART_PASTE(wxART_PASTE);
3495 static const wxString wxPyART_DELETE(wxART_DELETE);
3496 static const wxString wxPyART_NEW(wxART_NEW);
3497 static const wxString wxPyART_UNDO(wxART_UNDO);
3498 static const wxString wxPyART_REDO(wxART_REDO);
3499 static const wxString wxPyART_QUIT(wxART_QUIT);
3500 static const wxString wxPyART_FIND(wxART_FIND);
3501 static const wxString wxPyART_FIND_AND_REPLACE(wxART_FIND_AND_REPLACE);
3502 // Python aware wxArtProvider
3503 class wxPyArtProvider : public wxArtProvider {
3504 public:
3505
3506 virtual wxBitmap CreateBitmap(const wxArtID& id,
3507 const wxArtClient& client,
3508 const wxSize& size) {
3509 wxBitmap rval = wxNullBitmap;
3510 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3511 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
3512 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
3513 PyObject* ro;
3514 wxBitmap* ptr;
3515 PyObject* s1, *s2;
3516 s1 = wx2PyString(id);
3517 s2 = wx2PyString(client);
3518 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
3519 Py_DECREF(so);
3520 Py_DECREF(s1);
3521 Py_DECREF(s2);
3522 if (ro) {
3523 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
3524 rval = *ptr;
3525 Py_DECREF(ro);
3526 }
3527 }
3528 wxPyEndBlockThreads(blocked);
3529 return rval;
3530 }
3531
3532 PYPRIVATE;
3533 };
3534
3535 SWIGINTERN void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
3536
3537
3538
3539 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
3540 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3541 PyObject* ret = PyTuple_New(3);
3542 if (ret) {
3543 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
3544 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
3545 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
3546 }
3547 wxPyEndBlockThreads(blocked);
3548 return ret;
3549 }
3550
3551 SWIGINTERN PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
3552 bool cont;
3553 long index = 0;
3554 wxString value;
3555
3556 cont = self->GetFirstGroup(value, index);
3557 return __EnumerationHelper(cont, value, index);
3558 }
3559 SWIGINTERN PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
3560 bool cont;
3561 wxString value;
3562
3563 cont = self->GetNextGroup(value, index);
3564 return __EnumerationHelper(cont, value, index);
3565 }
3566 SWIGINTERN PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
3567 bool cont;
3568 long index = 0;
3569 wxString value;
3570
3571 cont = self->GetFirstEntry(value, index);
3572 return __EnumerationHelper(cont, value, index);
3573 }
3574 SWIGINTERN PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
3575 bool cont;
3576 wxString value;
3577
3578 cont = self->GetNextEntry(value, index);
3579 return __EnumerationHelper(cont, value, index);
3580 }
3581 SWIGINTERN long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
3582 long rv;
3583 self->Read(key, &rv, defaultVal);
3584 return rv;
3585 }
3586
3587 SWIGINTERN int
3588 SWIG_AsVal_double (PyObject *obj, double* val)
3589 {
3590 if (PyNumber_Check(obj)) {
3591 if (val) *val = PyFloat_AsDouble(obj);
3592 return SWIG_OK;
3593 }
3594 return SWIG_TypeError;
3595 }
3596
3597 SWIGINTERN double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
3598 double rv;
3599 self->Read(key, &rv, defaultVal);
3600 return rv;
3601 }
3602
3603 #define SWIG_From_double PyFloat_FromDouble
3604
3605 SWIGINTERN bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
3606 bool rv;
3607 self->Read(key, &rv, defaultVal);
3608 return rv;
3609 }
3610
3611 #include <wx/datetime.h>
3612
3613 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
3614 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
3615
3616 #define LOCAL_TZ wxDateTime::Local
3617
3618 SWIGINTERN PyObject *wxDateTime_GetAmPmStrings(){
3619 wxString am;
3620 wxString pm;
3621 wxDateTime::GetAmPmStrings(&am, &pm);
3622 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3623 PyObject* tup = PyTuple_New(2);
3624 PyTuple_SET_ITEM(tup, 0, wx2PyString(am));
3625 PyTuple_SET_ITEM(tup, 1, wx2PyString(pm));
3626 wxPyEndBlockThreads(blocked);
3627 return tup;
3628 }
3629
3630 SWIGINTERNINLINE PyObject *
3631 SWIG_From_unsigned_SS_int (unsigned int value)
3632 {
3633 return SWIG_From_unsigned_SS_long (value);
3634 }
3635
3636 SWIGINTERN wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
3637 SWIGINTERN wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
3638 SWIGINTERN wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
3639 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
3640 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
3641 SWIGINTERN bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
3642 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
3643 return (*self < *other);
3644 }
3645 SWIGINTERN bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
3646 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
3647 return (*self <= *other);
3648 }
3649 SWIGINTERN bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
3650 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
3651 return (*self > *other);
3652 }
3653 SWIGINTERN bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
3654 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
3655 return (*self >= *other);
3656 }
3657 SWIGINTERN bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
3658 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
3659 return (*self == *other);
3660 }
3661 SWIGINTERN bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
3662 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
3663 return (*self != *other);
3664 }
3665 SWIGINTERN int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
3666 const wxChar* rv;
3667 const wxChar* _date = date;
3668 rv = self->ParseRfc822Date(_date);
3669 if (rv == NULL) return -1;
3670 return rv - _date;
3671 }
3672 SWIGINTERN int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
3673 const wxChar* rv;
3674 const wxChar* _date = date;
3675 rv = self->ParseFormat(_date, format, dateDef);
3676 if (rv == NULL) return -1;
3677 return rv - _date;
3678 }
3679 SWIGINTERN int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
3680 const wxChar* rv;
3681 const wxChar* _datetime = datetime;
3682 rv = self->ParseDateTime(_datetime);
3683 if (rv == NULL) return -1;
3684 return rv - _datetime;
3685 }
3686 SWIGINTERN int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
3687 const wxChar* rv;
3688 const wxChar* _date = date;
3689 rv = self->ParseDate(_date);
3690 if (rv == NULL) return -1;
3691 return rv - _date;
3692 }
3693 SWIGINTERN int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
3694 const wxChar* rv;
3695 const wxChar* _time = time;
3696 rv = self->ParseTime(_time);
3697 if (rv == NULL) return -1;
3698 return rv - _time;
3699 }
3700 SWIGINTERN wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
3701 SWIGINTERN wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
3702 SWIGINTERN wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
3703 SWIGINTERN wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
3704 SWIGINTERN bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
3705 SWIGINTERN bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
3706 SWIGINTERN bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
3707 SWIGINTERN bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
3708 SWIGINTERN bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
3709 SWIGINTERN bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
3710 SWIGINTERN wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
3711 SWIGINTERN wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
3712 SWIGINTERN wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
3713 SWIGINTERN wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
3714 SWIGINTERN bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
3715 SWIGINTERN bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
3716
3717 #include <wx/dataobj.h>
3718
3719 SWIGINTERN PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
3720 size_t count = self->GetFormatCount(dir);
3721 wxDataFormat* formats = new wxDataFormat[count];
3722 self->GetAllFormats(formats, dir);
3723
3724 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3725 PyObject* list = PyList_New(count);
3726 for (size_t i=0; i<count; i++) {
3727 wxDataFormat* format = new wxDataFormat(formats[i]);
3728 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
3729 PyList_SET_ITEM(list, i, obj); // PyList_SET_ITEM steals a reference
3730 }
3731 wxPyEndBlockThreads(blocked);
3732 delete [] formats;
3733 return list;
3734 }
3735 SWIGINTERN PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
3736 PyObject* rval = NULL;
3737 size_t size = self->GetDataSize(format);
3738 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3739 if (size) {
3740 char* buf = new char[size];
3741 if (self->GetDataHere(format, buf))
3742 rval = PyString_FromStringAndSize(buf, size);
3743 delete [] buf;
3744 }
3745 if (! rval) {
3746 rval = Py_None;
3747 Py_INCREF(rval);
3748 }
3749 wxPyEndBlockThreads(blocked);
3750 return rval;
3751 }
3752 SWIGINTERN bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
3753 bool rval;
3754 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3755 if (PyString_Check(data)) {
3756 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
3757 }
3758 else {
3759 // raise a TypeError if not a string
3760 PyErr_SetString(PyExc_TypeError, "String expected.");
3761 rval = false;
3762 }
3763 wxPyEndBlockThreads(blocked);
3764 return rval;
3765 }
3766 SWIGINTERN PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
3767 PyObject* rval = NULL;
3768 size_t size = self->GetDataSize();
3769 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3770 if (size) {
3771 char* buf = new char[size];
3772 if (self->GetDataHere(buf))
3773 rval = PyString_FromStringAndSize(buf, size);
3774 delete [] buf;
3775 }
3776 if (! rval) {
3777 rval = Py_None;
3778 Py_INCREF(rval);
3779 }
3780 wxPyEndBlockThreads(blocked);
3781 return rval;
3782 }
3783 SWIGINTERN bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
3784 bool rval;
3785 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3786 if (PyString_Check(data)) {
3787 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3788 }
3789 else {
3790 // raise a TypeError if not a string
3791 PyErr_SetString(PyExc_TypeError, "String expected.");
3792 rval = false;
3793 }
3794 wxPyEndBlockThreads(blocked);
3795 return rval;
3796 }
3797 // Create a new class for wxPython to use
3798 class wxPyDataObjectSimple : public wxDataObjectSimple {
3799 public:
3800 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
3801 : wxDataObjectSimple(format) {}
3802
3803 DEC_PYCALLBACK_SIZET__const(GetDataSize);
3804 bool GetDataHere(void *buf) const;
3805 bool SetData(size_t len, const void *buf) const;
3806 PYPRIVATE;
3807 };
3808
3809 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
3810
3811 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
3812 // We need to get the data for this object and write it to buf. I think
3813 // the best way to do this for wxPython is to have the Python method
3814 // return either a string or None and then act appropriately with the
3815 // C++ version.
3816
3817 bool rval = false;
3818 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3819 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
3820 PyObject* ro;
3821 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3822 if (ro) {
3823 rval = (ro != Py_None && PyString_Check(ro));
3824 if (rval)
3825 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
3826 Py_DECREF(ro);
3827 }
3828 }
3829 wxPyEndBlockThreads(blocked);
3830 return rval;
3831 }
3832
3833 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) const{
3834 // For this one we simply need to make a string from buf and len
3835 // and send it to the Python method.
3836 bool rval = false;
3837 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3838 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
3839 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
3840 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
3841 Py_DECREF(data);
3842 }
3843 wxPyEndBlockThreads(blocked);
3844 return rval;
3845 }
3846
3847 // Create a new class for wxPython to use
3848 class wxPyTextDataObject : public wxTextDataObject {
3849 public:
3850 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
3851 : wxTextDataObject(text) {}
3852
3853 DEC_PYCALLBACK_SIZET__const(GetTextLength);
3854 DEC_PYCALLBACK_STRING__const(GetText);
3855 DEC_PYCALLBACK__STRING(SetText);
3856 PYPRIVATE;
3857 };
3858
3859 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
3860 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
3861 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
3862
3863
3864 // Create a new class for wxPython to use
3865 class wxPyBitmapDataObject : public wxBitmapDataObject {
3866 public:
3867 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
3868 : wxBitmapDataObject(bitmap) {}
3869
3870 wxBitmap GetBitmap() const;
3871 void SetBitmap(const wxBitmap& bitmap);
3872 PYPRIVATE;
3873 };
3874
3875 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
3876 wxBitmap* rval = &wxNullBitmap;
3877 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3878 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
3879 PyObject* ro;
3880 wxBitmap* ptr;
3881 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3882 if (ro) {
3883 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
3884 rval = ptr;
3885 Py_DECREF(ro);
3886 }
3887 }
3888 wxPyEndBlockThreads(blocked);
3889 return *rval;
3890 }
3891
3892 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
3893 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3894 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
3895 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
3896 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
3897 Py_DECREF(bo);
3898 }
3899 wxPyEndBlockThreads(blocked);
3900 }
3901
3902 SWIGINTERN wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
3903 return new wxCustomDataObject(wxDataFormat(formatName));
3904 }
3905 SWIGINTERN bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
3906 bool rval;
3907 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3908 if (PyString_Check(data)) {
3909 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3910 }
3911 else {
3912 // raise a TypeError if not a string
3913 PyErr_SetString(PyExc_TypeError, "String expected.");
3914 rval = false;
3915 }
3916 wxPyEndBlockThreads(blocked);
3917 return rval;
3918 }
3919 SWIGINTERN PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
3920 PyObject* obj;
3921 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3922 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
3923 wxPyEndBlockThreads(blocked);
3924 return obj;
3925 }
3926
3927 class wxMetafileDataObject : public wxDataObjectSimple
3928 {
3929 public:
3930 wxMetafileDataObject() { wxPyRaiseNotImplemented(); }
3931 };
3932
3933
3934 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
3935
3936
3937 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
3938 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
3939 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
3940 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
3941 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
3942
3943
3944 class wxPyTextDropTarget : public wxTextDropTarget {
3945 public:
3946 wxPyTextDropTarget() {}
3947
3948 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
3949
3950 DEC_PYCALLBACK__(OnLeave);
3951 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3952 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3953 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3954 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3955
3956 PYPRIVATE;
3957 };
3958
3959 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
3960 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
3961 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
3962 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
3963 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
3964 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
3965
3966
3967
3968 class wxPyFileDropTarget : public wxFileDropTarget {
3969 public:
3970 wxPyFileDropTarget() {}
3971
3972 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
3973
3974 DEC_PYCALLBACK__(OnLeave);
3975 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3976 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3977 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3978 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3979
3980 PYPRIVATE;
3981 };
3982
3983 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
3984 const wxArrayString& filenames) {
3985 bool rval = false;
3986 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3987 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
3988 PyObject* list = wxArrayString2PyList_helper(filenames);
3989 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
3990 Py_DECREF(list);
3991 }
3992 wxPyEndBlockThreads(blocked);
3993 return rval;
3994 }
3995
3996
3997
3998 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
3999 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
4000 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
4001 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
4002 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
4003
4004
4005
4006
4007 SWIGINTERN bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
4008
4009 #include <wx/display.h>
4010
4011 SWIGINTERN bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
4012 SWIGINTERN bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
4013
4014 #if !wxUSE_DISPLAY
4015 const wxVideoMode wxDefaultVideoMode;
4016 #endif
4017
4018 SWIGINTERN PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4019 #if wxUSE_DISPLAY
4020 PyObject* pyList = NULL;
4021 wxArrayVideoModes arr = self->GetModes(mode);
4022 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4023 pyList = PyList_New(0);
4024 for (size_t i=0; i < arr.GetCount(); i++)
4025 {
4026 wxVideoMode* m = new wxVideoMode(arr.Item(i));
4027 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
4028 PyList_Append(pyList, pyObj);
4029 Py_DECREF(pyObj);
4030 }
4031 wxPyEndBlockThreads(blocked);
4032 return pyList;
4033 #else
4034 wxPyRaiseNotImplemented();
4035 return NULL;
4036 #endif
4037 }
4038 SWIGINTERN wxVideoMode wxDisplay_GetCurrentMode(wxDisplay const *self){
4039 #if wxUSE_DISPLAY
4040 return self->GetCurrentMode();
4041 #else
4042 wxPyRaiseNotImplemented();
4043 return wxDefaultVideoMode;
4044 #endif
4045 }
4046 SWIGINTERN bool wxDisplay_ChangeMode(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4047 #if wxUSE_DISPLAY
4048 return self->ChangeMode(mode);
4049 #else
4050 wxPyRaiseNotImplemented();
4051 return false;
4052 #endif
4053 }
4054 SWIGINTERN void wxDisplay_ResetMode(wxDisplay *self){
4055 #if wxUSE_DISPLAY
4056 self->ResetMode();
4057 #else
4058 wxPyRaiseNotImplemented();
4059 #endif
4060 }
4061
4062 #include <wx/stdpaths.h>
4063
4064 SWIGINTERN wxStandardPaths *wxStandardPaths_Get(){
4065 return (wxStandardPaths*) &wxStandardPaths::Get();
4066 }
4067 #ifdef __cplusplus
4068 extern "C" {
4069 #endif
4070 SWIGINTERN PyObject *_wrap_SystemSettings_GetColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4071 PyObject *resultobj = 0;
4072 wxSystemColour arg1 ;
4073 wxColour result;
4074 int val1 ;
4075 int ecode1 = 0 ;
4076 PyObject * obj0 = 0 ;
4077 char * kwnames[] = {
4078 (char *) "index", NULL
4079 };
4080
4081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) SWIG_fail;
4082 ecode1 = SWIG_AsVal_int(obj0, &val1);
4083 if (!SWIG_IsOK(ecode1)) {
4084 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetColour" "', expected argument " "1"" of type '" "wxSystemColour""'");
4085 }
4086 arg1 = static_cast< wxSystemColour >(val1);
4087 {
4088 if (!wxPyCheckForApp()) SWIG_fail;
4089 PyThreadState* __tstate = wxPyBeginAllowThreads();
4090 result = wxSystemSettings::GetColour(arg1);
4091 wxPyEndAllowThreads(__tstate);
4092 if (PyErr_Occurred()) SWIG_fail;
4093 }
4094 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
4095 return resultobj;
4096 fail:
4097 return NULL;
4098 }
4099
4100
4101 SWIGINTERN PyObject *_wrap_SystemSettings_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4102 PyObject *resultobj = 0;
4103 wxSystemFont arg1 ;
4104 wxFont result;
4105 int val1 ;
4106 int ecode1 = 0 ;
4107 PyObject * obj0 = 0 ;
4108 char * kwnames[] = {
4109 (char *) "index", NULL
4110 };
4111
4112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) SWIG_fail;
4113 ecode1 = SWIG_AsVal_int(obj0, &val1);
4114 if (!SWIG_IsOK(ecode1)) {
4115 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetFont" "', expected argument " "1"" of type '" "wxSystemFont""'");
4116 }
4117 arg1 = static_cast< wxSystemFont >(val1);
4118 {
4119 if (!wxPyCheckForApp()) SWIG_fail;
4120 PyThreadState* __tstate = wxPyBeginAllowThreads();
4121 result = wxSystemSettings::GetFont(arg1);
4122 wxPyEndAllowThreads(__tstate);
4123 if (PyErr_Occurred()) SWIG_fail;
4124 }
4125 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
4126 return resultobj;
4127 fail:
4128 return NULL;
4129 }
4130
4131
4132 SWIGINTERN PyObject *_wrap_SystemSettings_GetMetric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4133 PyObject *resultobj = 0;
4134 wxSystemMetric arg1 ;
4135 wxWindow *arg2 = (wxWindow *) NULL ;
4136 int result;
4137 int val1 ;
4138 int ecode1 = 0 ;
4139 void *argp2 = 0 ;
4140 int res2 = 0 ;
4141 PyObject * obj0 = 0 ;
4142 PyObject * obj1 = 0 ;
4143 char * kwnames[] = {
4144 (char *) "index",(char *) "win", NULL
4145 };
4146
4147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SystemSettings_GetMetric",kwnames,&obj0,&obj1)) SWIG_fail;
4148 ecode1 = SWIG_AsVal_int(obj0, &val1);
4149 if (!SWIG_IsOK(ecode1)) {
4150 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetMetric" "', expected argument " "1"" of type '" "wxSystemMetric""'");
4151 }
4152 arg1 = static_cast< wxSystemMetric >(val1);
4153 if (obj1) {
4154 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
4155 if (!SWIG_IsOK(res2)) {
4156 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SystemSettings_GetMetric" "', expected argument " "2"" of type '" "wxWindow *""'");
4157 }
4158 arg2 = reinterpret_cast< wxWindow * >(argp2);
4159 }
4160 {
4161 if (!wxPyCheckForApp()) SWIG_fail;
4162 PyThreadState* __tstate = wxPyBeginAllowThreads();
4163 result = (int)wxSystemSettings::GetMetric(arg1,arg2);
4164 wxPyEndAllowThreads(__tstate);
4165 if (PyErr_Occurred()) SWIG_fail;
4166 }
4167 resultobj = SWIG_From_int(static_cast< int >(result));
4168 return resultobj;
4169 fail:
4170 return NULL;
4171 }
4172
4173
4174 SWIGINTERN PyObject *_wrap_SystemSettings_HasFeature(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4175 PyObject *resultobj = 0;
4176 wxSystemFeature arg1 ;
4177 bool result;
4178 int val1 ;
4179 int ecode1 = 0 ;
4180 PyObject * obj0 = 0 ;
4181 char * kwnames[] = {
4182 (char *) "index", NULL
4183 };
4184
4185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) SWIG_fail;
4186 ecode1 = SWIG_AsVal_int(obj0, &val1);
4187 if (!SWIG_IsOK(ecode1)) {
4188 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_HasFeature" "', expected argument " "1"" of type '" "wxSystemFeature""'");
4189 }
4190 arg1 = static_cast< wxSystemFeature >(val1);
4191 {
4192 if (!wxPyCheckForApp()) SWIG_fail;
4193 PyThreadState* __tstate = wxPyBeginAllowThreads();
4194 result = (bool)wxSystemSettings::HasFeature(arg1);
4195 wxPyEndAllowThreads(__tstate);
4196 if (PyErr_Occurred()) SWIG_fail;
4197 }
4198 {
4199 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4200 }
4201 return resultobj;
4202 fail:
4203 return NULL;
4204 }
4205
4206
4207 SWIGINTERN PyObject *_wrap_SystemSettings_GetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4208 PyObject *resultobj = 0;
4209 wxSystemScreenType result;
4210
4211 if (!SWIG_Python_UnpackTuple(args,"SystemSettings_GetScreenType",0,0,0)) SWIG_fail;
4212 {
4213 if (!wxPyCheckForApp()) SWIG_fail;
4214 PyThreadState* __tstate = wxPyBeginAllowThreads();
4215 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
4216 wxPyEndAllowThreads(__tstate);
4217 if (PyErr_Occurred()) SWIG_fail;
4218 }
4219 resultobj = SWIG_From_int(static_cast< int >(result));
4220 return resultobj;
4221 fail:
4222 return NULL;
4223 }
4224
4225
4226 SWIGINTERN PyObject *_wrap_SystemSettings_SetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4227 PyObject *resultobj = 0;
4228 wxSystemScreenType arg1 ;
4229 int val1 ;
4230 int ecode1 = 0 ;
4231 PyObject * obj0 = 0 ;
4232 char * kwnames[] = {
4233 (char *) "screen", NULL
4234 };
4235
4236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) SWIG_fail;
4237 ecode1 = SWIG_AsVal_int(obj0, &val1);
4238 if (!SWIG_IsOK(ecode1)) {
4239 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_SetScreenType" "', expected argument " "1"" of type '" "wxSystemScreenType""'");
4240 }
4241 arg1 = static_cast< wxSystemScreenType >(val1);
4242 {
4243 if (!wxPyCheckForApp()) SWIG_fail;
4244 PyThreadState* __tstate = wxPyBeginAllowThreads();
4245 wxSystemSettings::SetScreenType(arg1);
4246 wxPyEndAllowThreads(__tstate);
4247 if (PyErr_Occurred()) SWIG_fail;
4248 }
4249 resultobj = SWIG_Py_Void();
4250 return resultobj;
4251 fail:
4252 return NULL;
4253 }
4254
4255
4256 SWIGINTERN PyObject *SystemSettings_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4257 PyObject *obj;
4258 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4259 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemSettings, SWIG_NewClientData(obj));
4260 return SWIG_Py_Void();
4261 }
4262
4263 SWIGINTERN int WINDOW_DEFAULT_VARIANT_set(PyObject *) {
4264 SWIG_Error(SWIG_AttributeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
4265 return 1;
4266 }
4267
4268
4269 SWIGINTERN PyObject *WINDOW_DEFAULT_VARIANT_get(void) {
4270 PyObject *pyobj = 0;
4271
4272 {
4273 #if wxUSE_UNICODE
4274 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4275 #else
4276 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4277 #endif
4278 }
4279 return pyobj;
4280 }
4281
4282
4283 SWIGINTERN PyObject *_wrap_new_SystemOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4284 PyObject *resultobj = 0;
4285 wxSystemOptions *result = 0 ;
4286
4287 if (!SWIG_Python_UnpackTuple(args,"new_SystemOptions",0,0,0)) SWIG_fail;
4288 {
4289 PyThreadState* __tstate = wxPyBeginAllowThreads();
4290 result = (wxSystemOptions *)new wxSystemOptions();
4291 wxPyEndAllowThreads(__tstate);
4292 if (PyErr_Occurred()) SWIG_fail;
4293 }
4294 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSystemOptions, SWIG_POINTER_NEW | 0 );
4295 return resultobj;
4296 fail:
4297 return NULL;
4298 }
4299
4300
4301 SWIGINTERN PyObject *_wrap_SystemOptions_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4302 PyObject *resultobj = 0;
4303 wxString *arg1 = 0 ;
4304 wxString *arg2 = 0 ;
4305 bool temp1 = false ;
4306 bool temp2 = false ;
4307 PyObject * obj0 = 0 ;
4308 PyObject * obj1 = 0 ;
4309 char * kwnames[] = {
4310 (char *) "name",(char *) "value", NULL
4311 };
4312
4313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) SWIG_fail;
4314 {
4315 arg1 = wxString_in_helper(obj0);
4316 if (arg1 == NULL) SWIG_fail;
4317 temp1 = true;
4318 }
4319 {
4320 arg2 = wxString_in_helper(obj1);
4321 if (arg2 == NULL) SWIG_fail;
4322 temp2 = true;
4323 }
4324 {
4325 PyThreadState* __tstate = wxPyBeginAllowThreads();
4326 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
4327 wxPyEndAllowThreads(__tstate);
4328 if (PyErr_Occurred()) SWIG_fail;
4329 }
4330 resultobj = SWIG_Py_Void();
4331 {
4332 if (temp1)
4333 delete arg1;
4334 }
4335 {
4336 if (temp2)
4337 delete arg2;
4338 }
4339 return resultobj;
4340 fail:
4341 {
4342 if (temp1)
4343 delete arg1;
4344 }
4345 {
4346 if (temp2)
4347 delete arg2;
4348 }
4349 return NULL;
4350 }
4351
4352
4353 SWIGINTERN PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4354 PyObject *resultobj = 0;
4355 wxString *arg1 = 0 ;
4356 int arg2 ;
4357 bool temp1 = false ;
4358 int val2 ;
4359 int ecode2 = 0 ;
4360 PyObject * obj0 = 0 ;
4361 PyObject * obj1 = 0 ;
4362 char * kwnames[] = {
4363 (char *) "name",(char *) "value", NULL
4364 };
4365
4366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
4367 {
4368 arg1 = wxString_in_helper(obj0);
4369 if (arg1 == NULL) SWIG_fail;
4370 temp1 = true;
4371 }
4372 ecode2 = SWIG_AsVal_int(obj1, &val2);
4373 if (!SWIG_IsOK(ecode2)) {
4374 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SystemOptions_SetOptionInt" "', expected argument " "2"" of type '" "int""'");
4375 }
4376 arg2 = static_cast< int >(val2);
4377 {
4378 PyThreadState* __tstate = wxPyBeginAllowThreads();
4379 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
4380 wxPyEndAllowThreads(__tstate);
4381 if (PyErr_Occurred()) SWIG_fail;
4382 }
4383 resultobj = SWIG_Py_Void();
4384 {
4385 if (temp1)
4386 delete arg1;
4387 }
4388 return resultobj;
4389 fail:
4390 {
4391 if (temp1)
4392 delete arg1;
4393 }
4394 return NULL;
4395 }
4396
4397
4398 SWIGINTERN PyObject *_wrap_SystemOptions_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4399 PyObject *resultobj = 0;
4400 wxString *arg1 = 0 ;
4401 wxString result;
4402 bool temp1 = false ;
4403 PyObject * obj0 = 0 ;
4404 char * kwnames[] = {
4405 (char *) "name", NULL
4406 };
4407
4408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) SWIG_fail;
4409 {
4410 arg1 = wxString_in_helper(obj0);
4411 if (arg1 == NULL) SWIG_fail;
4412 temp1 = true;
4413 }
4414 {
4415 PyThreadState* __tstate = wxPyBeginAllowThreads();
4416 result = wxSystemOptions::GetOption((wxString const &)*arg1);
4417 wxPyEndAllowThreads(__tstate);
4418 if (PyErr_Occurred()) SWIG_fail;
4419 }
4420 {
4421 #if wxUSE_UNICODE
4422 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4423 #else
4424 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4425 #endif
4426 }
4427 {
4428 if (temp1)
4429 delete arg1;
4430 }
4431 return resultobj;
4432 fail:
4433 {
4434 if (temp1)
4435 delete arg1;
4436 }
4437 return NULL;
4438 }
4439
4440
4441 SWIGINTERN PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4442 PyObject *resultobj = 0;
4443 wxString *arg1 = 0 ;
4444 int result;
4445 bool temp1 = false ;
4446 PyObject * obj0 = 0 ;
4447 char * kwnames[] = {
4448 (char *) "name", NULL
4449 };
4450
4451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) SWIG_fail;
4452 {
4453 arg1 = wxString_in_helper(obj0);
4454 if (arg1 == NULL) SWIG_fail;
4455 temp1 = true;
4456 }
4457 {
4458 PyThreadState* __tstate = wxPyBeginAllowThreads();
4459 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
4460 wxPyEndAllowThreads(__tstate);
4461 if (PyErr_Occurred()) SWIG_fail;
4462 }
4463 resultobj = SWIG_From_int(static_cast< int >(result));
4464 {
4465 if (temp1)
4466 delete arg1;
4467 }
4468 return resultobj;
4469 fail:
4470 {
4471 if (temp1)
4472 delete arg1;
4473 }
4474 return NULL;
4475 }
4476
4477
4478 SWIGINTERN PyObject *_wrap_SystemOptions_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4479 PyObject *resultobj = 0;
4480 wxString *arg1 = 0 ;
4481 bool result;
4482 bool temp1 = false ;
4483 PyObject * obj0 = 0 ;
4484 char * kwnames[] = {
4485 (char *) "name", NULL
4486 };
4487
4488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) SWIG_fail;
4489 {
4490 arg1 = wxString_in_helper(obj0);
4491 if (arg1 == NULL) SWIG_fail;
4492 temp1 = true;
4493 }
4494 {
4495 PyThreadState* __tstate = wxPyBeginAllowThreads();
4496 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
4497 wxPyEndAllowThreads(__tstate);
4498 if (PyErr_Occurred()) SWIG_fail;
4499 }
4500 {
4501 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4502 }
4503 {
4504 if (temp1)
4505 delete arg1;
4506 }
4507 return resultobj;
4508 fail:
4509 {
4510 if (temp1)
4511 delete arg1;
4512 }
4513 return NULL;
4514 }
4515
4516
4517 SWIGINTERN PyObject *_wrap_SystemOptions_IsFalse(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4518 PyObject *resultobj = 0;
4519 wxString *arg1 = 0 ;
4520 bool result;
4521 bool temp1 = false ;
4522 PyObject * obj0 = 0 ;
4523 char * kwnames[] = {
4524 (char *) "name", NULL
4525 };
4526
4527 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_IsFalse",kwnames,&obj0)) SWIG_fail;
4528 {
4529 arg1 = wxString_in_helper(obj0);
4530 if (arg1 == NULL) SWIG_fail;
4531 temp1 = true;
4532 }
4533 {
4534 PyThreadState* __tstate = wxPyBeginAllowThreads();
4535 result = (bool)wxSystemOptions::IsFalse((wxString const &)*arg1);
4536 wxPyEndAllowThreads(__tstate);
4537 if (PyErr_Occurred()) SWIG_fail;
4538 }
4539 {
4540 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4541 }
4542 {
4543 if (temp1)
4544 delete arg1;
4545 }
4546 return resultobj;
4547 fail:
4548 {
4549 if (temp1)
4550 delete arg1;
4551 }
4552 return NULL;
4553 }
4554
4555
4556 SWIGINTERN PyObject *SystemOptions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4557 PyObject *obj;
4558 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4559 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemOptions, SWIG_NewClientData(obj));
4560 return SWIG_Py_Void();
4561 }
4562
4563 SWIGINTERN PyObject *SystemOptions_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4564 return SWIG_Python_InitShadowInstance(args);
4565 }
4566
4567 SWIGINTERN int FileSelectorPromptStr_set(PyObject *) {
4568 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorPromptStr is read-only.");
4569 return 1;
4570 }
4571
4572
4573 SWIGINTERN PyObject *FileSelectorPromptStr_get(void) {
4574 PyObject *pyobj = 0;
4575
4576 {
4577 #if wxUSE_UNICODE
4578 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4579 #else
4580 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4581 #endif
4582 }
4583 return pyobj;
4584 }
4585
4586
4587 SWIGINTERN int FileSelectorDefaultWildcardStr_set(PyObject *) {
4588 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
4589 return 1;
4590 }
4591
4592
4593 SWIGINTERN PyObject *FileSelectorDefaultWildcardStr_get(void) {
4594 PyObject *pyobj = 0;
4595
4596 {
4597 #if wxUSE_UNICODE
4598 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4599 #else
4600 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4601 #endif
4602 }
4603 return pyobj;
4604 }
4605
4606
4607 SWIGINTERN int DirSelectorPromptStr_set(PyObject *) {
4608 SWIG_Error(SWIG_AttributeError,"Variable DirSelectorPromptStr is read-only.");
4609 return 1;
4610 }
4611
4612
4613 SWIGINTERN PyObject *DirSelectorPromptStr_get(void) {
4614 PyObject *pyobj = 0;
4615
4616 {
4617 #if wxUSE_UNICODE
4618 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4619 #else
4620 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4621 #endif
4622 }
4623 return pyobj;
4624 }
4625
4626
4627 SWIGINTERN PyObject *_wrap_NewId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4628 PyObject *resultobj = 0;
4629 long result;
4630
4631 if (!SWIG_Python_UnpackTuple(args,"NewId",0,0,0)) SWIG_fail;
4632 {
4633 PyThreadState* __tstate = wxPyBeginAllowThreads();
4634 result = (long)wxNewId();
4635 wxPyEndAllowThreads(__tstate);
4636 if (PyErr_Occurred()) SWIG_fail;
4637 }
4638 resultobj = SWIG_From_long(static_cast< long >(result));
4639 return resultobj;
4640 fail:
4641 return NULL;
4642 }
4643
4644
4645 SWIGINTERN PyObject *_wrap_RegisterId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4646 PyObject *resultobj = 0;
4647 long arg1 ;
4648 long val1 ;
4649 int ecode1 = 0 ;
4650 PyObject * obj0 = 0 ;
4651 char * kwnames[] = {
4652 (char *) "id", NULL
4653 };
4654
4655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) SWIG_fail;
4656 ecode1 = SWIG_AsVal_long(obj0, &val1);
4657 if (!SWIG_IsOK(ecode1)) {
4658 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "RegisterId" "', expected argument " "1"" of type '" "long""'");
4659 }
4660 arg1 = static_cast< long >(val1);
4661 {
4662 PyThreadState* __tstate = wxPyBeginAllowThreads();
4663 wxRegisterId(arg1);
4664 wxPyEndAllowThreads(__tstate);
4665 if (PyErr_Occurred()) SWIG_fail;
4666 }
4667 resultobj = SWIG_Py_Void();
4668 return resultobj;
4669 fail:
4670 return NULL;
4671 }
4672
4673
4674 SWIGINTERN PyObject *_wrap_GetCurrentId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4675 PyObject *resultobj = 0;
4676 long result;
4677
4678 if (!SWIG_Python_UnpackTuple(args,"GetCurrentId",0,0,0)) SWIG_fail;
4679 {
4680 PyThreadState* __tstate = wxPyBeginAllowThreads();
4681 result = (long)wxGetCurrentId();
4682 wxPyEndAllowThreads(__tstate);
4683 if (PyErr_Occurred()) SWIG_fail;
4684 }
4685 resultobj = SWIG_From_long(static_cast< long >(result));
4686 return resultobj;
4687 fail:
4688 return NULL;
4689 }
4690
4691
4692 SWIGINTERN PyObject *_wrap_IsStockID(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4693 PyObject *resultobj = 0;
4694 int arg1 ;
4695 bool result;
4696 int val1 ;
4697 int ecode1 = 0 ;
4698 PyObject * obj0 = 0 ;
4699 char * kwnames[] = {
4700 (char *) "id", NULL
4701 };
4702
4703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) SWIG_fail;
4704 ecode1 = SWIG_AsVal_int(obj0, &val1);
4705 if (!SWIG_IsOK(ecode1)) {
4706 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockID" "', expected argument " "1"" of type '" "int""'");
4707 }
4708 arg1 = static_cast< int >(val1);
4709 {
4710 PyThreadState* __tstate = wxPyBeginAllowThreads();
4711 result = (bool)wxIsStockID(arg1);
4712 wxPyEndAllowThreads(__tstate);
4713 if (PyErr_Occurred()) SWIG_fail;
4714 }
4715 {
4716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4717 }
4718 return resultobj;
4719 fail:
4720 return NULL;
4721 }
4722
4723
4724 SWIGINTERN PyObject *_wrap_IsStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4725 PyObject *resultobj = 0;
4726 int arg1 ;
4727 wxString *arg2 = 0 ;
4728 bool result;
4729 int val1 ;
4730 int ecode1 = 0 ;
4731 bool temp2 = false ;
4732 PyObject * obj0 = 0 ;
4733 PyObject * obj1 = 0 ;
4734 char * kwnames[] = {
4735 (char *) "id",(char *) "label", NULL
4736 };
4737
4738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) SWIG_fail;
4739 ecode1 = SWIG_AsVal_int(obj0, &val1);
4740 if (!SWIG_IsOK(ecode1)) {
4741 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockLabel" "', expected argument " "1"" of type '" "int""'");
4742 }
4743 arg1 = static_cast< int >(val1);
4744 {
4745 arg2 = wxString_in_helper(obj1);
4746 if (arg2 == NULL) SWIG_fail;
4747 temp2 = true;
4748 }
4749 {
4750 PyThreadState* __tstate = wxPyBeginAllowThreads();
4751 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
4752 wxPyEndAllowThreads(__tstate);
4753 if (PyErr_Occurred()) SWIG_fail;
4754 }
4755 {
4756 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4757 }
4758 {
4759 if (temp2)
4760 delete arg2;
4761 }
4762 return resultobj;
4763 fail:
4764 {
4765 if (temp2)
4766 delete arg2;
4767 }
4768 return NULL;
4769 }
4770
4771
4772 SWIGINTERN PyObject *_wrap_GetStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4773 PyObject *resultobj = 0;
4774 int arg1 ;
4775 bool arg2 = (bool) true ;
4776 wxString arg3 = (wxString) wxPyEmptyString ;
4777 wxString result;
4778 int val1 ;
4779 int ecode1 = 0 ;
4780 bool val2 ;
4781 int ecode2 = 0 ;
4782 PyObject * obj0 = 0 ;
4783 PyObject * obj1 = 0 ;
4784 PyObject * obj2 = 0 ;
4785 char * kwnames[] = {
4786 (char *) "id",(char *) "withCodes",(char *) "accelerator", NULL
4787 };
4788
4789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GetStockLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4790 ecode1 = SWIG_AsVal_int(obj0, &val1);
4791 if (!SWIG_IsOK(ecode1)) {
4792 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetStockLabel" "', expected argument " "1"" of type '" "int""'");
4793 }
4794 arg1 = static_cast< int >(val1);
4795 if (obj1) {
4796 ecode2 = SWIG_AsVal_bool(obj1, &val2);
4797 if (!SWIG_IsOK(ecode2)) {
4798 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetStockLabel" "', expected argument " "2"" of type '" "bool""'");
4799 }
4800 arg2 = static_cast< bool >(val2);
4801 }
4802 if (obj2) {
4803 {
4804 wxString* sptr = wxString_in_helper(obj2);
4805 if (sptr == NULL) SWIG_fail;
4806 arg3 = *sptr;
4807 delete sptr;
4808 }
4809 }
4810 {
4811 PyThreadState* __tstate = wxPyBeginAllowThreads();
4812 result = wxGetStockLabel(arg1,arg2,arg3);
4813 wxPyEndAllowThreads(__tstate);
4814 if (PyErr_Occurred()) SWIG_fail;
4815 }
4816 {
4817 #if wxUSE_UNICODE
4818 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4819 #else
4820 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4821 #endif
4822 }
4823 return resultobj;
4824 fail:
4825 return NULL;
4826 }
4827
4828
4829 SWIGINTERN PyObject *_wrap_Bell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4830 PyObject *resultobj = 0;
4831
4832 if (!SWIG_Python_UnpackTuple(args,"Bell",0,0,0)) SWIG_fail;
4833 {
4834 if (!wxPyCheckForApp()) SWIG_fail;
4835 PyThreadState* __tstate = wxPyBeginAllowThreads();
4836 wxBell();
4837 wxPyEndAllowThreads(__tstate);
4838 if (PyErr_Occurred()) SWIG_fail;
4839 }
4840 resultobj = SWIG_Py_Void();
4841 return resultobj;
4842 fail:
4843 return NULL;
4844 }
4845
4846
4847 SWIGINTERN PyObject *_wrap_EndBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4848 PyObject *resultobj = 0;
4849
4850 if (!SWIG_Python_UnpackTuple(args,"EndBusyCursor",0,0,0)) SWIG_fail;
4851 {
4852 if (!wxPyCheckForApp()) SWIG_fail;
4853 PyThreadState* __tstate = wxPyBeginAllowThreads();
4854 wxEndBusyCursor();
4855 wxPyEndAllowThreads(__tstate);
4856 if (PyErr_Occurred()) SWIG_fail;
4857 }
4858 resultobj = SWIG_Py_Void();
4859 return resultobj;
4860 fail:
4861 return NULL;
4862 }
4863
4864
4865 SWIGINTERN PyObject *_wrap_GetElapsedTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4866 PyObject *resultobj = 0;
4867 bool arg1 = (bool) true ;
4868 long result;
4869 bool val1 ;
4870 int ecode1 = 0 ;
4871 PyObject * obj0 = 0 ;
4872 char * kwnames[] = {
4873 (char *) "resetTimer", NULL
4874 };
4875
4876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) SWIG_fail;
4877 if (obj0) {
4878 ecode1 = SWIG_AsVal_bool(obj0, &val1);
4879 if (!SWIG_IsOK(ecode1)) {
4880 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetElapsedTime" "', expected argument " "1"" of type '" "bool""'");
4881 }
4882 arg1 = static_cast< bool >(val1);
4883 }
4884 {
4885 PyThreadState* __tstate = wxPyBeginAllowThreads();
4886 result = (long)wxGetElapsedTime(arg1);
4887 wxPyEndAllowThreads(__tstate);
4888 if (PyErr_Occurred()) SWIG_fail;
4889 }
4890 resultobj = SWIG_From_long(static_cast< long >(result));
4891 return resultobj;
4892 fail:
4893 return NULL;
4894 }
4895
4896
4897 SWIGINTERN PyObject *_wrap_IsBusy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4898 PyObject *resultobj = 0;
4899 bool result;
4900
4901 if (!SWIG_Python_UnpackTuple(args,"IsBusy",0,0,0)) SWIG_fail;
4902 {
4903 PyThreadState* __tstate = wxPyBeginAllowThreads();
4904 result = (bool)wxIsBusy();
4905 wxPyEndAllowThreads(__tstate);
4906 if (PyErr_Occurred()) SWIG_fail;
4907 }
4908 {
4909 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4910 }
4911 return resultobj;
4912 fail:
4913 return NULL;
4914 }
4915
4916
4917 SWIGINTERN PyObject *_wrap_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4918 PyObject *resultobj = 0;
4919 wxString result;
4920
4921 if (!SWIG_Python_UnpackTuple(args,"Now",0,0,0)) SWIG_fail;
4922 {
4923 PyThreadState* __tstate = wxPyBeginAllowThreads();
4924 result = wxNow();
4925 wxPyEndAllowThreads(__tstate);
4926 if (PyErr_Occurred()) SWIG_fail;
4927 }
4928 {
4929 #if wxUSE_UNICODE
4930 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4931 #else
4932 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4933 #endif
4934 }
4935 return resultobj;
4936 fail:
4937 return NULL;
4938 }
4939
4940
4941 SWIGINTERN PyObject *_wrap_Shell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4942 PyObject *resultobj = 0;
4943 wxString const &arg1_defvalue = wxPyEmptyString ;
4944 wxString *arg1 = (wxString *) &arg1_defvalue ;
4945 bool result;
4946 bool temp1 = false ;
4947 PyObject * obj0 = 0 ;
4948 char * kwnames[] = {
4949 (char *) "command", NULL
4950 };
4951
4952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) SWIG_fail;
4953 if (obj0) {
4954 {
4955 arg1 = wxString_in_helper(obj0);
4956 if (arg1 == NULL) SWIG_fail;
4957 temp1 = true;
4958 }
4959 }
4960 {
4961 PyThreadState* __tstate = wxPyBeginAllowThreads();
4962 result = (bool)wxShell((wxString const &)*arg1);
4963 wxPyEndAllowThreads(__tstate);
4964 if (PyErr_Occurred()) SWIG_fail;
4965 }
4966 {
4967 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4968 }
4969 {
4970 if (temp1)
4971 delete arg1;
4972 }
4973 return resultobj;
4974 fail:
4975 {
4976 if (temp1)
4977 delete arg1;
4978 }
4979 return NULL;
4980 }
4981
4982
4983 SWIGINTERN PyObject *_wrap_StartTimer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4984 PyObject *resultobj = 0;
4985
4986 if (!SWIG_Python_UnpackTuple(args,"StartTimer",0,0,0)) SWIG_fail;
4987 {
4988 PyThreadState* __tstate = wxPyBeginAllowThreads();
4989 wxStartTimer();
4990 wxPyEndAllowThreads(__tstate);
4991 if (PyErr_Occurred()) SWIG_fail;
4992 }
4993 resultobj = SWIG_Py_Void();
4994 return resultobj;
4995 fail:
4996 return NULL;
4997 }
4998
4999
5000 SWIGINTERN PyObject *_wrap_GetOsVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5001 PyObject *resultobj = 0;
5002 int *arg1 = (int *) 0 ;
5003 int *arg2 = (int *) 0 ;
5004 int result;
5005 int temp1 ;
5006 int res1 = SWIG_TMPOBJ ;
5007 int temp2 ;
5008 int res2 = SWIG_TMPOBJ ;
5009
5010 arg1 = &temp1;
5011 arg2 = &temp2;
5012 if (!SWIG_Python_UnpackTuple(args,"GetOsVersion",0,0,0)) SWIG_fail;
5013 {
5014 PyThreadState* __tstate = wxPyBeginAllowThreads();
5015 result = (int)wxGetOsVersion(arg1,arg2);
5016 wxPyEndAllowThreads(__tstate);
5017 if (PyErr_Occurred()) SWIG_fail;
5018 }
5019 resultobj = SWIG_From_int(static_cast< int >(result));
5020 if (SWIG_IsTmpObj(res1)) {
5021 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
5022 } else {
5023 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5024 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
5025 }
5026 if (SWIG_IsTmpObj(res2)) {
5027 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
5028 } else {
5029 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5030 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
5031 }
5032 return resultobj;
5033 fail:
5034 return NULL;
5035 }
5036
5037
5038 SWIGINTERN PyObject *_wrap_GetOsDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5039 PyObject *resultobj = 0;
5040 wxString result;
5041
5042 if (!SWIG_Python_UnpackTuple(args,"GetOsDescription",0,0,0)) SWIG_fail;
5043 {
5044 PyThreadState* __tstate = wxPyBeginAllowThreads();
5045 result = wxGetOsDescription();
5046 wxPyEndAllowThreads(__tstate);
5047 if (PyErr_Occurred()) SWIG_fail;
5048 }
5049 {
5050 #if wxUSE_UNICODE
5051 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5052 #else
5053 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5054 #endif
5055 }
5056 return resultobj;
5057 fail:
5058 return NULL;
5059 }
5060
5061
5062 SWIGINTERN PyObject *_wrap_GetFreeMemory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5063 PyObject *resultobj = 0;
5064 wxMemorySize result;
5065
5066 if (!SWIG_Python_UnpackTuple(args,"GetFreeMemory",0,0,0)) SWIG_fail;
5067 {
5068 PyThreadState* __tstate = wxPyBeginAllowThreads();
5069 result = wxGetFreeMemory();
5070 wxPyEndAllowThreads(__tstate);
5071 if (PyErr_Occurred()) SWIG_fail;
5072 }
5073 resultobj = SWIG_NewPointerObj((new wxMemorySize(static_cast< const wxMemorySize& >(result))), SWIGTYPE_p_wxMemorySize, SWIG_POINTER_OWN | 0 );
5074 return resultobj;
5075 fail:
5076 return NULL;
5077 }
5078
5079
5080 SWIGINTERN PyObject *_wrap_Shutdown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5081 PyObject *resultobj = 0;
5082 wxShutdownFlags arg1 ;
5083 bool result;
5084 int val1 ;
5085 int ecode1 = 0 ;
5086 PyObject * obj0 = 0 ;
5087 char * kwnames[] = {
5088 (char *) "wFlags", NULL
5089 };
5090
5091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) SWIG_fail;
5092 ecode1 = SWIG_AsVal_int(obj0, &val1);
5093 if (!SWIG_IsOK(ecode1)) {
5094 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Shutdown" "', expected argument " "1"" of type '" "wxShutdownFlags""'");
5095 }
5096 arg1 = static_cast< wxShutdownFlags >(val1);
5097 {
5098 if (!wxPyCheckForApp()) SWIG_fail;
5099 PyThreadState* __tstate = wxPyBeginAllowThreads();
5100 result = (bool)wxShutdown(arg1);
5101 wxPyEndAllowThreads(__tstate);
5102 if (PyErr_Occurred()) SWIG_fail;
5103 }
5104 {
5105 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5106 }
5107 return resultobj;
5108 fail:
5109 return NULL;
5110 }
5111
5112
5113 SWIGINTERN PyObject *_wrap_Sleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5114 PyObject *resultobj = 0;
5115 int arg1 ;
5116 int val1 ;
5117 int ecode1 = 0 ;
5118 PyObject * obj0 = 0 ;
5119 char * kwnames[] = {
5120 (char *) "secs", NULL
5121 };
5122
5123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) SWIG_fail;
5124 ecode1 = SWIG_AsVal_int(obj0, &val1);
5125 if (!SWIG_IsOK(ecode1)) {
5126 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Sleep" "', expected argument " "1"" of type '" "int""'");
5127 }
5128 arg1 = static_cast< int >(val1);
5129 {
5130 PyThreadState* __tstate = wxPyBeginAllowThreads();
5131 wxSleep(arg1);
5132 wxPyEndAllowThreads(__tstate);
5133 if (PyErr_Occurred()) SWIG_fail;
5134 }
5135 resultobj = SWIG_Py_Void();
5136 return resultobj;
5137 fail:
5138 return NULL;
5139 }
5140
5141
5142 SWIGINTERN PyObject *_wrap_MilliSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5143 PyObject *resultobj = 0;
5144 unsigned long arg1 ;
5145 unsigned long val1 ;
5146 int ecode1 = 0 ;
5147 PyObject * obj0 = 0 ;
5148 char * kwnames[] = {
5149 (char *) "milliseconds", NULL
5150 };
5151
5152 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) SWIG_fail;
5153 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5154 if (!SWIG_IsOK(ecode1)) {
5155 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MilliSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5156 }
5157 arg1 = static_cast< unsigned long >(val1);
5158 {
5159 PyThreadState* __tstate = wxPyBeginAllowThreads();
5160 wxMilliSleep(arg1);
5161 wxPyEndAllowThreads(__tstate);
5162 if (PyErr_Occurred()) SWIG_fail;
5163 }
5164 resultobj = SWIG_Py_Void();
5165 return resultobj;
5166 fail:
5167 return NULL;
5168 }
5169
5170
5171 SWIGINTERN PyObject *_wrap_MicroSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5172 PyObject *resultobj = 0;
5173 unsigned long arg1 ;
5174 unsigned long val1 ;
5175 int ecode1 = 0 ;
5176 PyObject * obj0 = 0 ;
5177 char * kwnames[] = {
5178 (char *) "microseconds", NULL
5179 };
5180
5181 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) SWIG_fail;
5182 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5183 if (!SWIG_IsOK(ecode1)) {
5184 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MicroSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5185 }
5186 arg1 = static_cast< unsigned long >(val1);
5187 {
5188 PyThreadState* __tstate = wxPyBeginAllowThreads();
5189 wxMicroSleep(arg1);
5190 wxPyEndAllowThreads(__tstate);
5191 if (PyErr_Occurred()) SWIG_fail;
5192 }
5193 resultobj = SWIG_Py_Void();
5194 return resultobj;
5195 fail:
5196 return NULL;
5197 }
5198
5199
5200 SWIGINTERN PyObject *_wrap_EnableTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5201 PyObject *resultobj = 0;
5202 bool arg1 ;
5203 bool val1 ;
5204 int ecode1 = 0 ;
5205 PyObject * obj0 = 0 ;
5206 char * kwnames[] = {
5207 (char *) "enable", NULL
5208 };
5209
5210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) SWIG_fail;
5211 ecode1 = SWIG_AsVal_bool(obj0, &val1);
5212 if (!SWIG_IsOK(ecode1)) {
5213 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "EnableTopLevelWindows" "', expected argument " "1"" of type '" "bool""'");
5214 }
5215 arg1 = static_cast< bool >(val1);
5216 {
5217 PyThreadState* __tstate = wxPyBeginAllowThreads();
5218 wxEnableTopLevelWindows(arg1);
5219 wxPyEndAllowThreads(__tstate);
5220 if (PyErr_Occurred()) SWIG_fail;
5221 }
5222 resultobj = SWIG_Py_Void();
5223 return resultobj;
5224 fail:
5225 return NULL;
5226 }
5227
5228
5229 SWIGINTERN PyObject *_wrap_StripMenuCodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5230 PyObject *resultobj = 0;
5231 wxString *arg1 = 0 ;
5232 wxString result;
5233 bool temp1 = false ;
5234 PyObject * obj0 = 0 ;
5235 char * kwnames[] = {
5236 (char *) "_in", NULL
5237 };
5238
5239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) SWIG_fail;
5240 {
5241 arg1 = wxString_in_helper(obj0);
5242 if (arg1 == NULL) SWIG_fail;
5243 temp1 = true;
5244 }
5245 {
5246 PyThreadState* __tstate = wxPyBeginAllowThreads();
5247 result = wxStripMenuCodes((wxString const &)*arg1);
5248 wxPyEndAllowThreads(__tstate);
5249 if (PyErr_Occurred()) SWIG_fail;
5250 }
5251 {
5252 #if wxUSE_UNICODE
5253 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5254 #else
5255 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5256 #endif
5257 }
5258 {
5259 if (temp1)
5260 delete arg1;
5261 }
5262 return resultobj;
5263 fail:
5264 {
5265 if (temp1)
5266 delete arg1;
5267 }
5268 return NULL;
5269 }
5270
5271
5272 SWIGINTERN PyObject *_wrap_GetEmailAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5273 PyObject *resultobj = 0;
5274 wxString result;
5275
5276 if (!SWIG_Python_UnpackTuple(args,"GetEmailAddress",0,0,0)) SWIG_fail;
5277 {
5278 PyThreadState* __tstate = wxPyBeginAllowThreads();
5279 result = wxGetEmailAddress();
5280 wxPyEndAllowThreads(__tstate);
5281 if (PyErr_Occurred()) SWIG_fail;
5282 }
5283 {
5284 #if wxUSE_UNICODE
5285 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5286 #else
5287 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5288 #endif
5289 }
5290 return resultobj;
5291 fail:
5292 return NULL;
5293 }
5294
5295
5296 SWIGINTERN PyObject *_wrap_GetHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5297 PyObject *resultobj = 0;
5298 wxString result;
5299
5300 if (!SWIG_Python_UnpackTuple(args,"GetHostName",0,0,0)) SWIG_fail;
5301 {
5302 PyThreadState* __tstate = wxPyBeginAllowThreads();
5303 result = wxGetHostName();
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_GetFullHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5321 PyObject *resultobj = 0;
5322 wxString result;
5323
5324 if (!SWIG_Python_UnpackTuple(args,"GetFullHostName",0,0,0)) SWIG_fail;
5325 {
5326 PyThreadState* __tstate = wxPyBeginAllowThreads();
5327 result = wxGetFullHostName();
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_GetUserId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5345 PyObject *resultobj = 0;
5346 wxString result;
5347
5348 if (!SWIG_Python_UnpackTuple(args,"GetUserId",0,0,0)) SWIG_fail;
5349 {
5350 PyThreadState* __tstate = wxPyBeginAllowThreads();
5351 result = wxGetUserId();
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_GetUserName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5369 PyObject *resultobj = 0;
5370 wxString result;
5371
5372 if (!SWIG_Python_UnpackTuple(args,"GetUserName",0,0,0)) SWIG_fail;
5373 {
5374 PyThreadState* __tstate = wxPyBeginAllowThreads();
5375 result = wxGetUserName();
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_GetHomeDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5393 PyObject *resultobj = 0;
5394 wxString result;
5395
5396 if (!SWIG_Python_UnpackTuple(args,"GetHomeDir",0,0,0)) SWIG_fail;
5397 {
5398 PyThreadState* __tstate = wxPyBeginAllowThreads();
5399 result = wxGetHomeDir();
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_GetUserHome(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5417 PyObject *resultobj = 0;
5418 wxString const &arg1_defvalue = wxPyEmptyString ;
5419 wxString *arg1 = (wxString *) &arg1_defvalue ;
5420 wxString result;
5421 bool temp1 = false ;
5422 PyObject * obj0 = 0 ;
5423 char * kwnames[] = {
5424 (char *) "user", NULL
5425 };
5426
5427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) SWIG_fail;
5428 if (obj0) {
5429 {
5430 arg1 = wxString_in_helper(obj0);
5431 if (arg1 == NULL) SWIG_fail;
5432 temp1 = true;
5433 }
5434 }
5435 {
5436 PyThreadState* __tstate = wxPyBeginAllowThreads();
5437 result = wxGetUserHome((wxString const &)*arg1);
5438 wxPyEndAllowThreads(__tstate);
5439 if (PyErr_Occurred()) SWIG_fail;
5440 }
5441 {
5442 #if wxUSE_UNICODE
5443 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5444 #else
5445 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5446 #endif
5447 }
5448 {
5449 if (temp1)
5450 delete arg1;
5451 }
5452 return resultobj;
5453 fail:
5454 {
5455 if (temp1)
5456 delete arg1;
5457 }
5458 return NULL;
5459 }
5460
5461
5462 SWIGINTERN PyObject *_wrap_GetProcessId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5463 PyObject *resultobj = 0;
5464 unsigned long result;
5465
5466 if (!SWIG_Python_UnpackTuple(args,"GetProcessId",0,0,0)) SWIG_fail;
5467 {
5468 PyThreadState* __tstate = wxPyBeginAllowThreads();
5469 result = (unsigned long)wxGetProcessId();
5470 wxPyEndAllowThreads(__tstate);
5471 if (PyErr_Occurred()) SWIG_fail;
5472 }
5473 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
5474 return resultobj;
5475 fail:
5476 return NULL;
5477 }
5478
5479
5480 SWIGINTERN PyObject *_wrap_Trap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5481 PyObject *resultobj = 0;
5482
5483 if (!SWIG_Python_UnpackTuple(args,"Trap",0,0,0)) SWIG_fail;
5484 {
5485 PyThreadState* __tstate = wxPyBeginAllowThreads();
5486 wxTrap();
5487 wxPyEndAllowThreads(__tstate);
5488 if (PyErr_Occurred()) SWIG_fail;
5489 }
5490 resultobj = SWIG_Py_Void();
5491 return resultobj;
5492 fail:
5493 return NULL;
5494 }
5495
5496
5497 SWIGINTERN PyObject *_wrap_FileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5498 PyObject *resultobj = 0;
5499 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
5500 wxString *arg1 = (wxString *) &arg1_defvalue ;
5501 wxString const &arg2_defvalue = wxPyEmptyString ;
5502 wxString *arg2 = (wxString *) &arg2_defvalue ;
5503 wxString const &arg3_defvalue = wxPyEmptyString ;
5504 wxString *arg3 = (wxString *) &arg3_defvalue ;
5505 wxString const &arg4_defvalue = wxPyEmptyString ;
5506 wxString *arg4 = (wxString *) &arg4_defvalue ;
5507 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
5508 wxString *arg5 = (wxString *) &arg5_defvalue ;
5509 int arg6 = (int) 0 ;
5510 wxWindow *arg7 = (wxWindow *) NULL ;
5511 int arg8 = (int) -1 ;
5512 int arg9 = (int) -1 ;
5513 wxString result;
5514 bool temp1 = false ;
5515 bool temp2 = false ;
5516 bool temp3 = false ;
5517 bool temp4 = false ;
5518 bool temp5 = false ;
5519 int val6 ;
5520 int ecode6 = 0 ;
5521 void *argp7 = 0 ;
5522 int res7 = 0 ;
5523 int val8 ;
5524 int ecode8 = 0 ;
5525 int val9 ;
5526 int ecode9 = 0 ;
5527 PyObject * obj0 = 0 ;
5528 PyObject * obj1 = 0 ;
5529 PyObject * obj2 = 0 ;
5530 PyObject * obj3 = 0 ;
5531 PyObject * obj4 = 0 ;
5532 PyObject * obj5 = 0 ;
5533 PyObject * obj6 = 0 ;
5534 PyObject * obj7 = 0 ;
5535 PyObject * obj8 = 0 ;
5536 char * kwnames[] = {
5537 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
5538 };
5539
5540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
5541 if (obj0) {
5542 {
5543 arg1 = wxString_in_helper(obj0);
5544 if (arg1 == NULL) SWIG_fail;
5545 temp1 = true;
5546 }
5547 }
5548 if (obj1) {
5549 {
5550 arg2 = wxString_in_helper(obj1);
5551 if (arg2 == NULL) SWIG_fail;
5552 temp2 = true;
5553 }
5554 }
5555 if (obj2) {
5556 {
5557 arg3 = wxString_in_helper(obj2);
5558 if (arg3 == NULL) SWIG_fail;
5559 temp3 = true;
5560 }
5561 }
5562 if (obj3) {
5563 {
5564 arg4 = wxString_in_helper(obj3);
5565 if (arg4 == NULL) SWIG_fail;
5566 temp4 = true;
5567 }
5568 }
5569 if (obj4) {
5570 {
5571 arg5 = wxString_in_helper(obj4);
5572 if (arg5 == NULL) SWIG_fail;
5573 temp5 = true;
5574 }
5575 }
5576 if (obj5) {
5577 ecode6 = SWIG_AsVal_int(obj5, &val6);
5578 if (!SWIG_IsOK(ecode6)) {
5579 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "FileSelector" "', expected argument " "6"" of type '" "int""'");
5580 }
5581 arg6 = static_cast< int >(val6);
5582 }
5583 if (obj6) {
5584 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_wxWindow, 0 | 0 );
5585 if (!SWIG_IsOK(res7)) {
5586 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "FileSelector" "', expected argument " "7"" of type '" "wxWindow *""'");
5587 }
5588 arg7 = reinterpret_cast< wxWindow * >(argp7);
5589 }
5590 if (obj7) {
5591 ecode8 = SWIG_AsVal_int(obj7, &val8);
5592 if (!SWIG_IsOK(ecode8)) {
5593 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "FileSelector" "', expected argument " "8"" of type '" "int""'");
5594 }
5595 arg8 = static_cast< int >(val8);
5596 }
5597 if (obj8) {
5598 ecode9 = SWIG_AsVal_int(obj8, &val9);
5599 if (!SWIG_IsOK(ecode9)) {
5600 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "FileSelector" "', expected argument " "9"" of type '" "int""'");
5601 }
5602 arg9 = static_cast< int >(val9);
5603 }
5604 {
5605 if (!wxPyCheckForApp()) SWIG_fail;
5606 PyThreadState* __tstate = wxPyBeginAllowThreads();
5607 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
5608 wxPyEndAllowThreads(__tstate);
5609 if (PyErr_Occurred()) SWIG_fail;
5610 }
5611 {
5612 #if wxUSE_UNICODE
5613 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5614 #else
5615 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5616 #endif
5617 }
5618 {
5619 if (temp1)
5620 delete arg1;
5621 }
5622 {
5623 if (temp2)
5624 delete arg2;
5625 }
5626 {
5627 if (temp3)
5628 delete arg3;
5629 }
5630 {
5631 if (temp4)
5632 delete arg4;
5633 }
5634 {
5635 if (temp5)
5636 delete arg5;
5637 }
5638 return resultobj;
5639 fail:
5640 {
5641 if (temp1)
5642 delete arg1;
5643 }
5644 {
5645 if (temp2)
5646 delete arg2;
5647 }
5648 {
5649 if (temp3)
5650 delete arg3;
5651 }
5652 {
5653 if (temp4)
5654 delete arg4;
5655 }
5656 {
5657 if (temp5)
5658 delete arg5;
5659 }
5660 return NULL;
5661 }
5662
5663
5664 SWIGINTERN PyObject *_wrap_LoadFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5665 PyObject *resultobj = 0;
5666 wxString *arg1 = 0 ;
5667 wxString *arg2 = 0 ;
5668 wxString const &arg3_defvalue = wxPyEmptyString ;
5669 wxString *arg3 = (wxString *) &arg3_defvalue ;
5670 wxWindow *arg4 = (wxWindow *) NULL ;
5671 wxString result;
5672 bool temp1 = false ;
5673 bool temp2 = false ;
5674 bool temp3 = false ;
5675 void *argp4 = 0 ;
5676 int res4 = 0 ;
5677 PyObject * obj0 = 0 ;
5678 PyObject * obj1 = 0 ;
5679 PyObject * obj2 = 0 ;
5680 PyObject * obj3 = 0 ;
5681 char * kwnames[] = {
5682 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5683 };
5684
5685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5686 {
5687 arg1 = wxString_in_helper(obj0);
5688 if (arg1 == NULL) SWIG_fail;
5689 temp1 = true;
5690 }
5691 {
5692 arg2 = wxString_in_helper(obj1);
5693 if (arg2 == NULL) SWIG_fail;
5694 temp2 = true;
5695 }
5696 if (obj2) {
5697 {
5698 arg3 = wxString_in_helper(obj2);
5699 if (arg3 == NULL) SWIG_fail;
5700 temp3 = true;
5701 }
5702 }
5703 if (obj3) {
5704 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5705 if (!SWIG_IsOK(res4)) {
5706 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LoadFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5707 }
5708 arg4 = reinterpret_cast< wxWindow * >(argp4);
5709 }
5710 {
5711 if (!wxPyCheckForApp()) SWIG_fail;
5712 PyThreadState* __tstate = wxPyBeginAllowThreads();
5713 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5714 wxPyEndAllowThreads(__tstate);
5715 if (PyErr_Occurred()) SWIG_fail;
5716 }
5717 {
5718 #if wxUSE_UNICODE
5719 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5720 #else
5721 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5722 #endif
5723 }
5724 {
5725 if (temp1)
5726 delete arg1;
5727 }
5728 {
5729 if (temp2)
5730 delete arg2;
5731 }
5732 {
5733 if (temp3)
5734 delete arg3;
5735 }
5736 return resultobj;
5737 fail:
5738 {
5739 if (temp1)
5740 delete arg1;
5741 }
5742 {
5743 if (temp2)
5744 delete arg2;
5745 }
5746 {
5747 if (temp3)
5748 delete arg3;
5749 }
5750 return NULL;
5751 }
5752
5753
5754 SWIGINTERN PyObject *_wrap_SaveFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5755 PyObject *resultobj = 0;
5756 wxString *arg1 = 0 ;
5757 wxString *arg2 = 0 ;
5758 wxString const &arg3_defvalue = wxPyEmptyString ;
5759 wxString *arg3 = (wxString *) &arg3_defvalue ;
5760 wxWindow *arg4 = (wxWindow *) NULL ;
5761 wxString result;
5762 bool temp1 = false ;
5763 bool temp2 = false ;
5764 bool temp3 = false ;
5765 void *argp4 = 0 ;
5766 int res4 = 0 ;
5767 PyObject * obj0 = 0 ;
5768 PyObject * obj1 = 0 ;
5769 PyObject * obj2 = 0 ;
5770 PyObject * obj3 = 0 ;
5771 char * kwnames[] = {
5772 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5773 };
5774
5775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5776 {
5777 arg1 = wxString_in_helper(obj0);
5778 if (arg1 == NULL) SWIG_fail;
5779 temp1 = true;
5780 }
5781 {
5782 arg2 = wxString_in_helper(obj1);
5783 if (arg2 == NULL) SWIG_fail;
5784 temp2 = true;
5785 }
5786 if (obj2) {
5787 {
5788 arg3 = wxString_in_helper(obj2);
5789 if (arg3 == NULL) SWIG_fail;
5790 temp3 = true;
5791 }
5792 }
5793 if (obj3) {
5794 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5795 if (!SWIG_IsOK(res4)) {
5796 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SaveFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5797 }
5798 arg4 = reinterpret_cast< wxWindow * >(argp4);
5799 }
5800 {
5801 if (!wxPyCheckForApp()) SWIG_fail;
5802 PyThreadState* __tstate = wxPyBeginAllowThreads();
5803 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5804 wxPyEndAllowThreads(__tstate);
5805 if (PyErr_Occurred()) SWIG_fail;
5806 }
5807 {
5808 #if wxUSE_UNICODE
5809 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5810 #else
5811 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5812 #endif
5813 }
5814 {
5815 if (temp1)
5816 delete arg1;
5817 }
5818 {
5819 if (temp2)
5820 delete arg2;
5821 }
5822 {
5823 if (temp3)
5824 delete arg3;
5825 }
5826 return resultobj;
5827 fail:
5828 {
5829 if (temp1)
5830 delete arg1;
5831 }
5832 {
5833 if (temp2)
5834 delete arg2;
5835 }
5836 {
5837 if (temp3)
5838 delete arg3;
5839 }
5840 return NULL;
5841 }
5842
5843
5844 SWIGINTERN PyObject *_wrap_DirSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5845 PyObject *resultobj = 0;
5846 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
5847 wxString *arg1 = (wxString *) &arg1_defvalue ;
5848 wxString const &arg2_defvalue = wxPyEmptyString ;
5849 wxString *arg2 = (wxString *) &arg2_defvalue ;
5850 long arg3 = (long) wxDD_DEFAULT_STYLE ;
5851 wxPoint const &arg4_defvalue = wxDefaultPosition ;
5852 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
5853 wxWindow *arg5 = (wxWindow *) NULL ;
5854 wxString result;
5855 bool temp1 = false ;
5856 bool temp2 = false ;
5857 long val3 ;
5858 int ecode3 = 0 ;
5859 wxPoint temp4 ;
5860 void *argp5 = 0 ;
5861 int res5 = 0 ;
5862 PyObject * obj0 = 0 ;
5863 PyObject * obj1 = 0 ;
5864 PyObject * obj2 = 0 ;
5865 PyObject * obj3 = 0 ;
5866 PyObject * obj4 = 0 ;
5867 char * kwnames[] = {
5868 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
5869 };
5870
5871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
5872 if (obj0) {
5873 {
5874 arg1 = wxString_in_helper(obj0);
5875 if (arg1 == NULL) SWIG_fail;
5876 temp1 = true;
5877 }
5878 }
5879 if (obj1) {
5880 {
5881 arg2 = wxString_in_helper(obj1);
5882 if (arg2 == NULL) SWIG_fail;
5883 temp2 = true;
5884 }
5885 }
5886 if (obj2) {
5887 ecode3 = SWIG_AsVal_long(obj2, &val3);
5888 if (!SWIG_IsOK(ecode3)) {
5889 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DirSelector" "', expected argument " "3"" of type '" "long""'");
5890 }
5891 arg3 = static_cast< long >(val3);
5892 }
5893 if (obj3) {
5894 {
5895 arg4 = &temp4;
5896 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
5897 }
5898 }
5899 if (obj4) {
5900 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
5901 if (!SWIG_IsOK(res5)) {
5902 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DirSelector" "', expected argument " "5"" of type '" "wxWindow *""'");
5903 }
5904 arg5 = reinterpret_cast< wxWindow * >(argp5);
5905 }
5906 {
5907 if (!wxPyCheckForApp()) SWIG_fail;
5908 PyThreadState* __tstate = wxPyBeginAllowThreads();
5909 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
5910 wxPyEndAllowThreads(__tstate);
5911 if (PyErr_Occurred()) SWIG_fail;
5912 }
5913 {
5914 #if wxUSE_UNICODE
5915 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5916 #else
5917 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5918 #endif
5919 }
5920 {
5921 if (temp1)
5922 delete arg1;
5923 }
5924 {
5925 if (temp2)
5926 delete arg2;
5927 }
5928 return resultobj;
5929 fail:
5930 {
5931 if (temp1)
5932 delete arg1;
5933 }
5934 {
5935 if (temp2)
5936 delete arg2;
5937 }
5938 return NULL;
5939 }
5940
5941
5942 SWIGINTERN PyObject *_wrap_GetTextFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5943 PyObject *resultobj = 0;
5944 wxString *arg1 = 0 ;
5945 wxString const &arg2_defvalue = wxPyEmptyString ;
5946 wxString *arg2 = (wxString *) &arg2_defvalue ;
5947 wxString const &arg3_defvalue = wxPyEmptyString ;
5948 wxString *arg3 = (wxString *) &arg3_defvalue ;
5949 wxWindow *arg4 = (wxWindow *) NULL ;
5950 int arg5 = (int) -1 ;
5951 int arg6 = (int) -1 ;
5952 bool arg7 = (bool) true ;
5953 wxString result;
5954 bool temp1 = false ;
5955 bool temp2 = false ;
5956 bool temp3 = false ;
5957 void *argp4 = 0 ;
5958 int res4 = 0 ;
5959 int val5 ;
5960 int ecode5 = 0 ;
5961 int val6 ;
5962 int ecode6 = 0 ;
5963 bool val7 ;
5964 int ecode7 = 0 ;
5965 PyObject * obj0 = 0 ;
5966 PyObject * obj1 = 0 ;
5967 PyObject * obj2 = 0 ;
5968 PyObject * obj3 = 0 ;
5969 PyObject * obj4 = 0 ;
5970 PyObject * obj5 = 0 ;
5971 PyObject * obj6 = 0 ;
5972 char * kwnames[] = {
5973 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
5974 };
5975
5976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
5977 {
5978 arg1 = wxString_in_helper(obj0);
5979 if (arg1 == NULL) SWIG_fail;
5980 temp1 = true;
5981 }
5982 if (obj1) {
5983 {
5984 arg2 = wxString_in_helper(obj1);
5985 if (arg2 == NULL) SWIG_fail;
5986 temp2 = true;
5987 }
5988 }
5989 if (obj2) {
5990 {
5991 arg3 = wxString_in_helper(obj2);
5992 if (arg3 == NULL) SWIG_fail;
5993 temp3 = true;
5994 }
5995 }
5996 if (obj3) {
5997 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5998 if (!SWIG_IsOK(res4)) {
5999 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetTextFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6000 }
6001 arg4 = reinterpret_cast< wxWindow * >(argp4);
6002 }
6003 if (obj4) {
6004 ecode5 = SWIG_AsVal_int(obj4, &val5);
6005 if (!SWIG_IsOK(ecode5)) {
6006 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetTextFromUser" "', expected argument " "5"" of type '" "int""'");
6007 }
6008 arg5 = static_cast< int >(val5);
6009 }
6010 if (obj5) {
6011 ecode6 = SWIG_AsVal_int(obj5, &val6);
6012 if (!SWIG_IsOK(ecode6)) {
6013 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetTextFromUser" "', expected argument " "6"" of type '" "int""'");
6014 }
6015 arg6 = static_cast< int >(val6);
6016 }
6017 if (obj6) {
6018 ecode7 = SWIG_AsVal_bool(obj6, &val7);
6019 if (!SWIG_IsOK(ecode7)) {
6020 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetTextFromUser" "', expected argument " "7"" of type '" "bool""'");
6021 }
6022 arg7 = static_cast< bool >(val7);
6023 }
6024 {
6025 if (!wxPyCheckForApp()) SWIG_fail;
6026 PyThreadState* __tstate = wxPyBeginAllowThreads();
6027 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
6028 wxPyEndAllowThreads(__tstate);
6029 if (PyErr_Occurred()) SWIG_fail;
6030 }
6031 {
6032 #if wxUSE_UNICODE
6033 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6034 #else
6035 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6036 #endif
6037 }
6038 {
6039 if (temp1)
6040 delete arg1;
6041 }
6042 {
6043 if (temp2)
6044 delete arg2;
6045 }
6046 {
6047 if (temp3)
6048 delete arg3;
6049 }
6050 return resultobj;
6051 fail:
6052 {
6053 if (temp1)
6054 delete arg1;
6055 }
6056 {
6057 if (temp2)
6058 delete arg2;
6059 }
6060 {
6061 if (temp3)
6062 delete arg3;
6063 }
6064 return NULL;
6065 }
6066
6067
6068 SWIGINTERN PyObject *_wrap_GetPasswordFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6069 PyObject *resultobj = 0;
6070 wxString *arg1 = 0 ;
6071 wxString const &arg2_defvalue = wxPyEmptyString ;
6072 wxString *arg2 = (wxString *) &arg2_defvalue ;
6073 wxString const &arg3_defvalue = wxPyEmptyString ;
6074 wxString *arg3 = (wxString *) &arg3_defvalue ;
6075 wxWindow *arg4 = (wxWindow *) NULL ;
6076 wxString result;
6077 bool temp1 = false ;
6078 bool temp2 = false ;
6079 bool temp3 = false ;
6080 void *argp4 = 0 ;
6081 int res4 = 0 ;
6082 PyObject * obj0 = 0 ;
6083 PyObject * obj1 = 0 ;
6084 PyObject * obj2 = 0 ;
6085 PyObject * obj3 = 0 ;
6086 char * kwnames[] = {
6087 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
6088 };
6089
6090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6091 {
6092 arg1 = wxString_in_helper(obj0);
6093 if (arg1 == NULL) SWIG_fail;
6094 temp1 = true;
6095 }
6096 if (obj1) {
6097 {
6098 arg2 = wxString_in_helper(obj1);
6099 if (arg2 == NULL) SWIG_fail;
6100 temp2 = true;
6101 }
6102 }
6103 if (obj2) {
6104 {
6105 arg3 = wxString_in_helper(obj2);
6106 if (arg3 == NULL) SWIG_fail;
6107 temp3 = true;
6108 }
6109 }
6110 if (obj3) {
6111 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6112 if (!SWIG_IsOK(res4)) {
6113 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetPasswordFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6114 }
6115 arg4 = reinterpret_cast< wxWindow * >(argp4);
6116 }
6117 {
6118 if (!wxPyCheckForApp()) SWIG_fail;
6119 PyThreadState* __tstate = wxPyBeginAllowThreads();
6120 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
6121 wxPyEndAllowThreads(__tstate);
6122 if (PyErr_Occurred()) SWIG_fail;
6123 }
6124 {
6125 #if wxUSE_UNICODE
6126 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6127 #else
6128 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6129 #endif
6130 }
6131 {
6132 if (temp1)
6133 delete arg1;
6134 }
6135 {
6136 if (temp2)
6137 delete arg2;
6138 }
6139 {
6140 if (temp3)
6141 delete arg3;
6142 }
6143 return resultobj;
6144 fail:
6145 {
6146 if (temp1)
6147 delete arg1;
6148 }
6149 {
6150 if (temp2)
6151 delete arg2;
6152 }
6153 {
6154 if (temp3)
6155 delete arg3;
6156 }
6157 return NULL;
6158 }
6159
6160
6161 SWIGINTERN PyObject *_wrap_GetSingleChoice(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6162 PyObject *resultobj = 0;
6163 wxString *arg1 = 0 ;
6164 wxString *arg2 = 0 ;
6165 int arg3 ;
6166 wxString *arg4 = (wxString *) 0 ;
6167 wxWindow *arg5 = (wxWindow *) NULL ;
6168 int arg6 = (int) -1 ;
6169 int arg7 = (int) -1 ;
6170 bool arg8 = (bool) true ;
6171 int arg9 = (int) 150 ;
6172 int arg10 = (int) 200 ;
6173 wxString result;
6174 bool temp1 = false ;
6175 bool temp2 = false ;
6176 void *argp5 = 0 ;
6177 int res5 = 0 ;
6178 int val6 ;
6179 int ecode6 = 0 ;
6180 int val7 ;
6181 int ecode7 = 0 ;
6182 bool val8 ;
6183 int ecode8 = 0 ;
6184 int val9 ;
6185 int ecode9 = 0 ;
6186 int val10 ;
6187 int ecode10 = 0 ;
6188 PyObject * obj0 = 0 ;
6189 PyObject * obj1 = 0 ;
6190 PyObject * obj2 = 0 ;
6191 PyObject * obj3 = 0 ;
6192 PyObject * obj4 = 0 ;
6193 PyObject * obj5 = 0 ;
6194 PyObject * obj6 = 0 ;
6195 PyObject * obj7 = 0 ;
6196 PyObject * obj8 = 0 ;
6197 char * kwnames[] = {
6198 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6199 };
6200
6201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6202 {
6203 arg1 = wxString_in_helper(obj0);
6204 if (arg1 == NULL) SWIG_fail;
6205 temp1 = true;
6206 }
6207 {
6208 arg2 = wxString_in_helper(obj1);
6209 if (arg2 == NULL) SWIG_fail;
6210 temp2 = true;
6211 }
6212 {
6213 arg3 = PyList_Size(obj2);
6214 arg4 = wxString_LIST_helper(obj2);
6215 if (arg4 == NULL) SWIG_fail;
6216 }
6217 if (obj3) {
6218 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6219 if (!SWIG_IsOK(res5)) {
6220 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoice" "', expected argument " "5"" of type '" "wxWindow *""'");
6221 }
6222 arg5 = reinterpret_cast< wxWindow * >(argp5);
6223 }
6224 if (obj4) {
6225 ecode6 = SWIG_AsVal_int(obj4, &val6);
6226 if (!SWIG_IsOK(ecode6)) {
6227 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoice" "', expected argument " "6"" of type '" "int""'");
6228 }
6229 arg6 = static_cast< int >(val6);
6230 }
6231 if (obj5) {
6232 ecode7 = SWIG_AsVal_int(obj5, &val7);
6233 if (!SWIG_IsOK(ecode7)) {
6234 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoice" "', expected argument " "7"" of type '" "int""'");
6235 }
6236 arg7 = static_cast< int >(val7);
6237 }
6238 if (obj6) {
6239 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6240 if (!SWIG_IsOK(ecode8)) {
6241 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoice" "', expected argument " "8"" of type '" "bool""'");
6242 }
6243 arg8 = static_cast< bool >(val8);
6244 }
6245 if (obj7) {
6246 ecode9 = SWIG_AsVal_int(obj7, &val9);
6247 if (!SWIG_IsOK(ecode9)) {
6248 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoice" "', expected argument " "9"" of type '" "int""'");
6249 }
6250 arg9 = static_cast< int >(val9);
6251 }
6252 if (obj8) {
6253 ecode10 = SWIG_AsVal_int(obj8, &val10);
6254 if (!SWIG_IsOK(ecode10)) {
6255 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoice" "', expected argument " "10"" of type '" "int""'");
6256 }
6257 arg10 = static_cast< int >(val10);
6258 }
6259 {
6260 if (!wxPyCheckForApp()) SWIG_fail;
6261 PyThreadState* __tstate = wxPyBeginAllowThreads();
6262 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6263 wxPyEndAllowThreads(__tstate);
6264 if (PyErr_Occurred()) SWIG_fail;
6265 }
6266 {
6267 #if wxUSE_UNICODE
6268 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6269 #else
6270 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6271 #endif
6272 }
6273 {
6274 if (temp1)
6275 delete arg1;
6276 }
6277 {
6278 if (temp2)
6279 delete arg2;
6280 }
6281 {
6282 if (arg4) delete [] arg4;
6283 }
6284 return resultobj;
6285 fail:
6286 {
6287 if (temp1)
6288 delete arg1;
6289 }
6290 {
6291 if (temp2)
6292 delete arg2;
6293 }
6294 {
6295 if (arg4) delete [] arg4;
6296 }
6297 return NULL;
6298 }
6299
6300
6301 SWIGINTERN PyObject *_wrap_GetSingleChoiceIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6302 PyObject *resultobj = 0;
6303 wxString *arg1 = 0 ;
6304 wxString *arg2 = 0 ;
6305 int arg3 ;
6306 wxString *arg4 = (wxString *) 0 ;
6307 wxWindow *arg5 = (wxWindow *) NULL ;
6308 int arg6 = (int) -1 ;
6309 int arg7 = (int) -1 ;
6310 bool arg8 = (bool) true ;
6311 int arg9 = (int) 150 ;
6312 int arg10 = (int) 200 ;
6313 int result;
6314 bool temp1 = false ;
6315 bool temp2 = false ;
6316 void *argp5 = 0 ;
6317 int res5 = 0 ;
6318 int val6 ;
6319 int ecode6 = 0 ;
6320 int val7 ;
6321 int ecode7 = 0 ;
6322 bool val8 ;
6323 int ecode8 = 0 ;
6324 int val9 ;
6325 int ecode9 = 0 ;
6326 int val10 ;
6327 int ecode10 = 0 ;
6328 PyObject * obj0 = 0 ;
6329 PyObject * obj1 = 0 ;
6330 PyObject * obj2 = 0 ;
6331 PyObject * obj3 = 0 ;
6332 PyObject * obj4 = 0 ;
6333 PyObject * obj5 = 0 ;
6334 PyObject * obj6 = 0 ;
6335 PyObject * obj7 = 0 ;
6336 PyObject * obj8 = 0 ;
6337 char * kwnames[] = {
6338 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6339 };
6340
6341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6342 {
6343 arg1 = wxString_in_helper(obj0);
6344 if (arg1 == NULL) SWIG_fail;
6345 temp1 = true;
6346 }
6347 {
6348 arg2 = wxString_in_helper(obj1);
6349 if (arg2 == NULL) SWIG_fail;
6350 temp2 = true;
6351 }
6352 {
6353 arg3 = PyList_Size(obj2);
6354 arg4 = wxString_LIST_helper(obj2);
6355 if (arg4 == NULL) SWIG_fail;
6356 }
6357 if (obj3) {
6358 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6359 if (!SWIG_IsOK(res5)) {
6360 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoiceIndex" "', expected argument " "5"" of type '" "wxWindow *""'");
6361 }
6362 arg5 = reinterpret_cast< wxWindow * >(argp5);
6363 }
6364 if (obj4) {
6365 ecode6 = SWIG_AsVal_int(obj4, &val6);
6366 if (!SWIG_IsOK(ecode6)) {
6367 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoiceIndex" "', expected argument " "6"" of type '" "int""'");
6368 }
6369 arg6 = static_cast< int >(val6);
6370 }
6371 if (obj5) {
6372 ecode7 = SWIG_AsVal_int(obj5, &val7);
6373 if (!SWIG_IsOK(ecode7)) {
6374 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoiceIndex" "', expected argument " "7"" of type '" "int""'");
6375 }
6376 arg7 = static_cast< int >(val7);
6377 }
6378 if (obj6) {
6379 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6380 if (!SWIG_IsOK(ecode8)) {
6381 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoiceIndex" "', expected argument " "8"" of type '" "bool""'");
6382 }
6383 arg8 = static_cast< bool >(val8);
6384 }
6385 if (obj7) {
6386 ecode9 = SWIG_AsVal_int(obj7, &val9);
6387 if (!SWIG_IsOK(ecode9)) {
6388 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoiceIndex" "', expected argument " "9"" of type '" "int""'");
6389 }
6390 arg9 = static_cast< int >(val9);
6391 }
6392 if (obj8) {
6393 ecode10 = SWIG_AsVal_int(obj8, &val10);
6394 if (!SWIG_IsOK(ecode10)) {
6395 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoiceIndex" "', expected argument " "10"" of type '" "int""'");
6396 }
6397 arg10 = static_cast< int >(val10);
6398 }
6399 {
6400 if (!wxPyCheckForApp()) SWIG_fail;
6401 PyThreadState* __tstate = wxPyBeginAllowThreads();
6402 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6403 wxPyEndAllowThreads(__tstate);
6404 if (PyErr_Occurred()) SWIG_fail;
6405 }
6406 resultobj = SWIG_From_int(static_cast< int >(result));
6407 {
6408 if (temp1)
6409 delete arg1;
6410 }
6411 {
6412 if (temp2)
6413 delete arg2;
6414 }
6415 {
6416 if (arg4) delete [] arg4;
6417 }
6418 return resultobj;
6419 fail:
6420 {
6421 if (temp1)
6422 delete arg1;
6423 }
6424 {
6425 if (temp2)
6426 delete arg2;
6427 }
6428 {
6429 if (arg4) delete [] arg4;
6430 }
6431 return NULL;
6432 }
6433
6434
6435 SWIGINTERN PyObject *_wrap_MessageBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6436 PyObject *resultobj = 0;
6437 wxString *arg1 = 0 ;
6438 wxString const &arg2_defvalue = wxPyEmptyString ;
6439 wxString *arg2 = (wxString *) &arg2_defvalue ;
6440 int arg3 = (int) wxOK|wxCENTRE ;
6441 wxWindow *arg4 = (wxWindow *) NULL ;
6442 int arg5 = (int) -1 ;
6443 int arg6 = (int) -1 ;
6444 int result;
6445 bool temp1 = false ;
6446 bool temp2 = false ;
6447 int val3 ;
6448 int ecode3 = 0 ;
6449 void *argp4 = 0 ;
6450 int res4 = 0 ;
6451 int val5 ;
6452 int ecode5 = 0 ;
6453 int val6 ;
6454 int ecode6 = 0 ;
6455 PyObject * obj0 = 0 ;
6456 PyObject * obj1 = 0 ;
6457 PyObject * obj2 = 0 ;
6458 PyObject * obj3 = 0 ;
6459 PyObject * obj4 = 0 ;
6460 PyObject * obj5 = 0 ;
6461 char * kwnames[] = {
6462 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
6463 };
6464
6465 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
6466 {
6467 arg1 = wxString_in_helper(obj0);
6468 if (arg1 == NULL) SWIG_fail;
6469 temp1 = true;
6470 }
6471 if (obj1) {
6472 {
6473 arg2 = wxString_in_helper(obj1);
6474 if (arg2 == NULL) SWIG_fail;
6475 temp2 = true;
6476 }
6477 }
6478 if (obj2) {
6479 ecode3 = SWIG_AsVal_int(obj2, &val3);
6480 if (!SWIG_IsOK(ecode3)) {
6481 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MessageBox" "', expected argument " "3"" of type '" "int""'");
6482 }
6483 arg3 = static_cast< int >(val3);
6484 }
6485 if (obj3) {
6486 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6487 if (!SWIG_IsOK(res4)) {
6488 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MessageBox" "', expected argument " "4"" of type '" "wxWindow *""'");
6489 }
6490 arg4 = reinterpret_cast< wxWindow * >(argp4);
6491 }
6492 if (obj4) {
6493 ecode5 = SWIG_AsVal_int(obj4, &val5);
6494 if (!SWIG_IsOK(ecode5)) {
6495 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "MessageBox" "', expected argument " "5"" of type '" "int""'");
6496 }
6497 arg5 = static_cast< int >(val5);
6498 }
6499 if (obj5) {
6500 ecode6 = SWIG_AsVal_int(obj5, &val6);
6501 if (!SWIG_IsOK(ecode6)) {
6502 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "MessageBox" "', expected argument " "6"" of type '" "int""'");
6503 }
6504 arg6 = static_cast< int >(val6);
6505 }
6506 {
6507 if (!wxPyCheckForApp()) SWIG_fail;
6508 PyThreadState* __tstate = wxPyBeginAllowThreads();
6509 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
6510 wxPyEndAllowThreads(__tstate);
6511 if (PyErr_Occurred()) SWIG_fail;
6512 }
6513 resultobj = SWIG_From_int(static_cast< int >(result));
6514 {
6515 if (temp1)
6516 delete arg1;
6517 }
6518 {
6519 if (temp2)
6520 delete arg2;
6521 }
6522 return resultobj;
6523 fail:
6524 {
6525 if (temp1)
6526 delete arg1;
6527 }
6528 {
6529 if (temp2)
6530 delete arg2;
6531 }
6532 return NULL;
6533 }
6534
6535
6536 SWIGINTERN PyObject *_wrap_ColourDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6537 PyObject *resultobj = 0;
6538 bool result;
6539
6540 if (!SWIG_Python_UnpackTuple(args,"ColourDisplay",0,0,0)) SWIG_fail;
6541 {
6542 if (!wxPyCheckForApp()) SWIG_fail;
6543 PyThreadState* __tstate = wxPyBeginAllowThreads();
6544 result = (bool)wxColourDisplay();
6545 wxPyEndAllowThreads(__tstate);
6546 if (PyErr_Occurred()) SWIG_fail;
6547 }
6548 {
6549 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6550 }
6551 return resultobj;
6552 fail:
6553 return NULL;
6554 }
6555
6556
6557 SWIGINTERN PyObject *_wrap_DisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6558 PyObject *resultobj = 0;
6559 int result;
6560
6561 if (!SWIG_Python_UnpackTuple(args,"DisplayDepth",0,0,0)) SWIG_fail;
6562 {
6563 if (!wxPyCheckForApp()) SWIG_fail;
6564 PyThreadState* __tstate = wxPyBeginAllowThreads();
6565 result = (int)wxDisplayDepth();
6566 wxPyEndAllowThreads(__tstate);
6567 if (PyErr_Occurred()) SWIG_fail;
6568 }
6569 resultobj = SWIG_From_int(static_cast< int >(result));
6570 return resultobj;
6571 fail:
6572 return NULL;
6573 }
6574
6575
6576 SWIGINTERN PyObject *_wrap_GetDisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6577 PyObject *resultobj = 0;
6578 int result;
6579
6580 if (!SWIG_Python_UnpackTuple(args,"GetDisplayDepth",0,0,0)) SWIG_fail;
6581 {
6582 if (!wxPyCheckForApp()) SWIG_fail;
6583 PyThreadState* __tstate = wxPyBeginAllowThreads();
6584 result = (int)wxGetDisplayDepth();
6585 wxPyEndAllowThreads(__tstate);
6586 if (PyErr_Occurred()) SWIG_fail;
6587 }
6588 resultobj = SWIG_From_int(static_cast< int >(result));
6589 return resultobj;
6590 fail:
6591 return NULL;
6592 }
6593
6594
6595 SWIGINTERN PyObject *_wrap_DisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6596 PyObject *resultobj = 0;
6597 int *arg1 = (int *) 0 ;
6598 int *arg2 = (int *) 0 ;
6599 int temp1 ;
6600 int res1 = SWIG_TMPOBJ ;
6601 int temp2 ;
6602 int res2 = SWIG_TMPOBJ ;
6603
6604 arg1 = &temp1;
6605 arg2 = &temp2;
6606 if (!SWIG_Python_UnpackTuple(args,"DisplaySize",0,0,0)) SWIG_fail;
6607 {
6608 if (!wxPyCheckForApp()) SWIG_fail;
6609 PyThreadState* __tstate = wxPyBeginAllowThreads();
6610 wxDisplaySize(arg1,arg2);
6611 wxPyEndAllowThreads(__tstate);
6612 if (PyErr_Occurred()) SWIG_fail;
6613 }
6614 resultobj = SWIG_Py_Void();
6615 if (SWIG_IsTmpObj(res1)) {
6616 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6617 } else {
6618 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6619 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6620 }
6621 if (SWIG_IsTmpObj(res2)) {
6622 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6623 } else {
6624 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6625 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6626 }
6627 return resultobj;
6628 fail:
6629 return NULL;
6630 }
6631
6632
6633 SWIGINTERN PyObject *_wrap_GetDisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6634 PyObject *resultobj = 0;
6635 wxSize result;
6636
6637 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySize",0,0,0)) SWIG_fail;
6638 {
6639 if (!wxPyCheckForApp()) SWIG_fail;
6640 PyThreadState* __tstate = wxPyBeginAllowThreads();
6641 result = wxGetDisplaySize();
6642 wxPyEndAllowThreads(__tstate);
6643 if (PyErr_Occurred()) SWIG_fail;
6644 }
6645 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6646 return resultobj;
6647 fail:
6648 return NULL;
6649 }
6650
6651
6652 SWIGINTERN PyObject *_wrap_DisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6653 PyObject *resultobj = 0;
6654 int *arg1 = (int *) 0 ;
6655 int *arg2 = (int *) 0 ;
6656 int temp1 ;
6657 int res1 = SWIG_TMPOBJ ;
6658 int temp2 ;
6659 int res2 = SWIG_TMPOBJ ;
6660
6661 arg1 = &temp1;
6662 arg2 = &temp2;
6663 if (!SWIG_Python_UnpackTuple(args,"DisplaySizeMM",0,0,0)) SWIG_fail;
6664 {
6665 if (!wxPyCheckForApp()) SWIG_fail;
6666 PyThreadState* __tstate = wxPyBeginAllowThreads();
6667 wxDisplaySizeMM(arg1,arg2);
6668 wxPyEndAllowThreads(__tstate);
6669 if (PyErr_Occurred()) SWIG_fail;
6670 }
6671 resultobj = SWIG_Py_Void();
6672 if (SWIG_IsTmpObj(res1)) {
6673 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6674 } else {
6675 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6676 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6677 }
6678 if (SWIG_IsTmpObj(res2)) {
6679 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6680 } else {
6681 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6682 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6683 }
6684 return resultobj;
6685 fail:
6686 return NULL;
6687 }
6688
6689
6690 SWIGINTERN PyObject *_wrap_GetDisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6691 PyObject *resultobj = 0;
6692 wxSize result;
6693
6694 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySizeMM",0,0,0)) SWIG_fail;
6695 {
6696 if (!wxPyCheckForApp()) SWIG_fail;
6697 PyThreadState* __tstate = wxPyBeginAllowThreads();
6698 result = wxGetDisplaySizeMM();
6699 wxPyEndAllowThreads(__tstate);
6700 if (PyErr_Occurred()) SWIG_fail;
6701 }
6702 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6703 return resultobj;
6704 fail:
6705 return NULL;
6706 }
6707
6708
6709 SWIGINTERN PyObject *_wrap_ClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6710 PyObject *resultobj = 0;
6711 int *arg1 = (int *) 0 ;
6712 int *arg2 = (int *) 0 ;
6713 int *arg3 = (int *) 0 ;
6714 int *arg4 = (int *) 0 ;
6715 int temp1 ;
6716 int res1 = SWIG_TMPOBJ ;
6717 int temp2 ;
6718 int res2 = SWIG_TMPOBJ ;
6719 int temp3 ;
6720 int res3 = SWIG_TMPOBJ ;
6721 int temp4 ;
6722 int res4 = SWIG_TMPOBJ ;
6723
6724 arg1 = &temp1;
6725 arg2 = &temp2;
6726 arg3 = &temp3;
6727 arg4 = &temp4;
6728 if (!SWIG_Python_UnpackTuple(args,"ClientDisplayRect",0,0,0)) SWIG_fail;
6729 {
6730 if (!wxPyCheckForApp()) SWIG_fail;
6731 PyThreadState* __tstate = wxPyBeginAllowThreads();
6732 wxClientDisplayRect(arg1,arg2,arg3,arg4);
6733 wxPyEndAllowThreads(__tstate);
6734 if (PyErr_Occurred()) SWIG_fail;
6735 }
6736 resultobj = SWIG_Py_Void();
6737 if (SWIG_IsTmpObj(res1)) {
6738 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6739 } else {
6740 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6741 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6742 }
6743 if (SWIG_IsTmpObj(res2)) {
6744 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6745 } else {
6746 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6747 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6748 }
6749 if (SWIG_IsTmpObj(res3)) {
6750 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6751 } else {
6752 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6753 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6754 }
6755 if (SWIG_IsTmpObj(res4)) {
6756 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
6757 } else {
6758 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6759 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
6760 }
6761 return resultobj;
6762 fail:
6763 return NULL;
6764 }
6765
6766
6767 SWIGINTERN PyObject *_wrap_GetClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6768 PyObject *resultobj = 0;
6769 wxRect result;
6770
6771 if (!SWIG_Python_UnpackTuple(args,"GetClientDisplayRect",0,0,0)) SWIG_fail;
6772 {
6773 if (!wxPyCheckForApp()) SWIG_fail;
6774 PyThreadState* __tstate = wxPyBeginAllowThreads();
6775 result = wxGetClientDisplayRect();
6776 wxPyEndAllowThreads(__tstate);
6777 if (PyErr_Occurred()) SWIG_fail;
6778 }
6779 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6780 return resultobj;
6781 fail:
6782 return NULL;
6783 }
6784
6785
6786 SWIGINTERN PyObject *_wrap_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6787 PyObject *resultobj = 0;
6788 wxCursor *arg1 = 0 ;
6789 void *argp1 = 0 ;
6790 int res1 = 0 ;
6791 PyObject * obj0 = 0 ;
6792 char * kwnames[] = {
6793 (char *) "cursor", NULL
6794 };
6795
6796 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) SWIG_fail;
6797 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxCursor, 0 );
6798 if (!SWIG_IsOK(res1)) {
6799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
6800 }
6801 if (!argp1) {
6802 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
6803 }
6804 arg1 = reinterpret_cast< wxCursor * >(argp1);
6805 {
6806 if (!wxPyCheckForApp()) SWIG_fail;
6807 PyThreadState* __tstate = wxPyBeginAllowThreads();
6808 wxSetCursor(*arg1);
6809 wxPyEndAllowThreads(__tstate);
6810 if (PyErr_Occurred()) SWIG_fail;
6811 }
6812 resultobj = SWIG_Py_Void();
6813 return resultobj;
6814 fail:
6815 return NULL;
6816 }
6817
6818
6819 SWIGINTERN PyObject *_wrap_GetXDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6820 PyObject *resultobj = 0;
6821 void *result = 0 ;
6822
6823 if (!SWIG_Python_UnpackTuple(args,"GetXDisplay",0,0,0)) SWIG_fail;
6824 {
6825 if (!wxPyCheckForApp()) SWIG_fail;
6826 PyThreadState* __tstate = wxPyBeginAllowThreads();
6827 result = (void *)wxGetXDisplay();
6828 wxPyEndAllowThreads(__tstate);
6829 if (PyErr_Occurred()) SWIG_fail;
6830 }
6831 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
6832 return resultobj;
6833 fail:
6834 return NULL;
6835 }
6836
6837
6838 SWIGINTERN PyObject *_wrap_BeginBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6839 PyObject *resultobj = 0;
6840 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
6841 void *argp1 = 0 ;
6842 int res1 = 0 ;
6843 PyObject * obj0 = 0 ;
6844 char * kwnames[] = {
6845 (char *) "cursor", NULL
6846 };
6847
6848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) SWIG_fail;
6849 if (obj0) {
6850 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
6851 if (!SWIG_IsOK(res1)) {
6852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeginBusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
6853 }
6854 arg1 = reinterpret_cast< wxCursor * >(argp1);
6855 }
6856 {
6857 if (!wxPyCheckForApp()) SWIG_fail;
6858 PyThreadState* __tstate = wxPyBeginAllowThreads();
6859 wxBeginBusyCursor(arg1);
6860 wxPyEndAllowThreads(__tstate);
6861 if (PyErr_Occurred()) SWIG_fail;
6862 }
6863 resultobj = SWIG_Py_Void();
6864 return resultobj;
6865 fail:
6866 return NULL;
6867 }
6868
6869
6870 SWIGINTERN PyObject *_wrap_GetMousePosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6871 PyObject *resultobj = 0;
6872 wxPoint result;
6873
6874 if (!SWIG_Python_UnpackTuple(args,"GetMousePosition",0,0,0)) SWIG_fail;
6875 {
6876 if (!wxPyCheckForApp()) SWIG_fail;
6877 PyThreadState* __tstate = wxPyBeginAllowThreads();
6878 result = wxGetMousePosition();
6879 wxPyEndAllowThreads(__tstate);
6880 if (PyErr_Occurred()) SWIG_fail;
6881 }
6882 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6883 return resultobj;
6884 fail:
6885 return NULL;
6886 }
6887
6888
6889 SWIGINTERN PyObject *_wrap_FindWindowAtPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6890 PyObject *resultobj = 0;
6891 wxWindow *result = 0 ;
6892
6893 if (!SWIG_Python_UnpackTuple(args,"FindWindowAtPointer",0,0,0)) SWIG_fail;
6894 {
6895 if (!wxPyCheckForApp()) SWIG_fail;
6896 PyThreadState* __tstate = wxPyBeginAllowThreads();
6897 result = (wxWindow *)FindWindowAtPointer();
6898 wxPyEndAllowThreads(__tstate);
6899 if (PyErr_Occurred()) SWIG_fail;
6900 }
6901 {
6902 resultobj = wxPyMake_wxObject(result, 0);
6903 }
6904 return resultobj;
6905 fail:
6906 return NULL;
6907 }
6908
6909
6910 SWIGINTERN PyObject *_wrap_GetActiveWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6911 PyObject *resultobj = 0;
6912 wxWindow *result = 0 ;
6913
6914 if (!SWIG_Python_UnpackTuple(args,"GetActiveWindow",0,0,0)) SWIG_fail;
6915 {
6916 if (!wxPyCheckForApp()) SWIG_fail;
6917 PyThreadState* __tstate = wxPyBeginAllowThreads();
6918 result = (wxWindow *)wxGetActiveWindow();
6919 wxPyEndAllowThreads(__tstate);
6920 if (PyErr_Occurred()) SWIG_fail;
6921 }
6922 {
6923 resultobj = wxPyMake_wxObject(result, 0);
6924 }
6925 return resultobj;
6926 fail:
6927 return NULL;
6928 }
6929
6930
6931 SWIGINTERN PyObject *_wrap_GenericFindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6932 PyObject *resultobj = 0;
6933 wxPoint *arg1 = 0 ;
6934 wxWindow *result = 0 ;
6935 wxPoint temp1 ;
6936 PyObject * obj0 = 0 ;
6937 char * kwnames[] = {
6938 (char *) "pt", NULL
6939 };
6940
6941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
6942 {
6943 arg1 = &temp1;
6944 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6945 }
6946 {
6947 if (!wxPyCheckForApp()) SWIG_fail;
6948 PyThreadState* __tstate = wxPyBeginAllowThreads();
6949 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
6950 wxPyEndAllowThreads(__tstate);
6951 if (PyErr_Occurred()) SWIG_fail;
6952 }
6953 {
6954 resultobj = wxPyMake_wxObject(result, 0);
6955 }
6956 return resultobj;
6957 fail:
6958 return NULL;
6959 }
6960
6961
6962 SWIGINTERN PyObject *_wrap_FindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6963 PyObject *resultobj = 0;
6964 wxPoint *arg1 = 0 ;
6965 wxWindow *result = 0 ;
6966 wxPoint temp1 ;
6967 PyObject * obj0 = 0 ;
6968 char * kwnames[] = {
6969 (char *) "pt", NULL
6970 };
6971
6972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
6973 {
6974 arg1 = &temp1;
6975 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6976 }
6977 {
6978 if (!wxPyCheckForApp()) SWIG_fail;
6979 PyThreadState* __tstate = wxPyBeginAllowThreads();
6980 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
6981 wxPyEndAllowThreads(__tstate);
6982 if (PyErr_Occurred()) SWIG_fail;
6983 }
6984 {
6985 resultobj = wxPyMake_wxObject(result, 0);
6986 }
6987 return resultobj;
6988 fail:
6989 return NULL;
6990 }
6991
6992
6993 SWIGINTERN PyObject *_wrap_GetTopLevelParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6994 PyObject *resultobj = 0;
6995 wxWindow *arg1 = (wxWindow *) 0 ;
6996 wxWindow *result = 0 ;
6997 void *argp1 = 0 ;
6998 int res1 = 0 ;
6999 PyObject * obj0 = 0 ;
7000 char * kwnames[] = {
7001 (char *) "win", NULL
7002 };
7003
7004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) SWIG_fail;
7005 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
7006 if (!SWIG_IsOK(res1)) {
7007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetTopLevelParent" "', expected argument " "1"" of type '" "wxWindow *""'");
7008 }
7009 arg1 = reinterpret_cast< wxWindow * >(argp1);
7010 {
7011 if (!wxPyCheckForApp()) SWIG_fail;
7012 PyThreadState* __tstate = wxPyBeginAllowThreads();
7013 result = (wxWindow *)wxGetTopLevelParent(arg1);
7014 wxPyEndAllowThreads(__tstate);
7015 if (PyErr_Occurred()) SWIG_fail;
7016 }
7017 {
7018 resultobj = wxPyMake_wxObject(result, 0);
7019 }
7020 return resultobj;
7021 fail:
7022 return NULL;
7023 }
7024
7025
7026 SWIGINTERN PyObject *_wrap_LaunchDefaultBrowser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7027 PyObject *resultobj = 0;
7028 wxString *arg1 = 0 ;
7029 bool result;
7030 bool temp1 = false ;
7031 PyObject * obj0 = 0 ;
7032 char * kwnames[] = {
7033 (char *) "url", NULL
7034 };
7035
7036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LaunchDefaultBrowser",kwnames,&obj0)) SWIG_fail;
7037 {
7038 arg1 = wxString_in_helper(obj0);
7039 if (arg1 == NULL) SWIG_fail;
7040 temp1 = true;
7041 }
7042 {
7043 PyThreadState* __tstate = wxPyBeginAllowThreads();
7044 result = (bool)wxLaunchDefaultBrowser((wxString const &)*arg1);
7045 wxPyEndAllowThreads(__tstate);
7046 if (PyErr_Occurred()) SWIG_fail;
7047 }
7048 {
7049 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7050 }
7051 {
7052 if (temp1)
7053 delete arg1;
7054 }
7055 return resultobj;
7056 fail:
7057 {
7058 if (temp1)
7059 delete arg1;
7060 }
7061 return NULL;
7062 }
7063
7064
7065 SWIGINTERN PyObject *_wrap_GetKeyState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7066 PyObject *resultobj = 0;
7067 wxKeyCode arg1 ;
7068 bool result;
7069 int val1 ;
7070 int ecode1 = 0 ;
7071 PyObject * obj0 = 0 ;
7072 char * kwnames[] = {
7073 (char *) "key", NULL
7074 };
7075
7076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) SWIG_fail;
7077 ecode1 = SWIG_AsVal_int(obj0, &val1);
7078 if (!SWIG_IsOK(ecode1)) {
7079 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetKeyState" "', expected argument " "1"" of type '" "wxKeyCode""'");
7080 }
7081 arg1 = static_cast< wxKeyCode >(val1);
7082 {
7083 if (!wxPyCheckForApp()) SWIG_fail;
7084 PyThreadState* __tstate = wxPyBeginAllowThreads();
7085 result = (bool)wxGetKeyState(arg1);
7086 wxPyEndAllowThreads(__tstate);
7087 if (PyErr_Occurred()) SWIG_fail;
7088 }
7089 {
7090 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7091 }
7092 return resultobj;
7093 fail:
7094 return NULL;
7095 }
7096
7097
7098 SWIGINTERN PyObject *_wrap_new_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7099 PyObject *resultobj = 0;
7100 wxMouseState *result = 0 ;
7101
7102 if (!SWIG_Python_UnpackTuple(args,"new_MouseState",0,0,0)) SWIG_fail;
7103 {
7104 PyThreadState* __tstate = wxPyBeginAllowThreads();
7105 result = (wxMouseState *)new wxMouseState();
7106 wxPyEndAllowThreads(__tstate);
7107 if (PyErr_Occurred()) SWIG_fail;
7108 }
7109 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseState, SWIG_POINTER_NEW | 0 );
7110 return resultobj;
7111 fail:
7112 return NULL;
7113 }
7114
7115
7116 SWIGINTERN PyObject *_wrap_delete_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7117 PyObject *resultobj = 0;
7118 wxMouseState *arg1 = (wxMouseState *) 0 ;
7119 void *argp1 = 0 ;
7120 int res1 = 0 ;
7121 PyObject *swig_obj[1] ;
7122
7123 if (!args) SWIG_fail;
7124 swig_obj[0] = args;
7125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, SWIG_POINTER_DISOWN | 0 );
7126 if (!SWIG_IsOK(res1)) {
7127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MouseState" "', expected argument " "1"" of type '" "wxMouseState *""'");
7128 }
7129 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7130 {
7131 PyThreadState* __tstate = wxPyBeginAllowThreads();
7132 delete arg1;
7133
7134 wxPyEndAllowThreads(__tstate);
7135 if (PyErr_Occurred()) SWIG_fail;
7136 }
7137 resultobj = SWIG_Py_Void();
7138 return resultobj;
7139 fail:
7140 return NULL;
7141 }
7142
7143
7144 SWIGINTERN PyObject *_wrap_MouseState_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7145 PyObject *resultobj = 0;
7146 wxMouseState *arg1 = (wxMouseState *) 0 ;
7147 int result;
7148 void *argp1 = 0 ;
7149 int res1 = 0 ;
7150 PyObject *swig_obj[1] ;
7151
7152 if (!args) SWIG_fail;
7153 swig_obj[0] = args;
7154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7155 if (!SWIG_IsOK(res1)) {
7156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7157 }
7158 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7159 {
7160 PyThreadState* __tstate = wxPyBeginAllowThreads();
7161 result = (int)(arg1)->GetX();
7162 wxPyEndAllowThreads(__tstate);
7163 if (PyErr_Occurred()) SWIG_fail;
7164 }
7165 resultobj = SWIG_From_int(static_cast< int >(result));
7166 return resultobj;
7167 fail:
7168 return NULL;
7169 }
7170
7171
7172 SWIGINTERN PyObject *_wrap_MouseState_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7173 PyObject *resultobj = 0;
7174 wxMouseState *arg1 = (wxMouseState *) 0 ;
7175 int result;
7176 void *argp1 = 0 ;
7177 int res1 = 0 ;
7178 PyObject *swig_obj[1] ;
7179
7180 if (!args) SWIG_fail;
7181 swig_obj[0] = args;
7182 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7183 if (!SWIG_IsOK(res1)) {
7184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7185 }
7186 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7187 {
7188 PyThreadState* __tstate = wxPyBeginAllowThreads();
7189 result = (int)(arg1)->GetY();
7190 wxPyEndAllowThreads(__tstate);
7191 if (PyErr_Occurred()) SWIG_fail;
7192 }
7193 resultobj = SWIG_From_int(static_cast< int >(result));
7194 return resultobj;
7195 fail:
7196 return NULL;
7197 }
7198
7199
7200 SWIGINTERN PyObject *_wrap_MouseState_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7201 PyObject *resultobj = 0;
7202 wxMouseState *arg1 = (wxMouseState *) 0 ;
7203 bool result;
7204 void *argp1 = 0 ;
7205 int res1 = 0 ;
7206 PyObject *swig_obj[1] ;
7207
7208 if (!args) SWIG_fail;
7209 swig_obj[0] = args;
7210 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7211 if (!SWIG_IsOK(res1)) {
7212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_LeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7213 }
7214 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7215 {
7216 PyThreadState* __tstate = wxPyBeginAllowThreads();
7217 result = (bool)(arg1)->LeftDown();
7218 wxPyEndAllowThreads(__tstate);
7219 if (PyErr_Occurred()) SWIG_fail;
7220 }
7221 {
7222 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7223 }
7224 return resultobj;
7225 fail:
7226 return NULL;
7227 }
7228
7229
7230 SWIGINTERN PyObject *_wrap_MouseState_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7231 PyObject *resultobj = 0;
7232 wxMouseState *arg1 = (wxMouseState *) 0 ;
7233 bool result;
7234 void *argp1 = 0 ;
7235 int res1 = 0 ;
7236 PyObject *swig_obj[1] ;
7237
7238 if (!args) SWIG_fail;
7239 swig_obj[0] = args;
7240 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7241 if (!SWIG_IsOK(res1)) {
7242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7243 }
7244 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7245 {
7246 PyThreadState* __tstate = wxPyBeginAllowThreads();
7247 result = (bool)(arg1)->MiddleDown();
7248 wxPyEndAllowThreads(__tstate);
7249 if (PyErr_Occurred()) SWIG_fail;
7250 }
7251 {
7252 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7253 }
7254 return resultobj;
7255 fail:
7256 return NULL;
7257 }
7258
7259
7260 SWIGINTERN PyObject *_wrap_MouseState_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7261 PyObject *resultobj = 0;
7262 wxMouseState *arg1 = (wxMouseState *) 0 ;
7263 bool result;
7264 void *argp1 = 0 ;
7265 int res1 = 0 ;
7266 PyObject *swig_obj[1] ;
7267
7268 if (!args) SWIG_fail;
7269 swig_obj[0] = args;
7270 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7271 if (!SWIG_IsOK(res1)) {
7272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_RightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7273 }
7274 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7275 {
7276 PyThreadState* __tstate = wxPyBeginAllowThreads();
7277 result = (bool)(arg1)->RightDown();
7278 wxPyEndAllowThreads(__tstate);
7279 if (PyErr_Occurred()) SWIG_fail;
7280 }
7281 {
7282 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7283 }
7284 return resultobj;
7285 fail:
7286 return NULL;
7287 }
7288
7289
7290 SWIGINTERN PyObject *_wrap_MouseState_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7291 PyObject *resultobj = 0;
7292 wxMouseState *arg1 = (wxMouseState *) 0 ;
7293 bool result;
7294 void *argp1 = 0 ;
7295 int res1 = 0 ;
7296 PyObject *swig_obj[1] ;
7297
7298 if (!args) SWIG_fail;
7299 swig_obj[0] = args;
7300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7301 if (!SWIG_IsOK(res1)) {
7302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7303 }
7304 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7305 {
7306 PyThreadState* __tstate = wxPyBeginAllowThreads();
7307 result = (bool)(arg1)->ControlDown();
7308 wxPyEndAllowThreads(__tstate);
7309 if (PyErr_Occurred()) SWIG_fail;
7310 }
7311 {
7312 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7313 }
7314 return resultobj;
7315 fail:
7316 return NULL;
7317 }
7318
7319
7320 SWIGINTERN PyObject *_wrap_MouseState_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7321 PyObject *resultobj = 0;
7322 wxMouseState *arg1 = (wxMouseState *) 0 ;
7323 bool result;
7324 void *argp1 = 0 ;
7325 int res1 = 0 ;
7326 PyObject *swig_obj[1] ;
7327
7328 if (!args) SWIG_fail;
7329 swig_obj[0] = args;
7330 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7331 if (!SWIG_IsOK(res1)) {
7332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7333 }
7334 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7335 {
7336 PyThreadState* __tstate = wxPyBeginAllowThreads();
7337 result = (bool)(arg1)->ShiftDown();
7338 wxPyEndAllowThreads(__tstate);
7339 if (PyErr_Occurred()) SWIG_fail;
7340 }
7341 {
7342 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7343 }
7344 return resultobj;
7345 fail:
7346 return NULL;
7347 }
7348
7349
7350 SWIGINTERN PyObject *_wrap_MouseState_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7351 PyObject *resultobj = 0;
7352 wxMouseState *arg1 = (wxMouseState *) 0 ;
7353 bool result;
7354 void *argp1 = 0 ;
7355 int res1 = 0 ;
7356 PyObject *swig_obj[1] ;
7357
7358 if (!args) SWIG_fail;
7359 swig_obj[0] = args;
7360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7361 if (!SWIG_IsOK(res1)) {
7362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_AltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7363 }
7364 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7365 {
7366 PyThreadState* __tstate = wxPyBeginAllowThreads();
7367 result = (bool)(arg1)->AltDown();
7368 wxPyEndAllowThreads(__tstate);
7369 if (PyErr_Occurred()) SWIG_fail;
7370 }
7371 {
7372 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7373 }
7374 return resultobj;
7375 fail:
7376 return NULL;
7377 }
7378
7379
7380 SWIGINTERN PyObject *_wrap_MouseState_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7381 PyObject *resultobj = 0;
7382 wxMouseState *arg1 = (wxMouseState *) 0 ;
7383 bool result;
7384 void *argp1 = 0 ;
7385 int res1 = 0 ;
7386 PyObject *swig_obj[1] ;
7387
7388 if (!args) SWIG_fail;
7389 swig_obj[0] = args;
7390 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7391 if (!SWIG_IsOK(res1)) {
7392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7393 }
7394 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7395 {
7396 PyThreadState* __tstate = wxPyBeginAllowThreads();
7397 result = (bool)(arg1)->MetaDown();
7398 wxPyEndAllowThreads(__tstate);
7399 if (PyErr_Occurred()) SWIG_fail;
7400 }
7401 {
7402 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7403 }
7404 return resultobj;
7405 fail:
7406 return NULL;
7407 }
7408
7409
7410 SWIGINTERN PyObject *_wrap_MouseState_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7411 PyObject *resultobj = 0;
7412 wxMouseState *arg1 = (wxMouseState *) 0 ;
7413 bool result;
7414 void *argp1 = 0 ;
7415 int res1 = 0 ;
7416 PyObject *swig_obj[1] ;
7417
7418 if (!args) SWIG_fail;
7419 swig_obj[0] = args;
7420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7421 if (!SWIG_IsOK(res1)) {
7422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_CmdDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7423 }
7424 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7425 {
7426 PyThreadState* __tstate = wxPyBeginAllowThreads();
7427 result = (bool)(arg1)->CmdDown();
7428 wxPyEndAllowThreads(__tstate);
7429 if (PyErr_Occurred()) SWIG_fail;
7430 }
7431 {
7432 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7433 }
7434 return resultobj;
7435 fail:
7436 return NULL;
7437 }
7438
7439
7440 SWIGINTERN PyObject *_wrap_MouseState_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7441 PyObject *resultobj = 0;
7442 wxMouseState *arg1 = (wxMouseState *) 0 ;
7443 int arg2 ;
7444 void *argp1 = 0 ;
7445 int res1 = 0 ;
7446 int val2 ;
7447 int ecode2 = 0 ;
7448 PyObject * obj0 = 0 ;
7449 PyObject * obj1 = 0 ;
7450 char * kwnames[] = {
7451 (char *) "self",(char *) "x", NULL
7452 };
7453
7454 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
7455 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7456 if (!SWIG_IsOK(res1)) {
7457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7458 }
7459 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7460 ecode2 = SWIG_AsVal_int(obj1, &val2);
7461 if (!SWIG_IsOK(ecode2)) {
7462 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetX" "', expected argument " "2"" of type '" "int""'");
7463 }
7464 arg2 = static_cast< int >(val2);
7465 {
7466 PyThreadState* __tstate = wxPyBeginAllowThreads();
7467 (arg1)->SetX(arg2);
7468 wxPyEndAllowThreads(__tstate);
7469 if (PyErr_Occurred()) SWIG_fail;
7470 }
7471 resultobj = SWIG_Py_Void();
7472 return resultobj;
7473 fail:
7474 return NULL;
7475 }
7476
7477
7478 SWIGINTERN PyObject *_wrap_MouseState_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7479 PyObject *resultobj = 0;
7480 wxMouseState *arg1 = (wxMouseState *) 0 ;
7481 int arg2 ;
7482 void *argp1 = 0 ;
7483 int res1 = 0 ;
7484 int val2 ;
7485 int ecode2 = 0 ;
7486 PyObject * obj0 = 0 ;
7487 PyObject * obj1 = 0 ;
7488 char * kwnames[] = {
7489 (char *) "self",(char *) "y", NULL
7490 };
7491
7492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
7493 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7494 if (!SWIG_IsOK(res1)) {
7495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7496 }
7497 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7498 ecode2 = SWIG_AsVal_int(obj1, &val2);
7499 if (!SWIG_IsOK(ecode2)) {
7500 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetY" "', expected argument " "2"" of type '" "int""'");
7501 }
7502 arg2 = static_cast< int >(val2);
7503 {
7504 PyThreadState* __tstate = wxPyBeginAllowThreads();
7505 (arg1)->SetY(arg2);
7506 wxPyEndAllowThreads(__tstate);
7507 if (PyErr_Occurred()) SWIG_fail;
7508 }
7509 resultobj = SWIG_Py_Void();
7510 return resultobj;
7511 fail:
7512 return NULL;
7513 }
7514
7515
7516 SWIGINTERN PyObject *_wrap_MouseState_SetLeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7517 PyObject *resultobj = 0;
7518 wxMouseState *arg1 = (wxMouseState *) 0 ;
7519 bool arg2 ;
7520 void *argp1 = 0 ;
7521 int res1 = 0 ;
7522 bool val2 ;
7523 int ecode2 = 0 ;
7524 PyObject * obj0 = 0 ;
7525 PyObject * obj1 = 0 ;
7526 char * kwnames[] = {
7527 (char *) "self",(char *) "down", NULL
7528 };
7529
7530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetLeftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7532 if (!SWIG_IsOK(res1)) {
7533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetLeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7534 }
7535 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7536 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7537 if (!SWIG_IsOK(ecode2)) {
7538 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetLeftDown" "', expected argument " "2"" of type '" "bool""'");
7539 }
7540 arg2 = static_cast< bool >(val2);
7541 {
7542 PyThreadState* __tstate = wxPyBeginAllowThreads();
7543 (arg1)->SetLeftDown(arg2);
7544 wxPyEndAllowThreads(__tstate);
7545 if (PyErr_Occurred()) SWIG_fail;
7546 }
7547 resultobj = SWIG_Py_Void();
7548 return resultobj;
7549 fail:
7550 return NULL;
7551 }
7552
7553
7554 SWIGINTERN PyObject *_wrap_MouseState_SetMiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7555 PyObject *resultobj = 0;
7556 wxMouseState *arg1 = (wxMouseState *) 0 ;
7557 bool arg2 ;
7558 void *argp1 = 0 ;
7559 int res1 = 0 ;
7560 bool val2 ;
7561 int ecode2 = 0 ;
7562 PyObject * obj0 = 0 ;
7563 PyObject * obj1 = 0 ;
7564 char * kwnames[] = {
7565 (char *) "self",(char *) "down", NULL
7566 };
7567
7568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMiddleDown",kwnames,&obj0,&obj1)) SWIG_fail;
7569 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7570 if (!SWIG_IsOK(res1)) {
7571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7572 }
7573 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7574 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7575 if (!SWIG_IsOK(ecode2)) {
7576 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMiddleDown" "', expected argument " "2"" of type '" "bool""'");
7577 }
7578 arg2 = static_cast< bool >(val2);
7579 {
7580 PyThreadState* __tstate = wxPyBeginAllowThreads();
7581 (arg1)->SetMiddleDown(arg2);
7582 wxPyEndAllowThreads(__tstate);
7583 if (PyErr_Occurred()) SWIG_fail;
7584 }
7585 resultobj = SWIG_Py_Void();
7586 return resultobj;
7587 fail:
7588 return NULL;
7589 }
7590
7591
7592 SWIGINTERN PyObject *_wrap_MouseState_SetRightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7593 PyObject *resultobj = 0;
7594 wxMouseState *arg1 = (wxMouseState *) 0 ;
7595 bool arg2 ;
7596 void *argp1 = 0 ;
7597 int res1 = 0 ;
7598 bool val2 ;
7599 int ecode2 = 0 ;
7600 PyObject * obj0 = 0 ;
7601 PyObject * obj1 = 0 ;
7602 char * kwnames[] = {
7603 (char *) "self",(char *) "down", NULL
7604 };
7605
7606 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetRightDown",kwnames,&obj0,&obj1)) SWIG_fail;
7607 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7608 if (!SWIG_IsOK(res1)) {
7609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetRightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7610 }
7611 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7612 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7613 if (!SWIG_IsOK(ecode2)) {
7614 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetRightDown" "', expected argument " "2"" of type '" "bool""'");
7615 }
7616 arg2 = static_cast< bool >(val2);
7617 {
7618 PyThreadState* __tstate = wxPyBeginAllowThreads();
7619 (arg1)->SetRightDown(arg2);
7620 wxPyEndAllowThreads(__tstate);
7621 if (PyErr_Occurred()) SWIG_fail;
7622 }
7623 resultobj = SWIG_Py_Void();
7624 return resultobj;
7625 fail:
7626 return NULL;
7627 }
7628
7629
7630 SWIGINTERN PyObject *_wrap_MouseState_SetControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7631 PyObject *resultobj = 0;
7632 wxMouseState *arg1 = (wxMouseState *) 0 ;
7633 bool arg2 ;
7634 void *argp1 = 0 ;
7635 int res1 = 0 ;
7636 bool val2 ;
7637 int ecode2 = 0 ;
7638 PyObject * obj0 = 0 ;
7639 PyObject * obj1 = 0 ;
7640 char * kwnames[] = {
7641 (char *) "self",(char *) "down", NULL
7642 };
7643
7644 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetControlDown",kwnames,&obj0,&obj1)) SWIG_fail;
7645 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7646 if (!SWIG_IsOK(res1)) {
7647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7648 }
7649 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7650 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7651 if (!SWIG_IsOK(ecode2)) {
7652 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetControlDown" "', expected argument " "2"" of type '" "bool""'");
7653 }
7654 arg2 = static_cast< bool >(val2);
7655 {
7656 PyThreadState* __tstate = wxPyBeginAllowThreads();
7657 (arg1)->SetControlDown(arg2);
7658 wxPyEndAllowThreads(__tstate);
7659 if (PyErr_Occurred()) SWIG_fail;
7660 }
7661 resultobj = SWIG_Py_Void();
7662 return resultobj;
7663 fail:
7664 return NULL;
7665 }
7666
7667
7668 SWIGINTERN PyObject *_wrap_MouseState_SetShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7669 PyObject *resultobj = 0;
7670 wxMouseState *arg1 = (wxMouseState *) 0 ;
7671 bool arg2 ;
7672 void *argp1 = 0 ;
7673 int res1 = 0 ;
7674 bool val2 ;
7675 int ecode2 = 0 ;
7676 PyObject * obj0 = 0 ;
7677 PyObject * obj1 = 0 ;
7678 char * kwnames[] = {
7679 (char *) "self",(char *) "down", NULL
7680 };
7681
7682 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetShiftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7683 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7684 if (!SWIG_IsOK(res1)) {
7685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7686 }
7687 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7688 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7689 if (!SWIG_IsOK(ecode2)) {
7690 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetShiftDown" "', expected argument " "2"" of type '" "bool""'");
7691 }
7692 arg2 = static_cast< bool >(val2);
7693 {
7694 PyThreadState* __tstate = wxPyBeginAllowThreads();
7695 (arg1)->SetShiftDown(arg2);
7696 wxPyEndAllowThreads(__tstate);
7697 if (PyErr_Occurred()) SWIG_fail;
7698 }
7699 resultobj = SWIG_Py_Void();
7700 return resultobj;
7701 fail:
7702 return NULL;
7703 }
7704
7705
7706 SWIGINTERN PyObject *_wrap_MouseState_SetAltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7707 PyObject *resultobj = 0;
7708 wxMouseState *arg1 = (wxMouseState *) 0 ;
7709 bool arg2 ;
7710 void *argp1 = 0 ;
7711 int res1 = 0 ;
7712 bool val2 ;
7713 int ecode2 = 0 ;
7714 PyObject * obj0 = 0 ;
7715 PyObject * obj1 = 0 ;
7716 char * kwnames[] = {
7717 (char *) "self",(char *) "down", NULL
7718 };
7719
7720 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetAltDown",kwnames,&obj0,&obj1)) SWIG_fail;
7721 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7722 if (!SWIG_IsOK(res1)) {
7723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetAltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7724 }
7725 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7726 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7727 if (!SWIG_IsOK(ecode2)) {
7728 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetAltDown" "', expected argument " "2"" of type '" "bool""'");
7729 }
7730 arg2 = static_cast< bool >(val2);
7731 {
7732 PyThreadState* __tstate = wxPyBeginAllowThreads();
7733 (arg1)->SetAltDown(arg2);
7734 wxPyEndAllowThreads(__tstate);
7735 if (PyErr_Occurred()) SWIG_fail;
7736 }
7737 resultobj = SWIG_Py_Void();
7738 return resultobj;
7739 fail:
7740 return NULL;
7741 }
7742
7743
7744 SWIGINTERN PyObject *_wrap_MouseState_SetMetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7745 PyObject *resultobj = 0;
7746 wxMouseState *arg1 = (wxMouseState *) 0 ;
7747 bool arg2 ;
7748 void *argp1 = 0 ;
7749 int res1 = 0 ;
7750 bool val2 ;
7751 int ecode2 = 0 ;
7752 PyObject * obj0 = 0 ;
7753 PyObject * obj1 = 0 ;
7754 char * kwnames[] = {
7755 (char *) "self",(char *) "down", NULL
7756 };
7757
7758 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMetaDown",kwnames,&obj0,&obj1)) SWIG_fail;
7759 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7760 if (!SWIG_IsOK(res1)) {
7761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7762 }
7763 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7764 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7765 if (!SWIG_IsOK(ecode2)) {
7766 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMetaDown" "', expected argument " "2"" of type '" "bool""'");
7767 }
7768 arg2 = static_cast< bool >(val2);
7769 {
7770 PyThreadState* __tstate = wxPyBeginAllowThreads();
7771 (arg1)->SetMetaDown(arg2);
7772 wxPyEndAllowThreads(__tstate);
7773 if (PyErr_Occurred()) SWIG_fail;
7774 }
7775 resultobj = SWIG_Py_Void();
7776 return resultobj;
7777 fail:
7778 return NULL;
7779 }
7780
7781
7782 SWIGINTERN PyObject *MouseState_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7783 PyObject *obj;
7784 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7785 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseState, SWIG_NewClientData(obj));
7786 return SWIG_Py_Void();
7787 }
7788
7789 SWIGINTERN PyObject *MouseState_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7790 return SWIG_Python_InitShadowInstance(args);
7791 }
7792
7793 SWIGINTERN PyObject *_wrap_GetMouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7794 PyObject *resultobj = 0;
7795 wxMouseState result;
7796
7797 if (!SWIG_Python_UnpackTuple(args,"GetMouseState",0,0,0)) SWIG_fail;
7798 {
7799 PyThreadState* __tstate = wxPyBeginAllowThreads();
7800 result = wxGetMouseState();
7801 wxPyEndAllowThreads(__tstate);
7802 if (PyErr_Occurred()) SWIG_fail;
7803 }
7804 resultobj = SWIG_NewPointerObj((new wxMouseState(static_cast< const wxMouseState& >(result))), SWIGTYPE_p_wxMouseState, SWIG_POINTER_OWN | 0 );
7805 return resultobj;
7806 fail:
7807 return NULL;
7808 }
7809
7810
7811 SWIGINTERN PyObject *_wrap_WakeUpMainThread(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7812 PyObject *resultobj = 0;
7813
7814 if (!SWIG_Python_UnpackTuple(args,"WakeUpMainThread",0,0,0)) SWIG_fail;
7815 {
7816 if (!wxPyCheckForApp()) SWIG_fail;
7817 PyThreadState* __tstate = wxPyBeginAllowThreads();
7818 wxWakeUpMainThread();
7819 wxPyEndAllowThreads(__tstate);
7820 if (PyErr_Occurred()) SWIG_fail;
7821 }
7822 resultobj = SWIG_Py_Void();
7823 return resultobj;
7824 fail:
7825 return NULL;
7826 }
7827
7828
7829 SWIGINTERN PyObject *_wrap_MutexGuiEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7830 PyObject *resultobj = 0;
7831
7832 if (!SWIG_Python_UnpackTuple(args,"MutexGuiEnter",0,0,0)) SWIG_fail;
7833 {
7834 if (!wxPyCheckForApp()) SWIG_fail;
7835 PyThreadState* __tstate = wxPyBeginAllowThreads();
7836 wxMutexGuiEnter();
7837 wxPyEndAllowThreads(__tstate);
7838 if (PyErr_Occurred()) SWIG_fail;
7839 }
7840 resultobj = SWIG_Py_Void();
7841 return resultobj;
7842 fail:
7843 return NULL;
7844 }
7845
7846
7847 SWIGINTERN PyObject *_wrap_MutexGuiLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7848 PyObject *resultobj = 0;
7849
7850 if (!SWIG_Python_UnpackTuple(args,"MutexGuiLeave",0,0,0)) SWIG_fail;
7851 {
7852 if (!wxPyCheckForApp()) SWIG_fail;
7853 PyThreadState* __tstate = wxPyBeginAllowThreads();
7854 wxMutexGuiLeave();
7855 wxPyEndAllowThreads(__tstate);
7856 if (PyErr_Occurred()) SWIG_fail;
7857 }
7858 resultobj = SWIG_Py_Void();
7859 return resultobj;
7860 fail:
7861 return NULL;
7862 }
7863
7864
7865 SWIGINTERN PyObject *_wrap_new_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7866 PyObject *resultobj = 0;
7867 wxMutexGuiLocker *result = 0 ;
7868
7869 if (!SWIG_Python_UnpackTuple(args,"new_MutexGuiLocker",0,0,0)) SWIG_fail;
7870 {
7871 if (!wxPyCheckForApp()) SWIG_fail;
7872 PyThreadState* __tstate = wxPyBeginAllowThreads();
7873 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
7874 wxPyEndAllowThreads(__tstate);
7875 if (PyErr_Occurred()) SWIG_fail;
7876 }
7877 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_NEW | 0 );
7878 return resultobj;
7879 fail:
7880 return NULL;
7881 }
7882
7883
7884 SWIGINTERN PyObject *_wrap_delete_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7885 PyObject *resultobj = 0;
7886 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
7887 void *argp1 = 0 ;
7888 int res1 = 0 ;
7889 PyObject *swig_obj[1] ;
7890
7891 if (!args) SWIG_fail;
7892 swig_obj[0] = args;
7893 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_DISOWN | 0 );
7894 if (!SWIG_IsOK(res1)) {
7895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MutexGuiLocker" "', expected argument " "1"" of type '" "wxMutexGuiLocker *""'");
7896 }
7897 arg1 = reinterpret_cast< wxMutexGuiLocker * >(argp1);
7898 {
7899 PyThreadState* __tstate = wxPyBeginAllowThreads();
7900 delete arg1;
7901
7902 wxPyEndAllowThreads(__tstate);
7903 if (PyErr_Occurred()) SWIG_fail;
7904 }
7905 resultobj = SWIG_Py_Void();
7906 return resultobj;
7907 fail:
7908 return NULL;
7909 }
7910
7911
7912 SWIGINTERN PyObject *MutexGuiLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7913 PyObject *obj;
7914 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7915 SWIG_TypeNewClientData(SWIGTYPE_p_wxMutexGuiLocker, SWIG_NewClientData(obj));
7916 return SWIG_Py_Void();
7917 }
7918
7919 SWIGINTERN PyObject *MutexGuiLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7920 return SWIG_Python_InitShadowInstance(args);
7921 }
7922
7923 SWIGINTERN PyObject *_wrap_Thread_IsMain(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7924 PyObject *resultobj = 0;
7925 bool result;
7926
7927 if (!SWIG_Python_UnpackTuple(args,"Thread_IsMain",0,0,0)) SWIG_fail;
7928 {
7929 PyThreadState* __tstate = wxPyBeginAllowThreads();
7930 result = (bool)wxThread_IsMain();
7931 wxPyEndAllowThreads(__tstate);
7932 if (PyErr_Occurred()) SWIG_fail;
7933 }
7934 {
7935 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7936 }
7937 return resultobj;
7938 fail:
7939 return NULL;
7940 }
7941
7942
7943 SWIGINTERN PyObject *_wrap_new_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7944 PyObject *resultobj = 0;
7945 wxString *arg1 = 0 ;
7946 wxToolTip *result = 0 ;
7947 bool temp1 = false ;
7948 PyObject * obj0 = 0 ;
7949 char * kwnames[] = {
7950 (char *) "tip", NULL
7951 };
7952
7953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) SWIG_fail;
7954 {
7955 arg1 = wxString_in_helper(obj0);
7956 if (arg1 == NULL) SWIG_fail;
7957 temp1 = true;
7958 }
7959 {
7960 if (!wxPyCheckForApp()) SWIG_fail;
7961 PyThreadState* __tstate = wxPyBeginAllowThreads();
7962 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
7963 wxPyEndAllowThreads(__tstate);
7964 if (PyErr_Occurred()) SWIG_fail;
7965 }
7966 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxToolTip, SWIG_POINTER_NEW | 0 );
7967 {
7968 if (temp1)
7969 delete arg1;
7970 }
7971 return resultobj;
7972 fail:
7973 {
7974 if (temp1)
7975 delete arg1;
7976 }
7977 return NULL;
7978 }
7979
7980
7981 SWIGINTERN PyObject *_wrap_delete_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7982 PyObject *resultobj = 0;
7983 wxToolTip *arg1 = (wxToolTip *) 0 ;
7984 void *argp1 = 0 ;
7985 int res1 = 0 ;
7986 PyObject *swig_obj[1] ;
7987
7988 if (!args) SWIG_fail;
7989 swig_obj[0] = args;
7990 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
7991 if (!SWIG_IsOK(res1)) {
7992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ToolTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
7993 }
7994 arg1 = reinterpret_cast< wxToolTip * >(argp1);
7995 {
7996 PyThreadState* __tstate = wxPyBeginAllowThreads();
7997 delete arg1;
7998
7999 wxPyEndAllowThreads(__tstate);
8000 if (PyErr_Occurred()) SWIG_fail;
8001 }
8002 resultobj = SWIG_Py_Void();
8003 return resultobj;
8004 fail:
8005 return NULL;
8006 }
8007
8008
8009 SWIGINTERN PyObject *_wrap_ToolTip_SetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8010 PyObject *resultobj = 0;
8011 wxToolTip *arg1 = (wxToolTip *) 0 ;
8012 wxString *arg2 = 0 ;
8013 void *argp1 = 0 ;
8014 int res1 = 0 ;
8015 bool temp2 = false ;
8016 PyObject * obj0 = 0 ;
8017 PyObject * obj1 = 0 ;
8018 char * kwnames[] = {
8019 (char *) "self",(char *) "tip", NULL
8020 };
8021
8022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) SWIG_fail;
8023 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8024 if (!SWIG_IsOK(res1)) {
8025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_SetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8026 }
8027 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8028 {
8029 arg2 = wxString_in_helper(obj1);
8030 if (arg2 == NULL) SWIG_fail;
8031 temp2 = true;
8032 }
8033 {
8034 PyThreadState* __tstate = wxPyBeginAllowThreads();
8035 (arg1)->SetTip((wxString const &)*arg2);
8036 wxPyEndAllowThreads(__tstate);
8037 if (PyErr_Occurred()) SWIG_fail;
8038 }
8039 resultobj = SWIG_Py_Void();
8040 {
8041 if (temp2)
8042 delete arg2;
8043 }
8044 return resultobj;
8045 fail:
8046 {
8047 if (temp2)
8048 delete arg2;
8049 }
8050 return NULL;
8051 }
8052
8053
8054 SWIGINTERN PyObject *_wrap_ToolTip_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8055 PyObject *resultobj = 0;
8056 wxToolTip *arg1 = (wxToolTip *) 0 ;
8057 wxString result;
8058 void *argp1 = 0 ;
8059 int res1 = 0 ;
8060 PyObject *swig_obj[1] ;
8061
8062 if (!args) SWIG_fail;
8063 swig_obj[0] = args;
8064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8065 if (!SWIG_IsOK(res1)) {
8066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8067 }
8068 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8069 {
8070 PyThreadState* __tstate = wxPyBeginAllowThreads();
8071 result = (arg1)->GetTip();
8072 wxPyEndAllowThreads(__tstate);
8073 if (PyErr_Occurred()) SWIG_fail;
8074 }
8075 {
8076 #if wxUSE_UNICODE
8077 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8078 #else
8079 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8080 #endif
8081 }
8082 return resultobj;
8083 fail:
8084 return NULL;
8085 }
8086
8087
8088 SWIGINTERN PyObject *_wrap_ToolTip_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8089 PyObject *resultobj = 0;
8090 wxToolTip *arg1 = (wxToolTip *) 0 ;
8091 wxWindow *result = 0 ;
8092 void *argp1 = 0 ;
8093 int res1 = 0 ;
8094 PyObject *swig_obj[1] ;
8095
8096 if (!args) SWIG_fail;
8097 swig_obj[0] = args;
8098 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8099 if (!SWIG_IsOK(res1)) {
8100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetWindow" "', expected argument " "1"" of type '" "wxToolTip *""'");
8101 }
8102 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8103 {
8104 PyThreadState* __tstate = wxPyBeginAllowThreads();
8105 result = (wxWindow *)(arg1)->GetWindow();
8106 wxPyEndAllowThreads(__tstate);
8107 if (PyErr_Occurred()) SWIG_fail;
8108 }
8109 {
8110 resultobj = wxPyMake_wxObject(result, 0);
8111 }
8112 return resultobj;
8113 fail:
8114 return NULL;
8115 }
8116
8117
8118 SWIGINTERN PyObject *_wrap_ToolTip_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8119 PyObject *resultobj = 0;
8120 bool arg1 ;
8121 bool val1 ;
8122 int ecode1 = 0 ;
8123 PyObject * obj0 = 0 ;
8124 char * kwnames[] = {
8125 (char *) "flag", NULL
8126 };
8127
8128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) SWIG_fail;
8129 ecode1 = SWIG_AsVal_bool(obj0, &val1);
8130 if (!SWIG_IsOK(ecode1)) {
8131 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_Enable" "', expected argument " "1"" of type '" "bool""'");
8132 }
8133 arg1 = static_cast< bool >(val1);
8134 {
8135 PyThreadState* __tstate = wxPyBeginAllowThreads();
8136 wxToolTip::Enable(arg1);
8137 wxPyEndAllowThreads(__tstate);
8138 if (PyErr_Occurred()) SWIG_fail;
8139 }
8140 resultobj = SWIG_Py_Void();
8141 return resultobj;
8142 fail:
8143 return NULL;
8144 }
8145
8146
8147 SWIGINTERN PyObject *_wrap_ToolTip_SetDelay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8148 PyObject *resultobj = 0;
8149 long arg1 ;
8150 long val1 ;
8151 int ecode1 = 0 ;
8152 PyObject * obj0 = 0 ;
8153 char * kwnames[] = {
8154 (char *) "milliseconds", NULL
8155 };
8156
8157 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) SWIG_fail;
8158 ecode1 = SWIG_AsVal_long(obj0, &val1);
8159 if (!SWIG_IsOK(ecode1)) {
8160 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_SetDelay" "', expected argument " "1"" of type '" "long""'");
8161 }
8162 arg1 = static_cast< long >(val1);
8163 {
8164 PyThreadState* __tstate = wxPyBeginAllowThreads();
8165 wxToolTip::SetDelay(arg1);
8166 wxPyEndAllowThreads(__tstate);
8167 if (PyErr_Occurred()) SWIG_fail;
8168 }
8169 resultobj = SWIG_Py_Void();
8170 return resultobj;
8171 fail:
8172 return NULL;
8173 }
8174
8175
8176 SWIGINTERN PyObject *ToolTip_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8177 PyObject *obj;
8178 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8179 SWIG_TypeNewClientData(SWIGTYPE_p_wxToolTip, SWIG_NewClientData(obj));
8180 return SWIG_Py_Void();
8181 }
8182
8183 SWIGINTERN PyObject *ToolTip_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8184 return SWIG_Python_InitShadowInstance(args);
8185 }
8186
8187 SWIGINTERN PyObject *_wrap_new_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8188 PyObject *resultobj = 0;
8189 wxWindow *arg1 = (wxWindow *) 0 ;
8190 wxSize *arg2 = 0 ;
8191 wxCaret *result = 0 ;
8192 void *argp1 = 0 ;
8193 int res1 = 0 ;
8194 wxSize temp2 ;
8195 PyObject * obj0 = 0 ;
8196 PyObject * obj1 = 0 ;
8197 char * kwnames[] = {
8198 (char *) "window",(char *) "size", NULL
8199 };
8200
8201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) SWIG_fail;
8202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
8203 if (!SWIG_IsOK(res1)) {
8204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Caret" "', expected argument " "1"" of type '" "wxWindow *""'");
8205 }
8206 arg1 = reinterpret_cast< wxWindow * >(argp1);
8207 {
8208 arg2 = &temp2;
8209 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8210 }
8211 {
8212 if (!wxPyCheckForApp()) SWIG_fail;
8213 PyThreadState* __tstate = wxPyBeginAllowThreads();
8214 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
8215 wxPyEndAllowThreads(__tstate);
8216 if (PyErr_Occurred()) SWIG_fail;
8217 }
8218 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, SWIG_POINTER_NEW | 0 );
8219 return resultobj;
8220 fail:
8221 return NULL;
8222 }
8223
8224
8225 SWIGINTERN PyObject *_wrap_delete_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8226 PyObject *resultobj = 0;
8227 wxCaret *arg1 = (wxCaret *) 0 ;
8228 void *argp1 = 0 ;
8229 int res1 = 0 ;
8230 PyObject *swig_obj[1] ;
8231
8232 if (!args) SWIG_fail;
8233 swig_obj[0] = args;
8234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
8235 if (!SWIG_IsOK(res1)) {
8236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Caret" "', expected argument " "1"" of type '" "wxCaret *""'");
8237 }
8238 arg1 = reinterpret_cast< wxCaret * >(argp1);
8239 {
8240 PyThreadState* __tstate = wxPyBeginAllowThreads();
8241 delete arg1;
8242
8243 wxPyEndAllowThreads(__tstate);
8244 if (PyErr_Occurred()) SWIG_fail;
8245 }
8246 resultobj = SWIG_Py_Void();
8247 return resultobj;
8248 fail:
8249 return NULL;
8250 }
8251
8252
8253 SWIGINTERN PyObject *_wrap_Caret_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8254 PyObject *resultobj = 0;
8255 wxCaret *arg1 = (wxCaret *) 0 ;
8256 void *argp1 = 0 ;
8257 int res1 = 0 ;
8258 PyObject *swig_obj[1] ;
8259
8260 if (!args) SWIG_fail;
8261 swig_obj[0] = args;
8262 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8263 if (!SWIG_IsOK(res1)) {
8264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Destroy" "', expected argument " "1"" of type '" "wxCaret *""'");
8265 }
8266 arg1 = reinterpret_cast< wxCaret * >(argp1);
8267 {
8268 PyThreadState* __tstate = wxPyBeginAllowThreads();
8269 wxCaret_Destroy(arg1);
8270 wxPyEndAllowThreads(__tstate);
8271 if (PyErr_Occurred()) SWIG_fail;
8272 }
8273 resultobj = SWIG_Py_Void();
8274 return resultobj;
8275 fail:
8276 return NULL;
8277 }
8278
8279
8280 SWIGINTERN PyObject *_wrap_Caret_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8281 PyObject *resultobj = 0;
8282 wxCaret *arg1 = (wxCaret *) 0 ;
8283 bool result;
8284 void *argp1 = 0 ;
8285 int res1 = 0 ;
8286 PyObject *swig_obj[1] ;
8287
8288 if (!args) SWIG_fail;
8289 swig_obj[0] = args;
8290 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8291 if (!SWIG_IsOK(res1)) {
8292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsOk" "', expected argument " "1"" of type '" "wxCaret *""'");
8293 }
8294 arg1 = reinterpret_cast< wxCaret * >(argp1);
8295 {
8296 PyThreadState* __tstate = wxPyBeginAllowThreads();
8297 result = (bool)(arg1)->IsOk();
8298 wxPyEndAllowThreads(__tstate);
8299 if (PyErr_Occurred()) SWIG_fail;
8300 }
8301 {
8302 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8303 }
8304 return resultobj;
8305 fail:
8306 return NULL;
8307 }
8308
8309
8310 SWIGINTERN PyObject *_wrap_Caret_IsVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8311 PyObject *resultobj = 0;
8312 wxCaret *arg1 = (wxCaret *) 0 ;
8313 bool result;
8314 void *argp1 = 0 ;
8315 int res1 = 0 ;
8316 PyObject *swig_obj[1] ;
8317
8318 if (!args) SWIG_fail;
8319 swig_obj[0] = args;
8320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8321 if (!SWIG_IsOK(res1)) {
8322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsVisible" "', expected argument " "1"" of type '" "wxCaret *""'");
8323 }
8324 arg1 = reinterpret_cast< wxCaret * >(argp1);
8325 {
8326 PyThreadState* __tstate = wxPyBeginAllowThreads();
8327 result = (bool)(arg1)->IsVisible();
8328 wxPyEndAllowThreads(__tstate);
8329 if (PyErr_Occurred()) SWIG_fail;
8330 }
8331 {
8332 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8333 }
8334 return resultobj;
8335 fail:
8336 return NULL;
8337 }
8338
8339
8340 SWIGINTERN PyObject *_wrap_Caret_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8341 PyObject *resultobj = 0;
8342 wxCaret *arg1 = (wxCaret *) 0 ;
8343 wxPoint result;
8344 void *argp1 = 0 ;
8345 int res1 = 0 ;
8346 PyObject *swig_obj[1] ;
8347
8348 if (!args) SWIG_fail;
8349 swig_obj[0] = args;
8350 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8351 if (!SWIG_IsOK(res1)) {
8352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPosition" "', expected argument " "1"" of type '" "wxCaret *""'");
8353 }
8354 arg1 = reinterpret_cast< wxCaret * >(argp1);
8355 {
8356 PyThreadState* __tstate = wxPyBeginAllowThreads();
8357 result = (arg1)->GetPosition();
8358 wxPyEndAllowThreads(__tstate);
8359 if (PyErr_Occurred()) SWIG_fail;
8360 }
8361 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
8362 return resultobj;
8363 fail:
8364 return NULL;
8365 }
8366
8367
8368 SWIGINTERN PyObject *_wrap_Caret_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8369 PyObject *resultobj = 0;
8370 wxCaret *arg1 = (wxCaret *) 0 ;
8371 int *arg2 = (int *) 0 ;
8372 int *arg3 = (int *) 0 ;
8373 void *argp1 = 0 ;
8374 int res1 = 0 ;
8375 int temp2 ;
8376 int res2 = SWIG_TMPOBJ ;
8377 int temp3 ;
8378 int res3 = SWIG_TMPOBJ ;
8379 PyObject *swig_obj[1] ;
8380
8381 arg2 = &temp2;
8382 arg3 = &temp3;
8383 if (!args) SWIG_fail;
8384 swig_obj[0] = args;
8385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8386 if (!SWIG_IsOK(res1)) {
8387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPositionTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8388 }
8389 arg1 = reinterpret_cast< wxCaret * >(argp1);
8390 {
8391 PyThreadState* __tstate = wxPyBeginAllowThreads();
8392 (arg1)->GetPosition(arg2,arg3);
8393 wxPyEndAllowThreads(__tstate);
8394 if (PyErr_Occurred()) SWIG_fail;
8395 }
8396 resultobj = SWIG_Py_Void();
8397 if (SWIG_IsTmpObj(res2)) {
8398 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8399 } else {
8400 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8401 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8402 }
8403 if (SWIG_IsTmpObj(res3)) {
8404 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8405 } else {
8406 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8407 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8408 }
8409 return resultobj;
8410 fail:
8411 return NULL;
8412 }
8413
8414
8415 SWIGINTERN PyObject *_wrap_Caret_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8416 PyObject *resultobj = 0;
8417 wxCaret *arg1 = (wxCaret *) 0 ;
8418 wxSize result;
8419 void *argp1 = 0 ;
8420 int res1 = 0 ;
8421 PyObject *swig_obj[1] ;
8422
8423 if (!args) SWIG_fail;
8424 swig_obj[0] = args;
8425 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8426 if (!SWIG_IsOK(res1)) {
8427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8428 }
8429 arg1 = reinterpret_cast< wxCaret * >(argp1);
8430 {
8431 PyThreadState* __tstate = wxPyBeginAllowThreads();
8432 result = (arg1)->GetSize();
8433 wxPyEndAllowThreads(__tstate);
8434 if (PyErr_Occurred()) SWIG_fail;
8435 }
8436 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
8437 return resultobj;
8438 fail:
8439 return NULL;
8440 }
8441
8442
8443 SWIGINTERN PyObject *_wrap_Caret_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8444 PyObject *resultobj = 0;
8445 wxCaret *arg1 = (wxCaret *) 0 ;
8446 int *arg2 = (int *) 0 ;
8447 int *arg3 = (int *) 0 ;
8448 void *argp1 = 0 ;
8449 int res1 = 0 ;
8450 int temp2 ;
8451 int res2 = SWIG_TMPOBJ ;
8452 int temp3 ;
8453 int res3 = SWIG_TMPOBJ ;
8454 PyObject *swig_obj[1] ;
8455
8456 arg2 = &temp2;
8457 arg3 = &temp3;
8458 if (!args) SWIG_fail;
8459 swig_obj[0] = args;
8460 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8461 if (!SWIG_IsOK(res1)) {
8462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSizeTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8463 }
8464 arg1 = reinterpret_cast< wxCaret * >(argp1);
8465 {
8466 PyThreadState* __tstate = wxPyBeginAllowThreads();
8467 (arg1)->GetSize(arg2,arg3);
8468 wxPyEndAllowThreads(__tstate);
8469 if (PyErr_Occurred()) SWIG_fail;
8470 }
8471 resultobj = SWIG_Py_Void();
8472 if (SWIG_IsTmpObj(res2)) {
8473 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8474 } else {
8475 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8476 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8477 }
8478 if (SWIG_IsTmpObj(res3)) {
8479 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8480 } else {
8481 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8482 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8483 }
8484 return resultobj;
8485 fail:
8486 return NULL;
8487 }
8488
8489
8490 SWIGINTERN PyObject *_wrap_Caret_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8491 PyObject *resultobj = 0;
8492 wxCaret *arg1 = (wxCaret *) 0 ;
8493 wxWindow *result = 0 ;
8494 void *argp1 = 0 ;
8495 int res1 = 0 ;
8496 PyObject *swig_obj[1] ;
8497
8498 if (!args) SWIG_fail;
8499 swig_obj[0] = args;
8500 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8501 if (!SWIG_IsOK(res1)) {
8502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetWindow" "', expected argument " "1"" of type '" "wxCaret *""'");
8503 }
8504 arg1 = reinterpret_cast< wxCaret * >(argp1);
8505 {
8506 PyThreadState* __tstate = wxPyBeginAllowThreads();
8507 result = (wxWindow *)(arg1)->GetWindow();
8508 wxPyEndAllowThreads(__tstate);
8509 if (PyErr_Occurred()) SWIG_fail;
8510 }
8511 {
8512 resultobj = wxPyMake_wxObject(result, 0);
8513 }
8514 return resultobj;
8515 fail:
8516 return NULL;
8517 }
8518
8519
8520 SWIGINTERN PyObject *_wrap_Caret_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8521 PyObject *resultobj = 0;
8522 wxCaret *arg1 = (wxCaret *) 0 ;
8523 int arg2 ;
8524 int arg3 ;
8525 void *argp1 = 0 ;
8526 int res1 = 0 ;
8527 int val2 ;
8528 int ecode2 = 0 ;
8529 int val3 ;
8530 int ecode3 = 0 ;
8531 PyObject * obj0 = 0 ;
8532 PyObject * obj1 = 0 ;
8533 PyObject * obj2 = 0 ;
8534 char * kwnames[] = {
8535 (char *) "self",(char *) "x",(char *) "y", NULL
8536 };
8537
8538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8539 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8540 if (!SWIG_IsOK(res1)) {
8541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_MoveXY" "', expected argument " "1"" of type '" "wxCaret *""'");
8542 }
8543 arg1 = reinterpret_cast< wxCaret * >(argp1);
8544 ecode2 = SWIG_AsVal_int(obj1, &val2);
8545 if (!SWIG_IsOK(ecode2)) {
8546 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_MoveXY" "', expected argument " "2"" of type '" "int""'");
8547 }
8548 arg2 = static_cast< int >(val2);
8549 ecode3 = SWIG_AsVal_int(obj2, &val3);
8550 if (!SWIG_IsOK(ecode3)) {
8551 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_MoveXY" "', expected argument " "3"" of type '" "int""'");
8552 }
8553 arg3 = static_cast< int >(val3);
8554 {
8555 PyThreadState* __tstate = wxPyBeginAllowThreads();
8556 (arg1)->Move(arg2,arg3);
8557 wxPyEndAllowThreads(__tstate);
8558 if (PyErr_Occurred()) SWIG_fail;
8559 }
8560 resultobj = SWIG_Py_Void();
8561 return resultobj;
8562 fail:
8563 return NULL;
8564 }
8565
8566
8567 SWIGINTERN PyObject *_wrap_Caret_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8568 PyObject *resultobj = 0;
8569 wxCaret *arg1 = (wxCaret *) 0 ;
8570 wxPoint *arg2 = 0 ;
8571 void *argp1 = 0 ;
8572 int res1 = 0 ;
8573 wxPoint temp2 ;
8574 PyObject * obj0 = 0 ;
8575 PyObject * obj1 = 0 ;
8576 char * kwnames[] = {
8577 (char *) "self",(char *) "pt", NULL
8578 };
8579
8580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) SWIG_fail;
8581 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8582 if (!SWIG_IsOK(res1)) {
8583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Move" "', expected argument " "1"" of type '" "wxCaret *""'");
8584 }
8585 arg1 = reinterpret_cast< wxCaret * >(argp1);
8586 {
8587 arg2 = &temp2;
8588 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
8589 }
8590 {
8591 PyThreadState* __tstate = wxPyBeginAllowThreads();
8592 (arg1)->Move((wxPoint const &)*arg2);
8593 wxPyEndAllowThreads(__tstate);
8594 if (PyErr_Occurred()) SWIG_fail;
8595 }
8596 resultobj = SWIG_Py_Void();
8597 return resultobj;
8598 fail:
8599 return NULL;
8600 }
8601
8602
8603 SWIGINTERN PyObject *_wrap_Caret_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8604 PyObject *resultobj = 0;
8605 wxCaret *arg1 = (wxCaret *) 0 ;
8606 int arg2 ;
8607 int arg3 ;
8608 void *argp1 = 0 ;
8609 int res1 = 0 ;
8610 int val2 ;
8611 int ecode2 = 0 ;
8612 int val3 ;
8613 int ecode3 = 0 ;
8614 PyObject * obj0 = 0 ;
8615 PyObject * obj1 = 0 ;
8616 PyObject * obj2 = 0 ;
8617 char * kwnames[] = {
8618 (char *) "self",(char *) "width",(char *) "height", NULL
8619 };
8620
8621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8623 if (!SWIG_IsOK(res1)) {
8624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSizeWH" "', expected argument " "1"" of type '" "wxCaret *""'");
8625 }
8626 arg1 = reinterpret_cast< wxCaret * >(argp1);
8627 ecode2 = SWIG_AsVal_int(obj1, &val2);
8628 if (!SWIG_IsOK(ecode2)) {
8629 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
8630 }
8631 arg2 = static_cast< int >(val2);
8632 ecode3 = SWIG_AsVal_int(obj2, &val3);
8633 if (!SWIG_IsOK(ecode3)) {
8634 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
8635 }
8636 arg3 = static_cast< int >(val3);
8637 {
8638 PyThreadState* __tstate = wxPyBeginAllowThreads();
8639 (arg1)->SetSize(arg2,arg3);
8640 wxPyEndAllowThreads(__tstate);
8641 if (PyErr_Occurred()) SWIG_fail;
8642 }
8643 resultobj = SWIG_Py_Void();
8644 return resultobj;
8645 fail:
8646 return NULL;
8647 }
8648
8649
8650 SWIGINTERN PyObject *_wrap_Caret_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8651 PyObject *resultobj = 0;
8652 wxCaret *arg1 = (wxCaret *) 0 ;
8653 wxSize *arg2 = 0 ;
8654 void *argp1 = 0 ;
8655 int res1 = 0 ;
8656 wxSize temp2 ;
8657 PyObject * obj0 = 0 ;
8658 PyObject * obj1 = 0 ;
8659 char * kwnames[] = {
8660 (char *) "self",(char *) "size", NULL
8661 };
8662
8663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
8664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8665 if (!SWIG_IsOK(res1)) {
8666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8667 }
8668 arg1 = reinterpret_cast< wxCaret * >(argp1);
8669 {
8670 arg2 = &temp2;
8671 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8672 }
8673 {
8674 PyThreadState* __tstate = wxPyBeginAllowThreads();
8675 (arg1)->SetSize((wxSize const &)*arg2);
8676 wxPyEndAllowThreads(__tstate);
8677 if (PyErr_Occurred()) SWIG_fail;
8678 }
8679 resultobj = SWIG_Py_Void();
8680 return resultobj;
8681 fail:
8682 return NULL;
8683 }
8684
8685
8686 SWIGINTERN PyObject *_wrap_Caret_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8687 PyObject *resultobj = 0;
8688 wxCaret *arg1 = (wxCaret *) 0 ;
8689 int arg2 = (int) true ;
8690 void *argp1 = 0 ;
8691 int res1 = 0 ;
8692 int val2 ;
8693 int ecode2 = 0 ;
8694 PyObject * obj0 = 0 ;
8695 PyObject * obj1 = 0 ;
8696 char * kwnames[] = {
8697 (char *) "self",(char *) "show", NULL
8698 };
8699
8700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) SWIG_fail;
8701 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8702 if (!SWIG_IsOK(res1)) {
8703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Show" "', expected argument " "1"" of type '" "wxCaret *""'");
8704 }
8705 arg1 = reinterpret_cast< wxCaret * >(argp1);
8706 if (obj1) {
8707 ecode2 = SWIG_AsVal_int(obj1, &val2);
8708 if (!SWIG_IsOK(ecode2)) {
8709 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_Show" "', expected argument " "2"" of type '" "int""'");
8710 }
8711 arg2 = static_cast< int >(val2);
8712 }
8713 {
8714 PyThreadState* __tstate = wxPyBeginAllowThreads();
8715 (arg1)->Show(arg2);
8716 wxPyEndAllowThreads(__tstate);
8717 if (PyErr_Occurred()) SWIG_fail;
8718 }
8719 resultobj = SWIG_Py_Void();
8720 return resultobj;
8721 fail:
8722 return NULL;
8723 }
8724
8725
8726 SWIGINTERN PyObject *_wrap_Caret_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8727 PyObject *resultobj = 0;
8728 wxCaret *arg1 = (wxCaret *) 0 ;
8729 void *argp1 = 0 ;
8730 int res1 = 0 ;
8731 PyObject *swig_obj[1] ;
8732
8733 if (!args) SWIG_fail;
8734 swig_obj[0] = args;
8735 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8736 if (!SWIG_IsOK(res1)) {
8737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Hide" "', expected argument " "1"" of type '" "wxCaret *""'");
8738 }
8739 arg1 = reinterpret_cast< wxCaret * >(argp1);
8740 {
8741 PyThreadState* __tstate = wxPyBeginAllowThreads();
8742 (arg1)->Hide();
8743 wxPyEndAllowThreads(__tstate);
8744 if (PyErr_Occurred()) SWIG_fail;
8745 }
8746 resultobj = SWIG_Py_Void();
8747 return resultobj;
8748 fail:
8749 return NULL;
8750 }
8751
8752
8753 SWIGINTERN PyObject *_wrap_Caret_GetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8754 PyObject *resultobj = 0;
8755 int result;
8756
8757 if (!SWIG_Python_UnpackTuple(args,"Caret_GetBlinkTime",0,0,0)) SWIG_fail;
8758 {
8759 PyThreadState* __tstate = wxPyBeginAllowThreads();
8760 result = (int)wxCaret::GetBlinkTime();
8761 wxPyEndAllowThreads(__tstate);
8762 if (PyErr_Occurred()) SWIG_fail;
8763 }
8764 resultobj = SWIG_From_int(static_cast< int >(result));
8765 return resultobj;
8766 fail:
8767 return NULL;
8768 }
8769
8770
8771 SWIGINTERN PyObject *_wrap_Caret_SetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8772 PyObject *resultobj = 0;
8773 int arg1 ;
8774 int val1 ;
8775 int ecode1 = 0 ;
8776 PyObject * obj0 = 0 ;
8777 char * kwnames[] = {
8778 (char *) "milliseconds", NULL
8779 };
8780
8781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) SWIG_fail;
8782 ecode1 = SWIG_AsVal_int(obj0, &val1);
8783 if (!SWIG_IsOK(ecode1)) {
8784 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Caret_SetBlinkTime" "', expected argument " "1"" of type '" "int""'");
8785 }
8786 arg1 = static_cast< int >(val1);
8787 {
8788 PyThreadState* __tstate = wxPyBeginAllowThreads();
8789 wxCaret::SetBlinkTime(arg1);
8790 wxPyEndAllowThreads(__tstate);
8791 if (PyErr_Occurred()) SWIG_fail;
8792 }
8793 resultobj = SWIG_Py_Void();
8794 return resultobj;
8795 fail:
8796 return NULL;
8797 }
8798
8799
8800 SWIGINTERN PyObject *Caret_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8801 PyObject *obj;
8802 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8803 SWIG_TypeNewClientData(SWIGTYPE_p_wxCaret, SWIG_NewClientData(obj));
8804 return SWIG_Py_Void();
8805 }
8806
8807 SWIGINTERN PyObject *Caret_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8808 return SWIG_Python_InitShadowInstance(args);
8809 }
8810
8811 SWIGINTERN PyObject *_wrap_new_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8812 PyObject *resultobj = 0;
8813 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
8814 wxBusyCursor *result = 0 ;
8815 void *argp1 = 0 ;
8816 int res1 = 0 ;
8817 PyObject * obj0 = 0 ;
8818 char * kwnames[] = {
8819 (char *) "cursor", NULL
8820 };
8821
8822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) SWIG_fail;
8823 if (obj0) {
8824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
8825 if (!SWIG_IsOK(res1)) {
8826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
8827 }
8828 arg1 = reinterpret_cast< wxCursor * >(argp1);
8829 }
8830 {
8831 if (!wxPyCheckForApp()) SWIG_fail;
8832 PyThreadState* __tstate = wxPyBeginAllowThreads();
8833 result = (wxBusyCursor *)new wxBusyCursor(arg1);
8834 wxPyEndAllowThreads(__tstate);
8835 if (PyErr_Occurred()) SWIG_fail;
8836 }
8837 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_NEW | 0 );
8838 return resultobj;
8839 fail:
8840 return NULL;
8841 }
8842
8843
8844 SWIGINTERN PyObject *_wrap_delete_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8845 PyObject *resultobj = 0;
8846 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
8847 void *argp1 = 0 ;
8848 int res1 = 0 ;
8849 PyObject *swig_obj[1] ;
8850
8851 if (!args) SWIG_fail;
8852 swig_obj[0] = args;
8853 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_DISOWN | 0 );
8854 if (!SWIG_IsOK(res1)) {
8855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyCursor" "', expected argument " "1"" of type '" "wxBusyCursor *""'");
8856 }
8857 arg1 = reinterpret_cast< wxBusyCursor * >(argp1);
8858 {
8859 PyThreadState* __tstate = wxPyBeginAllowThreads();
8860 delete arg1;
8861
8862 wxPyEndAllowThreads(__tstate);
8863 if (PyErr_Occurred()) SWIG_fail;
8864 }
8865 resultobj = SWIG_Py_Void();
8866 return resultobj;
8867 fail:
8868 return NULL;
8869 }
8870
8871
8872 SWIGINTERN PyObject *BusyCursor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8873 PyObject *obj;
8874 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8875 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyCursor, SWIG_NewClientData(obj));
8876 return SWIG_Py_Void();
8877 }
8878
8879 SWIGINTERN PyObject *BusyCursor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8880 return SWIG_Python_InitShadowInstance(args);
8881 }
8882
8883 SWIGINTERN PyObject *_wrap_new_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8884 PyObject *resultobj = 0;
8885 wxWindow *arg1 = (wxWindow *) NULL ;
8886 wxWindowDisabler *result = 0 ;
8887 void *argp1 = 0 ;
8888 int res1 = 0 ;
8889 PyObject * obj0 = 0 ;
8890 char * kwnames[] = {
8891 (char *) "winToSkip", NULL
8892 };
8893
8894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) SWIG_fail;
8895 if (obj0) {
8896 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
8897 if (!SWIG_IsOK(res1)) {
8898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDisabler" "', expected argument " "1"" of type '" "wxWindow *""'");
8899 }
8900 arg1 = reinterpret_cast< wxWindow * >(argp1);
8901 }
8902 {
8903 if (!wxPyCheckForApp()) SWIG_fail;
8904 PyThreadState* __tstate = wxPyBeginAllowThreads();
8905 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
8906 wxPyEndAllowThreads(__tstate);
8907 if (PyErr_Occurred()) SWIG_fail;
8908 }
8909 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_NEW | 0 );
8910 return resultobj;
8911 fail:
8912 return NULL;
8913 }
8914
8915
8916 SWIGINTERN PyObject *_wrap_delete_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8917 PyObject *resultobj = 0;
8918 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
8919 void *argp1 = 0 ;
8920 int res1 = 0 ;
8921 PyObject *swig_obj[1] ;
8922
8923 if (!args) SWIG_fail;
8924 swig_obj[0] = args;
8925 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_DISOWN | 0 );
8926 if (!SWIG_IsOK(res1)) {
8927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_WindowDisabler" "', expected argument " "1"" of type '" "wxWindowDisabler *""'");
8928 }
8929 arg1 = reinterpret_cast< wxWindowDisabler * >(argp1);
8930 {
8931 PyThreadState* __tstate = wxPyBeginAllowThreads();
8932 delete arg1;
8933
8934 wxPyEndAllowThreads(__tstate);
8935 if (PyErr_Occurred()) SWIG_fail;
8936 }
8937 resultobj = SWIG_Py_Void();
8938 return resultobj;
8939 fail:
8940 return NULL;
8941 }
8942
8943
8944 SWIGINTERN PyObject *WindowDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8945 PyObject *obj;
8946 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8947 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDisabler, SWIG_NewClientData(obj));
8948 return SWIG_Py_Void();
8949 }
8950
8951 SWIGINTERN PyObject *WindowDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8952 return SWIG_Python_InitShadowInstance(args);
8953 }
8954
8955 SWIGINTERN PyObject *_wrap_new_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8956 PyObject *resultobj = 0;
8957 wxString *arg1 = 0 ;
8958 wxBusyInfo *result = 0 ;
8959 bool temp1 = false ;
8960 PyObject * obj0 = 0 ;
8961 char * kwnames[] = {
8962 (char *) "message", NULL
8963 };
8964
8965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) SWIG_fail;
8966 {
8967 arg1 = wxString_in_helper(obj0);
8968 if (arg1 == NULL) SWIG_fail;
8969 temp1 = true;
8970 }
8971 {
8972 if (!wxPyCheckForApp()) SWIG_fail;
8973 PyThreadState* __tstate = wxPyBeginAllowThreads();
8974 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
8975 wxPyEndAllowThreads(__tstate);
8976 if (PyErr_Occurred()) SWIG_fail;
8977 }
8978 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_NEW | 0 );
8979 {
8980 if (temp1)
8981 delete arg1;
8982 }
8983 return resultobj;
8984 fail:
8985 {
8986 if (temp1)
8987 delete arg1;
8988 }
8989 return NULL;
8990 }
8991
8992
8993 SWIGINTERN PyObject *_wrap_delete_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8994 PyObject *resultobj = 0;
8995 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
8996 void *argp1 = 0 ;
8997 int res1 = 0 ;
8998 PyObject *swig_obj[1] ;
8999
9000 if (!args) SWIG_fail;
9001 swig_obj[0] = args;
9002 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_DISOWN | 0 );
9003 if (!SWIG_IsOK(res1)) {
9004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyInfo" "', expected argument " "1"" of type '" "wxBusyInfo *""'");
9005 }
9006 arg1 = reinterpret_cast< wxBusyInfo * >(argp1);
9007 {
9008 PyThreadState* __tstate = wxPyBeginAllowThreads();
9009 delete arg1;
9010
9011 wxPyEndAllowThreads(__tstate);
9012 if (PyErr_Occurred()) SWIG_fail;
9013 }
9014 resultobj = SWIG_Py_Void();
9015 return resultobj;
9016 fail:
9017 return NULL;
9018 }
9019
9020
9021 SWIGINTERN PyObject *BusyInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9022 PyObject *obj;
9023 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9024 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyInfo, SWIG_NewClientData(obj));
9025 return SWIG_Py_Void();
9026 }
9027
9028 SWIGINTERN PyObject *BusyInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9029 return SWIG_Python_InitShadowInstance(args);
9030 }
9031
9032 SWIGINTERN PyObject *_wrap_new_StopWatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9033 PyObject *resultobj = 0;
9034 wxStopWatch *result = 0 ;
9035
9036 if (!SWIG_Python_UnpackTuple(args,"new_StopWatch",0,0,0)) SWIG_fail;
9037 {
9038 PyThreadState* __tstate = wxPyBeginAllowThreads();
9039 result = (wxStopWatch *)new wxStopWatch();
9040 wxPyEndAllowThreads(__tstate);
9041 if (PyErr_Occurred()) SWIG_fail;
9042 }
9043 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStopWatch, SWIG_POINTER_NEW | 0 );
9044 return resultobj;
9045 fail:
9046 return NULL;
9047 }
9048
9049
9050 SWIGINTERN PyObject *_wrap_StopWatch_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9051 PyObject *resultobj = 0;
9052 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9053 long arg2 = (long) 0 ;
9054 void *argp1 = 0 ;
9055 int res1 = 0 ;
9056 long val2 ;
9057 int ecode2 = 0 ;
9058 PyObject * obj0 = 0 ;
9059 PyObject * obj1 = 0 ;
9060 char * kwnames[] = {
9061 (char *) "self",(char *) "t0", NULL
9062 };
9063
9064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) SWIG_fail;
9065 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9066 if (!SWIG_IsOK(res1)) {
9067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Start" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9068 }
9069 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9070 if (obj1) {
9071 ecode2 = SWIG_AsVal_long(obj1, &val2);
9072 if (!SWIG_IsOK(ecode2)) {
9073 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StopWatch_Start" "', expected argument " "2"" of type '" "long""'");
9074 }
9075 arg2 = static_cast< long >(val2);
9076 }
9077 {
9078 PyThreadState* __tstate = wxPyBeginAllowThreads();
9079 (arg1)->Start(arg2);
9080 wxPyEndAllowThreads(__tstate);
9081 if (PyErr_Occurred()) SWIG_fail;
9082 }
9083 resultobj = SWIG_Py_Void();
9084 return resultobj;
9085 fail:
9086 return NULL;
9087 }
9088
9089
9090 SWIGINTERN PyObject *_wrap_StopWatch_Pause(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9091 PyObject *resultobj = 0;
9092 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9093 void *argp1 = 0 ;
9094 int res1 = 0 ;
9095 PyObject *swig_obj[1] ;
9096
9097 if (!args) SWIG_fail;
9098 swig_obj[0] = args;
9099 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9100 if (!SWIG_IsOK(res1)) {
9101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Pause" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9102 }
9103 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9104 {
9105 PyThreadState* __tstate = wxPyBeginAllowThreads();
9106 (arg1)->Pause();
9107 wxPyEndAllowThreads(__tstate);
9108 if (PyErr_Occurred()) SWIG_fail;
9109 }
9110 resultobj = SWIG_Py_Void();
9111 return resultobj;
9112 fail:
9113 return NULL;
9114 }
9115
9116
9117 SWIGINTERN PyObject *_wrap_StopWatch_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9118 PyObject *resultobj = 0;
9119 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9120 void *argp1 = 0 ;
9121 int res1 = 0 ;
9122 PyObject *swig_obj[1] ;
9123
9124 if (!args) SWIG_fail;
9125 swig_obj[0] = args;
9126 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9127 if (!SWIG_IsOK(res1)) {
9128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Resume" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9129 }
9130 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9131 {
9132 PyThreadState* __tstate = wxPyBeginAllowThreads();
9133 (arg1)->Resume();
9134 wxPyEndAllowThreads(__tstate);
9135 if (PyErr_Occurred()) SWIG_fail;
9136 }
9137 resultobj = SWIG_Py_Void();
9138 return resultobj;
9139 fail:
9140 return NULL;
9141 }
9142
9143
9144 SWIGINTERN PyObject *_wrap_StopWatch_Time(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9145 PyObject *resultobj = 0;
9146 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9147 long result;
9148 void *argp1 = 0 ;
9149 int res1 = 0 ;
9150 PyObject *swig_obj[1] ;
9151
9152 if (!args) SWIG_fail;
9153 swig_obj[0] = args;
9154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9155 if (!SWIG_IsOK(res1)) {
9156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Time" "', expected argument " "1"" of type '" "wxStopWatch const *""'");
9157 }
9158 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9159 {
9160 PyThreadState* __tstate = wxPyBeginAllowThreads();
9161 result = (long)((wxStopWatch const *)arg1)->Time();
9162 wxPyEndAllowThreads(__tstate);
9163 if (PyErr_Occurred()) SWIG_fail;
9164 }
9165 resultobj = SWIG_From_long(static_cast< long >(result));
9166 return resultobj;
9167 fail:
9168 return NULL;
9169 }
9170
9171
9172 SWIGINTERN PyObject *StopWatch_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9173 PyObject *obj;
9174 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9175 SWIG_TypeNewClientData(SWIGTYPE_p_wxStopWatch, SWIG_NewClientData(obj));
9176 return SWIG_Py_Void();
9177 }
9178
9179 SWIGINTERN PyObject *StopWatch_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9180 return SWIG_Python_InitShadowInstance(args);
9181 }
9182
9183 SWIGINTERN PyObject *_wrap_new_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9184 PyObject *resultobj = 0;
9185 int arg1 = (int) 9 ;
9186 int arg2 = (int) wxID_FILE1 ;
9187 wxFileHistory *result = 0 ;
9188 int val1 ;
9189 int ecode1 = 0 ;
9190 int val2 ;
9191 int ecode2 = 0 ;
9192 PyObject * obj0 = 0 ;
9193 PyObject * obj1 = 0 ;
9194 char * kwnames[] = {
9195 (char *) "maxFiles",(char *) "idBase", NULL
9196 };
9197
9198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9199 if (obj0) {
9200 ecode1 = SWIG_AsVal_int(obj0, &val1);
9201 if (!SWIG_IsOK(ecode1)) {
9202 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FileHistory" "', expected argument " "1"" of type '" "int""'");
9203 }
9204 arg1 = static_cast< int >(val1);
9205 }
9206 if (obj1) {
9207 ecode2 = SWIG_AsVal_int(obj1, &val2);
9208 if (!SWIG_IsOK(ecode2)) {
9209 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FileHistory" "', expected argument " "2"" of type '" "int""'");
9210 }
9211 arg2 = static_cast< int >(val2);
9212 }
9213 {
9214 PyThreadState* __tstate = wxPyBeginAllowThreads();
9215 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
9216 wxPyEndAllowThreads(__tstate);
9217 if (PyErr_Occurred()) SWIG_fail;
9218 }
9219 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileHistory, SWIG_POINTER_NEW | 0 );
9220 return resultobj;
9221 fail:
9222 return NULL;
9223 }
9224
9225
9226 SWIGINTERN PyObject *_wrap_delete_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9227 PyObject *resultobj = 0;
9228 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9229 void *argp1 = 0 ;
9230 int res1 = 0 ;
9231 PyObject *swig_obj[1] ;
9232
9233 if (!args) SWIG_fail;
9234 swig_obj[0] = args;
9235 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, SWIG_POINTER_DISOWN | 0 );
9236 if (!SWIG_IsOK(res1)) {
9237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9238 }
9239 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9240 {
9241 PyThreadState* __tstate = wxPyBeginAllowThreads();
9242 delete arg1;
9243
9244 wxPyEndAllowThreads(__tstate);
9245 if (PyErr_Occurred()) SWIG_fail;
9246 }
9247 resultobj = SWIG_Py_Void();
9248 return resultobj;
9249 fail:
9250 return NULL;
9251 }
9252
9253
9254 SWIGINTERN PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9255 PyObject *resultobj = 0;
9256 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9257 wxString *arg2 = 0 ;
9258 void *argp1 = 0 ;
9259 int res1 = 0 ;
9260 bool temp2 = false ;
9261 PyObject * obj0 = 0 ;
9262 PyObject * obj1 = 0 ;
9263 char * kwnames[] = {
9264 (char *) "self",(char *) "file", NULL
9265 };
9266
9267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9268 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9269 if (!SWIG_IsOK(res1)) {
9270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFileToHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9271 }
9272 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9273 {
9274 arg2 = wxString_in_helper(obj1);
9275 if (arg2 == NULL) SWIG_fail;
9276 temp2 = true;
9277 }
9278 {
9279 PyThreadState* __tstate = wxPyBeginAllowThreads();
9280 (arg1)->AddFileToHistory((wxString const &)*arg2);
9281 wxPyEndAllowThreads(__tstate);
9282 if (PyErr_Occurred()) SWIG_fail;
9283 }
9284 resultobj = SWIG_Py_Void();
9285 {
9286 if (temp2)
9287 delete arg2;
9288 }
9289 return resultobj;
9290 fail:
9291 {
9292 if (temp2)
9293 delete arg2;
9294 }
9295 return NULL;
9296 }
9297
9298
9299 SWIGINTERN PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9300 PyObject *resultobj = 0;
9301 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9302 int arg2 ;
9303 void *argp1 = 0 ;
9304 int res1 = 0 ;
9305 int val2 ;
9306 int ecode2 = 0 ;
9307 PyObject * obj0 = 0 ;
9308 PyObject * obj1 = 0 ;
9309 char * kwnames[] = {
9310 (char *) "self",(char *) "i", NULL
9311 };
9312
9313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9314 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9315 if (!SWIG_IsOK(res1)) {
9316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9317 }
9318 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9319 ecode2 = SWIG_AsVal_int(obj1, &val2);
9320 if (!SWIG_IsOK(ecode2)) {
9321 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "2"" of type '" "int""'");
9322 }
9323 arg2 = static_cast< int >(val2);
9324 {
9325 PyThreadState* __tstate = wxPyBeginAllowThreads();
9326 (arg1)->RemoveFileFromHistory(arg2);
9327 wxPyEndAllowThreads(__tstate);
9328 if (PyErr_Occurred()) SWIG_fail;
9329 }
9330 resultobj = SWIG_Py_Void();
9331 return resultobj;
9332 fail:
9333 return NULL;
9334 }
9335
9336
9337 SWIGINTERN PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9338 PyObject *resultobj = 0;
9339 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9340 int result;
9341 void *argp1 = 0 ;
9342 int res1 = 0 ;
9343 PyObject *swig_obj[1] ;
9344
9345 if (!args) SWIG_fail;
9346 swig_obj[0] = args;
9347 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9348 if (!SWIG_IsOK(res1)) {
9349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetMaxFiles" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9350 }
9351 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9352 {
9353 PyThreadState* __tstate = wxPyBeginAllowThreads();
9354 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
9355 wxPyEndAllowThreads(__tstate);
9356 if (PyErr_Occurred()) SWIG_fail;
9357 }
9358 resultobj = SWIG_From_int(static_cast< int >(result));
9359 return resultobj;
9360 fail:
9361 return NULL;
9362 }
9363
9364
9365 SWIGINTERN PyObject *_wrap_FileHistory_UseMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9366 PyObject *resultobj = 0;
9367 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9368 wxMenu *arg2 = (wxMenu *) 0 ;
9369 void *argp1 = 0 ;
9370 int res1 = 0 ;
9371 void *argp2 = 0 ;
9372 int res2 = 0 ;
9373 PyObject * obj0 = 0 ;
9374 PyObject * obj1 = 0 ;
9375 char * kwnames[] = {
9376 (char *) "self",(char *) "menu", NULL
9377 };
9378
9379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9380 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9381 if (!SWIG_IsOK(res1)) {
9382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_UseMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9383 }
9384 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9385 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9386 if (!SWIG_IsOK(res2)) {
9387 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_UseMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9388 }
9389 arg2 = reinterpret_cast< wxMenu * >(argp2);
9390 {
9391 PyThreadState* __tstate = wxPyBeginAllowThreads();
9392 (arg1)->UseMenu(arg2);
9393 wxPyEndAllowThreads(__tstate);
9394 if (PyErr_Occurred()) SWIG_fail;
9395 }
9396 resultobj = SWIG_Py_Void();
9397 return resultobj;
9398 fail:
9399 return NULL;
9400 }
9401
9402
9403 SWIGINTERN PyObject *_wrap_FileHistory_RemoveMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9404 PyObject *resultobj = 0;
9405 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9406 wxMenu *arg2 = (wxMenu *) 0 ;
9407 void *argp1 = 0 ;
9408 int res1 = 0 ;
9409 void *argp2 = 0 ;
9410 int res2 = 0 ;
9411 PyObject * obj0 = 0 ;
9412 PyObject * obj1 = 0 ;
9413 char * kwnames[] = {
9414 (char *) "self",(char *) "menu", NULL
9415 };
9416
9417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9418 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9419 if (!SWIG_IsOK(res1)) {
9420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9421 }
9422 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9423 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9424 if (!SWIG_IsOK(res2)) {
9425 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_RemoveMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9426 }
9427 arg2 = reinterpret_cast< wxMenu * >(argp2);
9428 {
9429 PyThreadState* __tstate = wxPyBeginAllowThreads();
9430 (arg1)->RemoveMenu(arg2);
9431 wxPyEndAllowThreads(__tstate);
9432 if (PyErr_Occurred()) SWIG_fail;
9433 }
9434 resultobj = SWIG_Py_Void();
9435 return resultobj;
9436 fail:
9437 return NULL;
9438 }
9439
9440
9441 SWIGINTERN PyObject *_wrap_FileHistory_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9442 PyObject *resultobj = 0;
9443 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9444 wxConfigBase *arg2 = 0 ;
9445 void *argp1 = 0 ;
9446 int res1 = 0 ;
9447 void *argp2 = 0 ;
9448 int res2 = 0 ;
9449 PyObject * obj0 = 0 ;
9450 PyObject * obj1 = 0 ;
9451 char * kwnames[] = {
9452 (char *) "self",(char *) "config", NULL
9453 };
9454
9455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) SWIG_fail;
9456 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9457 if (!SWIG_IsOK(res1)) {
9458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Load" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9459 }
9460 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9461 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9462 if (!SWIG_IsOK(res2)) {
9463 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9464 }
9465 if (!argp2) {
9466 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9467 }
9468 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9469 {
9470 PyThreadState* __tstate = wxPyBeginAllowThreads();
9471 (arg1)->Load(*arg2);
9472 wxPyEndAllowThreads(__tstate);
9473 if (PyErr_Occurred()) SWIG_fail;
9474 }
9475 resultobj = SWIG_Py_Void();
9476 return resultobj;
9477 fail:
9478 return NULL;
9479 }
9480
9481
9482 SWIGINTERN PyObject *_wrap_FileHistory_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9483 PyObject *resultobj = 0;
9484 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9485 wxConfigBase *arg2 = 0 ;
9486 void *argp1 = 0 ;
9487 int res1 = 0 ;
9488 void *argp2 = 0 ;
9489 int res2 = 0 ;
9490 PyObject * obj0 = 0 ;
9491 PyObject * obj1 = 0 ;
9492 char * kwnames[] = {
9493 (char *) "self",(char *) "config", NULL
9494 };
9495
9496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) SWIG_fail;
9497 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9498 if (!SWIG_IsOK(res1)) {
9499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Save" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9500 }
9501 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9502 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9503 if (!SWIG_IsOK(res2)) {
9504 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9505 }
9506 if (!argp2) {
9507 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9508 }
9509 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9510 {
9511 PyThreadState* __tstate = wxPyBeginAllowThreads();
9512 (arg1)->Save(*arg2);
9513 wxPyEndAllowThreads(__tstate);
9514 if (PyErr_Occurred()) SWIG_fail;
9515 }
9516 resultobj = SWIG_Py_Void();
9517 return resultobj;
9518 fail:
9519 return NULL;
9520 }
9521
9522
9523 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9524 PyObject *resultobj = 0;
9525 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9526 void *argp1 = 0 ;
9527 int res1 = 0 ;
9528 PyObject *swig_obj[1] ;
9529
9530 if (!args) SWIG_fail;
9531 swig_obj[0] = args;
9532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9533 if (!SWIG_IsOK(res1)) {
9534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9535 }
9536 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9537 {
9538 PyThreadState* __tstate = wxPyBeginAllowThreads();
9539 (arg1)->AddFilesToMenu();
9540 wxPyEndAllowThreads(__tstate);
9541 if (PyErr_Occurred()) SWIG_fail;
9542 }
9543 resultobj = SWIG_Py_Void();
9544 return resultobj;
9545 fail:
9546 return NULL;
9547 }
9548
9549
9550 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9551 PyObject *resultobj = 0;
9552 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9553 wxMenu *arg2 = (wxMenu *) 0 ;
9554 void *argp1 = 0 ;
9555 int res1 = 0 ;
9556 void *argp2 = 0 ;
9557 int res2 = 0 ;
9558 PyObject * obj0 = 0 ;
9559 PyObject * obj1 = 0 ;
9560 char * kwnames[] = {
9561 (char *) "self",(char *) "menu", NULL
9562 };
9563
9564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9565 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9566 if (!SWIG_IsOK(res1)) {
9567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9568 }
9569 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9570 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9571 if (!SWIG_IsOK(res2)) {
9572 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9573 }
9574 arg2 = reinterpret_cast< wxMenu * >(argp2);
9575 {
9576 PyThreadState* __tstate = wxPyBeginAllowThreads();
9577 (arg1)->AddFilesToMenu(arg2);
9578 wxPyEndAllowThreads(__tstate);
9579 if (PyErr_Occurred()) SWIG_fail;
9580 }
9581 resultobj = SWIG_Py_Void();
9582 return resultobj;
9583 fail:
9584 return NULL;
9585 }
9586
9587
9588 SWIGINTERN PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9589 PyObject *resultobj = 0;
9590 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9591 int arg2 ;
9592 wxString result;
9593 void *argp1 = 0 ;
9594 int res1 = 0 ;
9595 int val2 ;
9596 int ecode2 = 0 ;
9597 PyObject * obj0 = 0 ;
9598 PyObject * obj1 = 0 ;
9599 char * kwnames[] = {
9600 (char *) "self",(char *) "i", NULL
9601 };
9602
9603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) SWIG_fail;
9604 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9605 if (!SWIG_IsOK(res1)) {
9606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9607 }
9608 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9609 ecode2 = SWIG_AsVal_int(obj1, &val2);
9610 if (!SWIG_IsOK(ecode2)) {
9611 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "2"" of type '" "int""'");
9612 }
9613 arg2 = static_cast< int >(val2);
9614 {
9615 PyThreadState* __tstate = wxPyBeginAllowThreads();
9616 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
9617 wxPyEndAllowThreads(__tstate);
9618 if (PyErr_Occurred()) SWIG_fail;
9619 }
9620 {
9621 #if wxUSE_UNICODE
9622 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9623 #else
9624 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9625 #endif
9626 }
9627 return resultobj;
9628 fail:
9629 return NULL;
9630 }
9631
9632
9633 SWIGINTERN PyObject *_wrap_FileHistory_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9634 PyObject *resultobj = 0;
9635 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9636 int result;
9637 void *argp1 = 0 ;
9638 int res1 = 0 ;
9639 PyObject *swig_obj[1] ;
9640
9641 if (!args) SWIG_fail;
9642 swig_obj[0] = args;
9643 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9644 if (!SWIG_IsOK(res1)) {
9645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetCount" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9646 }
9647 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9648 {
9649 PyThreadState* __tstate = wxPyBeginAllowThreads();
9650 result = (int)((wxFileHistory const *)arg1)->GetCount();
9651 wxPyEndAllowThreads(__tstate);
9652 if (PyErr_Occurred()) SWIG_fail;
9653 }
9654 resultobj = SWIG_From_int(static_cast< int >(result));
9655 return resultobj;
9656 fail:
9657 return NULL;
9658 }
9659
9660
9661 SWIGINTERN PyObject *FileHistory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9662 PyObject *obj;
9663 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9664 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileHistory, SWIG_NewClientData(obj));
9665 return SWIG_Py_Void();
9666 }
9667
9668 SWIGINTERN PyObject *FileHistory_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9669 return SWIG_Python_InitShadowInstance(args);
9670 }
9671
9672 SWIGINTERN PyObject *_wrap_new_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9673 PyObject *resultobj = 0;
9674 wxString *arg1 = 0 ;
9675 wxString const &arg2_defvalue = wxPyEmptyString ;
9676 wxString *arg2 = (wxString *) &arg2_defvalue ;
9677 wxSingleInstanceChecker *result = 0 ;
9678 bool temp1 = false ;
9679 bool temp2 = false ;
9680 PyObject * obj0 = 0 ;
9681 PyObject * obj1 = 0 ;
9682 char * kwnames[] = {
9683 (char *) "name",(char *) "path", NULL
9684 };
9685
9686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) SWIG_fail;
9687 {
9688 arg1 = wxString_in_helper(obj0);
9689 if (arg1 == NULL) SWIG_fail;
9690 temp1 = true;
9691 }
9692 if (obj1) {
9693 {
9694 arg2 = wxString_in_helper(obj1);
9695 if (arg2 == NULL) SWIG_fail;
9696 temp2 = true;
9697 }
9698 }
9699 {
9700 PyThreadState* __tstate = wxPyBeginAllowThreads();
9701 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
9702 wxPyEndAllowThreads(__tstate);
9703 if (PyErr_Occurred()) SWIG_fail;
9704 }
9705 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_NEW | 0 );
9706 {
9707 if (temp1)
9708 delete arg1;
9709 }
9710 {
9711 if (temp2)
9712 delete arg2;
9713 }
9714 return resultobj;
9715 fail:
9716 {
9717 if (temp1)
9718 delete arg1;
9719 }
9720 {
9721 if (temp2)
9722 delete arg2;
9723 }
9724 return NULL;
9725 }
9726
9727
9728 SWIGINTERN PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9729 PyObject *resultobj = 0;
9730 wxSingleInstanceChecker *result = 0 ;
9731
9732 if (!SWIG_Python_UnpackTuple(args,"new_PreSingleInstanceChecker",0,0,0)) SWIG_fail;
9733 {
9734 PyThreadState* __tstate = wxPyBeginAllowThreads();
9735 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
9736 wxPyEndAllowThreads(__tstate);
9737 if (PyErr_Occurred()) SWIG_fail;
9738 }
9739 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_OWN | 0 );
9740 return resultobj;
9741 fail:
9742 return NULL;
9743 }
9744
9745
9746 SWIGINTERN PyObject *_wrap_delete_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9747 PyObject *resultobj = 0;
9748 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
9749 void *argp1 = 0 ;
9750 int res1 = 0 ;
9751 PyObject *swig_obj[1] ;
9752
9753 if (!args) SWIG_fail;
9754 swig_obj[0] = args;
9755 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_DISOWN | 0 );
9756 if (!SWIG_IsOK(res1)) {
9757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SingleInstanceChecker" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
9758 }
9759 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
9760 {
9761 PyThreadState* __tstate = wxPyBeginAllowThreads();
9762 delete arg1;
9763
9764 wxPyEndAllowThreads(__tstate);
9765 if (PyErr_Occurred()) SWIG_fail;
9766 }
9767 resultobj = SWIG_Py_Void();
9768 return resultobj;
9769 fail:
9770 return NULL;
9771 }
9772
9773
9774 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9775 PyObject *resultobj = 0;
9776 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
9777 wxString *arg2 = 0 ;
9778 wxString const &arg3_defvalue = wxPyEmptyString ;
9779 wxString *arg3 = (wxString *) &arg3_defvalue ;
9780 bool result;
9781 void *argp1 = 0 ;
9782 int res1 = 0 ;
9783 bool temp2 = false ;
9784 bool temp3 = false ;
9785 PyObject * obj0 = 0 ;
9786 PyObject * obj1 = 0 ;
9787 PyObject * obj2 = 0 ;
9788 char * kwnames[] = {
9789 (char *) "self",(char *) "name",(char *) "path", NULL
9790 };
9791
9792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9793 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
9794 if (!SWIG_IsOK(res1)) {
9795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_Create" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
9796 }
9797 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
9798 {
9799 arg2 = wxString_in_helper(obj1);
9800 if (arg2 == NULL) SWIG_fail;
9801 temp2 = true;
9802 }
9803 if (obj2) {
9804 {
9805 arg3 = wxString_in_helper(obj2);
9806 if (arg3 == NULL) SWIG_fail;
9807 temp3 = true;
9808 }
9809 }
9810 {
9811 PyThreadState* __tstate = wxPyBeginAllowThreads();
9812 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
9813 wxPyEndAllowThreads(__tstate);
9814 if (PyErr_Occurred()) SWIG_fail;
9815 }
9816 {
9817 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9818 }
9819 {
9820 if (temp2)
9821 delete arg2;
9822 }
9823 {
9824 if (temp3)
9825 delete arg3;
9826 }
9827 return resultobj;
9828 fail:
9829 {
9830 if (temp2)
9831 delete arg2;
9832 }
9833 {
9834 if (temp3)
9835 delete arg3;
9836 }
9837 return NULL;
9838 }
9839
9840
9841 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9842 PyObject *resultobj = 0;
9843 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
9844 bool result;
9845 void *argp1 = 0 ;
9846 int res1 = 0 ;
9847 PyObject *swig_obj[1] ;
9848
9849 if (!args) SWIG_fail;
9850 swig_obj[0] = args;
9851 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
9852 if (!SWIG_IsOK(res1)) {
9853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_IsAnotherRunning" "', expected argument " "1"" of type '" "wxSingleInstanceChecker const *""'");
9854 }
9855 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
9856 {
9857 PyThreadState* __tstate = wxPyBeginAllowThreads();
9858 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
9859 wxPyEndAllowThreads(__tstate);
9860 if (PyErr_Occurred()) SWIG_fail;
9861 }
9862 {
9863 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9864 }
9865 return resultobj;
9866 fail:
9867 return NULL;
9868 }
9869
9870
9871 SWIGINTERN PyObject *SingleInstanceChecker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9872 PyObject *obj;
9873 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9874 SWIG_TypeNewClientData(SWIGTYPE_p_wxSingleInstanceChecker, SWIG_NewClientData(obj));
9875 return SWIG_Py_Void();
9876 }
9877
9878 SWIGINTERN PyObject *SingleInstanceChecker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9879 return SWIG_Python_InitShadowInstance(args);
9880 }
9881
9882 SWIGINTERN PyObject *_wrap_DrawWindowOnDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9883 PyObject *resultobj = 0;
9884 wxWindow *arg1 = (wxWindow *) 0 ;
9885 wxDC *arg2 = 0 ;
9886 bool result;
9887 void *argp1 = 0 ;
9888 int res1 = 0 ;
9889 void *argp2 = 0 ;
9890 int res2 = 0 ;
9891 PyObject * obj0 = 0 ;
9892 PyObject * obj1 = 0 ;
9893 char * kwnames[] = {
9894 (char *) "window",(char *) "dc", NULL
9895 };
9896
9897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DrawWindowOnDC",kwnames,&obj0,&obj1)) SWIG_fail;
9898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
9899 if (!SWIG_IsOK(res1)) {
9900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DrawWindowOnDC" "', expected argument " "1"" of type '" "wxWindow *""'");
9901 }
9902 arg1 = reinterpret_cast< wxWindow * >(argp1);
9903 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
9904 if (!SWIG_IsOK(res2)) {
9905 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
9906 }
9907 if (!argp2) {
9908 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
9909 }
9910 arg2 = reinterpret_cast< wxDC * >(argp2);
9911 {
9912 PyThreadState* __tstate = wxPyBeginAllowThreads();
9913 result = (bool)wxDrawWindowOnDC(arg1,(wxDC const &)*arg2);
9914 wxPyEndAllowThreads(__tstate);
9915 if (PyErr_Occurred()) SWIG_fail;
9916 }
9917 {
9918 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9919 }
9920 return resultobj;
9921 fail:
9922 return NULL;
9923 }
9924
9925
9926 SWIGINTERN PyObject *_wrap_delete_TipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9927 PyObject *resultobj = 0;
9928 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
9929 void *argp1 = 0 ;
9930 int res1 = 0 ;
9931 PyObject *swig_obj[1] ;
9932
9933 if (!args) SWIG_fail;
9934 swig_obj[0] = args;
9935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, SWIG_POINTER_DISOWN | 0 );
9936 if (!SWIG_IsOK(res1)) {
9937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TipProvider" "', expected argument " "1"" of type '" "wxTipProvider *""'");
9938 }
9939 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
9940 {
9941 PyThreadState* __tstate = wxPyBeginAllowThreads();
9942 delete arg1;
9943
9944 wxPyEndAllowThreads(__tstate);
9945 if (PyErr_Occurred()) SWIG_fail;
9946 }
9947 resultobj = SWIG_Py_Void();
9948 return resultobj;
9949 fail:
9950 return NULL;
9951 }
9952
9953
9954 SWIGINTERN PyObject *_wrap_TipProvider_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9955 PyObject *resultobj = 0;
9956 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
9957 wxString result;
9958 void *argp1 = 0 ;
9959 int res1 = 0 ;
9960 PyObject *swig_obj[1] ;
9961
9962 if (!args) SWIG_fail;
9963 swig_obj[0] = args;
9964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
9965 if (!SWIG_IsOK(res1)) {
9966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
9967 }
9968 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
9969 {
9970 PyThreadState* __tstate = wxPyBeginAllowThreads();
9971 result = (arg1)->GetTip();
9972 wxPyEndAllowThreads(__tstate);
9973 if (PyErr_Occurred()) SWIG_fail;
9974 }
9975 {
9976 #if wxUSE_UNICODE
9977 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9978 #else
9979 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9980 #endif
9981 }
9982 return resultobj;
9983 fail:
9984 return NULL;
9985 }
9986
9987
9988 SWIGINTERN PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9989 PyObject *resultobj = 0;
9990 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
9991 size_t result;
9992 void *argp1 = 0 ;
9993 int res1 = 0 ;
9994 PyObject *swig_obj[1] ;
9995
9996 if (!args) SWIG_fail;
9997 swig_obj[0] = args;
9998 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
9999 if (!SWIG_IsOK(res1)) {
10000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetCurrentTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
10001 }
10002 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
10003 {
10004 PyThreadState* __tstate = wxPyBeginAllowThreads();
10005 result = (size_t)(arg1)->GetCurrentTip();
10006 wxPyEndAllowThreads(__tstate);
10007 if (PyErr_Occurred()) SWIG_fail;
10008 }
10009 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
10010 return resultobj;
10011 fail:
10012 return NULL;
10013 }
10014
10015
10016 SWIGINTERN PyObject *_wrap_TipProvider_PreprocessTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10017 PyObject *resultobj = 0;
10018 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
10019 wxString *arg2 = 0 ;
10020 wxString result;
10021 void *argp1 = 0 ;
10022 int res1 = 0 ;
10023 bool temp2 = false ;
10024 PyObject * obj0 = 0 ;
10025 PyObject * obj1 = 0 ;
10026 char * kwnames[] = {
10027 (char *) "self",(char *) "tip", NULL
10028 };
10029
10030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) SWIG_fail;
10031 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
10032 if (!SWIG_IsOK(res1)) {
10033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_PreprocessTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
10034 }
10035 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
10036 {
10037 arg2 = wxString_in_helper(obj1);
10038 if (arg2 == NULL) SWIG_fail;
10039 temp2 = true;
10040 }
10041 {
10042 PyThreadState* __tstate = wxPyBeginAllowThreads();
10043 result = (arg1)->PreprocessTip((wxString const &)*arg2);
10044 wxPyEndAllowThreads(__tstate);
10045 if (PyErr_Occurred()) SWIG_fail;
10046 }
10047 {
10048 #if wxUSE_UNICODE
10049 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10050 #else
10051 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10052 #endif
10053 }
10054 {
10055 if (temp2)
10056 delete arg2;
10057 }
10058 return resultobj;
10059 fail:
10060 {
10061 if (temp2)
10062 delete arg2;
10063 }
10064 return NULL;
10065 }
10066
10067
10068 SWIGINTERN PyObject *TipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10069 PyObject *obj;
10070 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10071 SWIG_TypeNewClientData(SWIGTYPE_p_wxTipProvider, SWIG_NewClientData(obj));
10072 return SWIG_Py_Void();
10073 }
10074
10075 SWIGINTERN PyObject *_wrap_new_PyTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10076 PyObject *resultobj = 0;
10077 size_t arg1 ;
10078 wxPyTipProvider *result = 0 ;
10079 size_t val1 ;
10080 int ecode1 = 0 ;
10081 PyObject * obj0 = 0 ;
10082 char * kwnames[] = {
10083 (char *) "currentTip", NULL
10084 };
10085
10086 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) SWIG_fail;
10087 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
10088 if (!SWIG_IsOK(ecode1)) {
10089 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyTipProvider" "', expected argument " "1"" of type '" "size_t""'");
10090 }
10091 arg1 = static_cast< size_t >(val1);
10092 {
10093 PyThreadState* __tstate = wxPyBeginAllowThreads();
10094 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
10095 wxPyEndAllowThreads(__tstate);
10096 if (PyErr_Occurred()) SWIG_fail;
10097 }
10098 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_NEW | 0 );
10099 return resultobj;
10100 fail:
10101 return NULL;
10102 }
10103
10104
10105 SWIGINTERN PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10106 PyObject *resultobj = 0;
10107 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
10108 PyObject *arg2 = (PyObject *) 0 ;
10109 PyObject *arg3 = (PyObject *) 0 ;
10110 void *argp1 = 0 ;
10111 int res1 = 0 ;
10112 PyObject * obj0 = 0 ;
10113 PyObject * obj1 = 0 ;
10114 PyObject * obj2 = 0 ;
10115 char * kwnames[] = {
10116 (char *) "self",(char *) "self",(char *) "_class", NULL
10117 };
10118
10119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10120 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTipProvider, 0 | 0 );
10121 if (!SWIG_IsOK(res1)) {
10122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTipProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTipProvider *""'");
10123 }
10124 arg1 = reinterpret_cast< wxPyTipProvider * >(argp1);
10125 arg2 = obj1;
10126 arg3 = obj2;
10127 {
10128 PyThreadState* __tstate = wxPyBeginAllowThreads();
10129 (arg1)->_setCallbackInfo(arg2,arg3);
10130 wxPyEndAllowThreads(__tstate);
10131 if (PyErr_Occurred()) SWIG_fail;
10132 }
10133 resultobj = SWIG_Py_Void();
10134 return resultobj;
10135 fail:
10136 return NULL;
10137 }
10138
10139
10140 SWIGINTERN PyObject *PyTipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10141 PyObject *obj;
10142 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10143 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTipProvider, SWIG_NewClientData(obj));
10144 return SWIG_Py_Void();
10145 }
10146
10147 SWIGINTERN PyObject *PyTipProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10148 return SWIG_Python_InitShadowInstance(args);
10149 }
10150
10151 SWIGINTERN PyObject *_wrap_ShowTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10152 PyObject *resultobj = 0;
10153 wxWindow *arg1 = (wxWindow *) 0 ;
10154 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
10155 bool arg3 = (bool) true ;
10156 bool result;
10157 void *argp1 = 0 ;
10158 int res1 = 0 ;
10159 void *argp2 = 0 ;
10160 int res2 = 0 ;
10161 bool val3 ;
10162 int ecode3 = 0 ;
10163 PyObject * obj0 = 0 ;
10164 PyObject * obj1 = 0 ;
10165 PyObject * obj2 = 0 ;
10166 char * kwnames[] = {
10167 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
10168 };
10169
10170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10171 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
10172 if (!SWIG_IsOK(res1)) {
10173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowTip" "', expected argument " "1"" of type '" "wxWindow *""'");
10174 }
10175 arg1 = reinterpret_cast< wxWindow * >(argp1);
10176 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTipProvider, 0 | 0 );
10177 if (!SWIG_IsOK(res2)) {
10178 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShowTip" "', expected argument " "2"" of type '" "wxTipProvider *""'");
10179 }
10180 arg2 = reinterpret_cast< wxTipProvider * >(argp2);
10181 if (obj2) {
10182 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10183 if (!SWIG_IsOK(ecode3)) {
10184 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ShowTip" "', expected argument " "3"" of type '" "bool""'");
10185 }
10186 arg3 = static_cast< bool >(val3);
10187 }
10188 {
10189 if (!wxPyCheckForApp()) SWIG_fail;
10190 PyThreadState* __tstate = wxPyBeginAllowThreads();
10191 result = (bool)wxShowTip(arg1,arg2,arg3);
10192 wxPyEndAllowThreads(__tstate);
10193 if (PyErr_Occurred()) SWIG_fail;
10194 }
10195 {
10196 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10197 }
10198 return resultobj;
10199 fail:
10200 return NULL;
10201 }
10202
10203
10204 SWIGINTERN PyObject *_wrap_CreateFileTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10205 PyObject *resultobj = 0;
10206 wxString *arg1 = 0 ;
10207 size_t arg2 ;
10208 wxTipProvider *result = 0 ;
10209 bool temp1 = false ;
10210 size_t val2 ;
10211 int ecode2 = 0 ;
10212 PyObject * obj0 = 0 ;
10213 PyObject * obj1 = 0 ;
10214 char * kwnames[] = {
10215 (char *) "filename",(char *) "currentTip", NULL
10216 };
10217
10218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) SWIG_fail;
10219 {
10220 arg1 = wxString_in_helper(obj0);
10221 if (arg1 == NULL) SWIG_fail;
10222 temp1 = true;
10223 }
10224 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
10225 if (!SWIG_IsOK(ecode2)) {
10226 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CreateFileTipProvider" "', expected argument " "2"" of type '" "size_t""'");
10227 }
10228 arg2 = static_cast< size_t >(val2);
10229 {
10230 if (!wxPyCheckForApp()) SWIG_fail;
10231 PyThreadState* __tstate = wxPyBeginAllowThreads();
10232 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
10233 wxPyEndAllowThreads(__tstate);
10234 if (PyErr_Occurred()) SWIG_fail;
10235 }
10236 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTipProvider, SWIG_POINTER_OWN | 0 );
10237 {
10238 if (temp1)
10239 delete arg1;
10240 }
10241 return resultobj;
10242 fail:
10243 {
10244 if (temp1)
10245 delete arg1;
10246 }
10247 return NULL;
10248 }
10249
10250
10251 SWIGINTERN PyObject *_wrap_new_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10252 PyObject *resultobj = 0;
10253 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
10254 int arg2 = (int) wxID_ANY ;
10255 wxPyTimer *result = 0 ;
10256 void *argp1 = 0 ;
10257 int res1 = 0 ;
10258 int val2 ;
10259 int ecode2 = 0 ;
10260 PyObject * obj0 = 0 ;
10261 PyObject * obj1 = 0 ;
10262 char * kwnames[] = {
10263 (char *) "owner",(char *) "id", NULL
10264 };
10265
10266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) SWIG_fail;
10267 if (obj0) {
10268 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
10269 if (!SWIG_IsOK(res1)) {
10270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Timer" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
10271 }
10272 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
10273 }
10274 if (obj1) {
10275 ecode2 = SWIG_AsVal_int(obj1, &val2);
10276 if (!SWIG_IsOK(ecode2)) {
10277 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Timer" "', expected argument " "2"" of type '" "int""'");
10278 }
10279 arg2 = static_cast< int >(val2);
10280 }
10281 {
10282 if (!wxPyCheckForApp()) SWIG_fail;
10283 PyThreadState* __tstate = wxPyBeginAllowThreads();
10284 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
10285 wxPyEndAllowThreads(__tstate);
10286 if (PyErr_Occurred()) SWIG_fail;
10287 }
10288 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTimer, SWIG_POINTER_NEW | 0 );
10289 return resultobj;
10290 fail:
10291 return NULL;
10292 }
10293
10294
10295 SWIGINTERN PyObject *_wrap_delete_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10296 PyObject *resultobj = 0;
10297 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10298 void *argp1 = 0 ;
10299 int res1 = 0 ;
10300 PyObject *swig_obj[1] ;
10301
10302 if (!args) SWIG_fail;
10303 swig_obj[0] = args;
10304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, SWIG_POINTER_DISOWN | 0 );
10305 if (!SWIG_IsOK(res1)) {
10306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Timer" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10307 }
10308 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10309 {
10310 PyThreadState* __tstate = wxPyBeginAllowThreads();
10311 delete arg1;
10312
10313 wxPyEndAllowThreads(__tstate);
10314 if (PyErr_Occurred()) SWIG_fail;
10315 }
10316 resultobj = SWIG_Py_Void();
10317 return resultobj;
10318 fail:
10319 return NULL;
10320 }
10321
10322
10323 SWIGINTERN PyObject *_wrap_Timer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10324 PyObject *resultobj = 0;
10325 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10326 PyObject *arg2 = (PyObject *) 0 ;
10327 PyObject *arg3 = (PyObject *) 0 ;
10328 int arg4 = (int) 1 ;
10329 void *argp1 = 0 ;
10330 int res1 = 0 ;
10331 int val4 ;
10332 int ecode4 = 0 ;
10333 PyObject * obj0 = 0 ;
10334 PyObject * obj1 = 0 ;
10335 PyObject * obj2 = 0 ;
10336 PyObject * obj3 = 0 ;
10337 char * kwnames[] = {
10338 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
10339 };
10340
10341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10342 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10343 if (!SWIG_IsOK(res1)) {
10344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10345 }
10346 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10347 arg2 = obj1;
10348 arg3 = obj2;
10349 if (obj3) {
10350 ecode4 = SWIG_AsVal_int(obj3, &val4);
10351 if (!SWIG_IsOK(ecode4)) {
10352 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Timer__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
10353 }
10354 arg4 = static_cast< int >(val4);
10355 }
10356 {
10357 PyThreadState* __tstate = wxPyBeginAllowThreads();
10358 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
10359 wxPyEndAllowThreads(__tstate);
10360 if (PyErr_Occurred()) SWIG_fail;
10361 }
10362 resultobj = SWIG_Py_Void();
10363 return resultobj;
10364 fail:
10365 return NULL;
10366 }
10367
10368
10369 SWIGINTERN PyObject *_wrap_Timer_SetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10370 PyObject *resultobj = 0;
10371 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10372 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
10373 int arg3 = (int) wxID_ANY ;
10374 void *argp1 = 0 ;
10375 int res1 = 0 ;
10376 void *argp2 = 0 ;
10377 int res2 = 0 ;
10378 int val3 ;
10379 int ecode3 = 0 ;
10380 PyObject * obj0 = 0 ;
10381 PyObject * obj1 = 0 ;
10382 PyObject * obj2 = 0 ;
10383 char * kwnames[] = {
10384 (char *) "self",(char *) "owner",(char *) "id", NULL
10385 };
10386
10387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10389 if (!SWIG_IsOK(res1)) {
10390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_SetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10391 }
10392 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10393 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
10394 if (!SWIG_IsOK(res2)) {
10395 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Timer_SetOwner" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
10396 }
10397 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
10398 if (obj2) {
10399 ecode3 = SWIG_AsVal_int(obj2, &val3);
10400 if (!SWIG_IsOK(ecode3)) {
10401 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_SetOwner" "', expected argument " "3"" of type '" "int""'");
10402 }
10403 arg3 = static_cast< int >(val3);
10404 }
10405 {
10406 PyThreadState* __tstate = wxPyBeginAllowThreads();
10407 (arg1)->SetOwner(arg2,arg3);
10408 wxPyEndAllowThreads(__tstate);
10409 if (PyErr_Occurred()) SWIG_fail;
10410 }
10411 resultobj = SWIG_Py_Void();
10412 return resultobj;
10413 fail:
10414 return NULL;
10415 }
10416
10417
10418 SWIGINTERN PyObject *_wrap_Timer_GetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10419 PyObject *resultobj = 0;
10420 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10421 wxEvtHandler *result = 0 ;
10422 void *argp1 = 0 ;
10423 int res1 = 0 ;
10424 PyObject *swig_obj[1] ;
10425
10426 if (!args) SWIG_fail;
10427 swig_obj[0] = args;
10428 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10429 if (!SWIG_IsOK(res1)) {
10430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10431 }
10432 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10433 {
10434 PyThreadState* __tstate = wxPyBeginAllowThreads();
10435 result = (wxEvtHandler *)(arg1)->GetOwner();
10436 wxPyEndAllowThreads(__tstate);
10437 if (PyErr_Occurred()) SWIG_fail;
10438 }
10439 {
10440 resultobj = wxPyMake_wxObject(result, 0);
10441 }
10442 return resultobj;
10443 fail:
10444 return NULL;
10445 }
10446
10447
10448 SWIGINTERN PyObject *_wrap_Timer_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10449 PyObject *resultobj = 0;
10450 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10451 int arg2 = (int) -1 ;
10452 bool arg3 = (bool) false ;
10453 bool result;
10454 void *argp1 = 0 ;
10455 int res1 = 0 ;
10456 int val2 ;
10457 int ecode2 = 0 ;
10458 bool val3 ;
10459 int ecode3 = 0 ;
10460 PyObject * obj0 = 0 ;
10461 PyObject * obj1 = 0 ;
10462 PyObject * obj2 = 0 ;
10463 char * kwnames[] = {
10464 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
10465 };
10466
10467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10468 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10469 if (!SWIG_IsOK(res1)) {
10470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Start" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10471 }
10472 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10473 if (obj1) {
10474 ecode2 = SWIG_AsVal_int(obj1, &val2);
10475 if (!SWIG_IsOK(ecode2)) {
10476 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Timer_Start" "', expected argument " "2"" of type '" "int""'");
10477 }
10478 arg2 = static_cast< int >(val2);
10479 }
10480 if (obj2) {
10481 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10482 if (!SWIG_IsOK(ecode3)) {
10483 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_Start" "', expected argument " "3"" of type '" "bool""'");
10484 }
10485 arg3 = static_cast< bool >(val3);
10486 }
10487 {
10488 PyThreadState* __tstate = wxPyBeginAllowThreads();
10489 result = (bool)(arg1)->Start(arg2,arg3);
10490 wxPyEndAllowThreads(__tstate);
10491 if (PyErr_Occurred()) SWIG_fail;
10492 }
10493 {
10494 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10495 }
10496 return resultobj;
10497 fail:
10498 return NULL;
10499 }
10500
10501
10502 SWIGINTERN PyObject *_wrap_Timer_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10503 PyObject *resultobj = 0;
10504 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10505 void *argp1 = 0 ;
10506 int res1 = 0 ;
10507 PyObject *swig_obj[1] ;
10508
10509 if (!args) SWIG_fail;
10510 swig_obj[0] = args;
10511 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10512 if (!SWIG_IsOK(res1)) {
10513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Stop" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10514 }
10515 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10516 {
10517 PyThreadState* __tstate = wxPyBeginAllowThreads();
10518 (arg1)->Stop();
10519 wxPyEndAllowThreads(__tstate);
10520 if (PyErr_Occurred()) SWIG_fail;
10521 }
10522 resultobj = SWIG_Py_Void();
10523 return resultobj;
10524 fail:
10525 return NULL;
10526 }
10527
10528
10529 SWIGINTERN PyObject *_wrap_Timer_Notify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10530 PyObject *resultobj = 0;
10531 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10532 void *argp1 = 0 ;
10533 int res1 = 0 ;
10534 PyObject *swig_obj[1] ;
10535
10536 if (!args) SWIG_fail;
10537 swig_obj[0] = args;
10538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10539 if (!SWIG_IsOK(res1)) {
10540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Notify" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10541 }
10542 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10543 {
10544 PyThreadState* __tstate = wxPyBeginAllowThreads();
10545 (arg1)->Notify();
10546 wxPyEndAllowThreads(__tstate);
10547 if (PyErr_Occurred()) SWIG_fail;
10548 }
10549 resultobj = SWIG_Py_Void();
10550 return resultobj;
10551 fail:
10552 return NULL;
10553 }
10554
10555
10556 SWIGINTERN PyObject *_wrap_Timer_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10557 PyObject *resultobj = 0;
10558 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10559 bool result;
10560 void *argp1 = 0 ;
10561 int res1 = 0 ;
10562 PyObject *swig_obj[1] ;
10563
10564 if (!args) SWIG_fail;
10565 swig_obj[0] = args;
10566 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10567 if (!SWIG_IsOK(res1)) {
10568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsRunning" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
10569 }
10570 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10571 {
10572 PyThreadState* __tstate = wxPyBeginAllowThreads();
10573 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
10574 wxPyEndAllowThreads(__tstate);
10575 if (PyErr_Occurred()) SWIG_fail;
10576 }
10577 {
10578 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10579 }
10580 return resultobj;
10581 fail:
10582 return NULL;
10583 }
10584
10585
10586 SWIGINTERN PyObject *_wrap_Timer_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10587 PyObject *resultobj = 0;
10588 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10589 int result;
10590 void *argp1 = 0 ;
10591 int res1 = 0 ;
10592 PyObject *swig_obj[1] ;
10593
10594 if (!args) SWIG_fail;
10595 swig_obj[0] = args;
10596 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10597 if (!SWIG_IsOK(res1)) {
10598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetInterval" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
10599 }
10600 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10601 {
10602 PyThreadState* __tstate = wxPyBeginAllowThreads();
10603 result = (int)((wxPyTimer const *)arg1)->GetInterval();
10604 wxPyEndAllowThreads(__tstate);
10605 if (PyErr_Occurred()) SWIG_fail;
10606 }
10607 resultobj = SWIG_From_int(static_cast< int >(result));
10608 return resultobj;
10609 fail:
10610 return NULL;
10611 }
10612
10613
10614 SWIGINTERN PyObject *_wrap_Timer_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10615 PyObject *resultobj = 0;
10616 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10617 int result;
10618 void *argp1 = 0 ;
10619 int res1 = 0 ;
10620 PyObject *swig_obj[1] ;
10621
10622 if (!args) SWIG_fail;
10623 swig_obj[0] = args;
10624 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10625 if (!SWIG_IsOK(res1)) {
10626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetId" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
10627 }
10628 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10629 {
10630 PyThreadState* __tstate = wxPyBeginAllowThreads();
10631 result = (int)((wxPyTimer const *)arg1)->GetId();
10632 wxPyEndAllowThreads(__tstate);
10633 if (PyErr_Occurred()) SWIG_fail;
10634 }
10635 resultobj = SWIG_From_int(static_cast< int >(result));
10636 return resultobj;
10637 fail:
10638 return NULL;
10639 }
10640
10641
10642 SWIGINTERN PyObject *_wrap_Timer_IsOneShot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10643 PyObject *resultobj = 0;
10644 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10645 bool result;
10646 void *argp1 = 0 ;
10647 int res1 = 0 ;
10648 PyObject *swig_obj[1] ;
10649
10650 if (!args) SWIG_fail;
10651 swig_obj[0] = args;
10652 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10653 if (!SWIG_IsOK(res1)) {
10654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsOneShot" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
10655 }
10656 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10657 {
10658 PyThreadState* __tstate = wxPyBeginAllowThreads();
10659 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
10660 wxPyEndAllowThreads(__tstate);
10661 if (PyErr_Occurred()) SWIG_fail;
10662 }
10663 {
10664 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10665 }
10666 return resultobj;
10667 fail:
10668 return NULL;
10669 }
10670
10671
10672 SWIGINTERN PyObject *Timer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10673 PyObject *obj;
10674 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10675 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTimer, SWIG_NewClientData(obj));
10676 return SWIG_Py_Void();
10677 }
10678
10679 SWIGINTERN PyObject *Timer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10680 return SWIG_Python_InitShadowInstance(args);
10681 }
10682
10683 SWIGINTERN PyObject *_wrap_new_TimerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10684 PyObject *resultobj = 0;
10685 int arg1 = (int) 0 ;
10686 int arg2 = (int) 0 ;
10687 wxTimerEvent *result = 0 ;
10688 int val1 ;
10689 int ecode1 = 0 ;
10690 int val2 ;
10691 int ecode2 = 0 ;
10692 PyObject * obj0 = 0 ;
10693 PyObject * obj1 = 0 ;
10694 char * kwnames[] = {
10695 (char *) "timerid",(char *) "interval", NULL
10696 };
10697
10698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) SWIG_fail;
10699 if (obj0) {
10700 ecode1 = SWIG_AsVal_int(obj0, &val1);
10701 if (!SWIG_IsOK(ecode1)) {
10702 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimerEvent" "', expected argument " "1"" of type '" "int""'");
10703 }
10704 arg1 = static_cast< int >(val1);
10705 }
10706 if (obj1) {
10707 ecode2 = SWIG_AsVal_int(obj1, &val2);
10708 if (!SWIG_IsOK(ecode2)) {
10709 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerEvent" "', expected argument " "2"" of type '" "int""'");
10710 }
10711 arg2 = static_cast< int >(val2);
10712 }
10713 {
10714 PyThreadState* __tstate = wxPyBeginAllowThreads();
10715 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
10716 wxPyEndAllowThreads(__tstate);
10717 if (PyErr_Occurred()) SWIG_fail;
10718 }
10719 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_NEW | 0 );
10720 return resultobj;
10721 fail:
10722 return NULL;
10723 }
10724
10725
10726 SWIGINTERN PyObject *_wrap_TimerEvent_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10727 PyObject *resultobj = 0;
10728 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
10729 int result;
10730 void *argp1 = 0 ;
10731 int res1 = 0 ;
10732 PyObject *swig_obj[1] ;
10733
10734 if (!args) SWIG_fail;
10735 swig_obj[0] = args;
10736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerEvent, 0 | 0 );
10737 if (!SWIG_IsOK(res1)) {
10738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerEvent_GetInterval" "', expected argument " "1"" of type '" "wxTimerEvent const *""'");
10739 }
10740 arg1 = reinterpret_cast< wxTimerEvent * >(argp1);
10741 {
10742 PyThreadState* __tstate = wxPyBeginAllowThreads();
10743 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
10744 wxPyEndAllowThreads(__tstate);
10745 if (PyErr_Occurred()) SWIG_fail;
10746 }
10747 resultobj = SWIG_From_int(static_cast< int >(result));
10748 return resultobj;
10749 fail:
10750 return NULL;
10751 }
10752
10753
10754 SWIGINTERN PyObject *TimerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10755 PyObject *obj;
10756 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10757 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerEvent, SWIG_NewClientData(obj));
10758 return SWIG_Py_Void();
10759 }
10760
10761 SWIGINTERN PyObject *TimerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10762 return SWIG_Python_InitShadowInstance(args);
10763 }
10764
10765 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10766 PyObject *resultobj = 0;
10767 wxTimer *arg1 = 0 ;
10768 wxTimerRunner *result = 0 ;
10769 void *argp1 = 0 ;
10770 int res1 = 0 ;
10771
10772 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
10773 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
10774 if (!SWIG_IsOK(res1)) {
10775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
10776 }
10777 if (!argp1) {
10778 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
10779 }
10780 arg1 = reinterpret_cast< wxTimer * >(argp1);
10781 {
10782 if (!wxPyCheckForApp()) SWIG_fail;
10783 PyThreadState* __tstate = wxPyBeginAllowThreads();
10784 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
10785 wxPyEndAllowThreads(__tstate);
10786 if (PyErr_Occurred()) SWIG_fail;
10787 }
10788 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
10789 return resultobj;
10790 fail:
10791 return NULL;
10792 }
10793
10794
10795 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10796 PyObject *resultobj = 0;
10797 wxTimer *arg1 = 0 ;
10798 int arg2 ;
10799 bool arg3 = (bool) false ;
10800 wxTimerRunner *result = 0 ;
10801 void *argp1 = 0 ;
10802 int res1 = 0 ;
10803 int val2 ;
10804 int ecode2 = 0 ;
10805 bool val3 ;
10806 int ecode3 = 0 ;
10807
10808 if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
10809 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
10810 if (!SWIG_IsOK(res1)) {
10811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
10812 }
10813 if (!argp1) {
10814 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
10815 }
10816 arg1 = reinterpret_cast< wxTimer * >(argp1);
10817 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
10818 if (!SWIG_IsOK(ecode2)) {
10819 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerRunner" "', expected argument " "2"" of type '" "int""'");
10820 }
10821 arg2 = static_cast< int >(val2);
10822 if (swig_obj[2]) {
10823 ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
10824 if (!SWIG_IsOK(ecode3)) {
10825 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimerRunner" "', expected argument " "3"" of type '" "bool""'");
10826 }
10827 arg3 = static_cast< bool >(val3);
10828 }
10829 {
10830 if (!wxPyCheckForApp()) SWIG_fail;
10831 PyThreadState* __tstate = wxPyBeginAllowThreads();
10832 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
10833 wxPyEndAllowThreads(__tstate);
10834 if (PyErr_Occurred()) SWIG_fail;
10835 }
10836 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
10837 return resultobj;
10838 fail:
10839 return NULL;
10840 }
10841
10842
10843 SWIGINTERN PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
10844 int argc;
10845 PyObject *argv[4];
10846
10847 if (!(argc = SWIG_Python_UnpackTuple(args,"new_TimerRunner",0,3,argv))) SWIG_fail;
10848 --argc;
10849 if (argc == 1) {
10850 return _wrap_new_TimerRunner__SWIG_0(self, argc, argv);
10851 }
10852 if ((argc >= 2) && (argc <= 3)) {
10853 return _wrap_new_TimerRunner__SWIG_1(self, argc, argv);
10854 }
10855
10856 fail:
10857 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
10858 return NULL;
10859 }
10860
10861
10862 SWIGINTERN PyObject *_wrap_delete_TimerRunner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10863 PyObject *resultobj = 0;
10864 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
10865 void *argp1 = 0 ;
10866 int res1 = 0 ;
10867 PyObject *swig_obj[1] ;
10868
10869 if (!args) SWIG_fail;
10870 swig_obj[0] = args;
10871 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_DISOWN | 0 );
10872 if (!SWIG_IsOK(res1)) {
10873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimerRunner" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
10874 }
10875 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
10876 {
10877 PyThreadState* __tstate = wxPyBeginAllowThreads();
10878 delete arg1;
10879
10880 wxPyEndAllowThreads(__tstate);
10881 if (PyErr_Occurred()) SWIG_fail;
10882 }
10883 resultobj = SWIG_Py_Void();
10884 return resultobj;
10885 fail:
10886 return NULL;
10887 }
10888
10889
10890 SWIGINTERN PyObject *_wrap_TimerRunner_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10891 PyObject *resultobj = 0;
10892 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
10893 int arg2 ;
10894 bool arg3 = (bool) false ;
10895 void *argp1 = 0 ;
10896 int res1 = 0 ;
10897 int val2 ;
10898 int ecode2 = 0 ;
10899 bool val3 ;
10900 int ecode3 = 0 ;
10901 PyObject * obj0 = 0 ;
10902 PyObject * obj1 = 0 ;
10903 PyObject * obj2 = 0 ;
10904 char * kwnames[] = {
10905 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
10906 };
10907
10908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimerRunner, 0 | 0 );
10910 if (!SWIG_IsOK(res1)) {
10911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerRunner_Start" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
10912 }
10913 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
10914 ecode2 = SWIG_AsVal_int(obj1, &val2);
10915 if (!SWIG_IsOK(ecode2)) {
10916 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimerRunner_Start" "', expected argument " "2"" of type '" "int""'");
10917 }
10918 arg2 = static_cast< int >(val2);
10919 if (obj2) {
10920 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10921 if (!SWIG_IsOK(ecode3)) {
10922 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TimerRunner_Start" "', expected argument " "3"" of type '" "bool""'");
10923 }
10924 arg3 = static_cast< bool >(val3);
10925 }
10926 {
10927 PyThreadState* __tstate = wxPyBeginAllowThreads();
10928 (arg1)->Start(arg2,arg3);
10929 wxPyEndAllowThreads(__tstate);
10930 if (PyErr_Occurred()) SWIG_fail;
10931 }
10932 resultobj = SWIG_Py_Void();
10933 return resultobj;
10934 fail:
10935 return NULL;
10936 }
10937
10938
10939 SWIGINTERN PyObject *TimerRunner_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10940 PyObject *obj;
10941 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10942 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerRunner, SWIG_NewClientData(obj));
10943 return SWIG_Py_Void();
10944 }
10945
10946 SWIGINTERN PyObject *TimerRunner_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10947 return SWIG_Python_InitShadowInstance(args);
10948 }
10949
10950 SWIGINTERN PyObject *_wrap_new_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10951 PyObject *resultobj = 0;
10952 wxLog *result = 0 ;
10953
10954 if (!SWIG_Python_UnpackTuple(args,"new_Log",0,0,0)) SWIG_fail;
10955 {
10956 PyThreadState* __tstate = wxPyBeginAllowThreads();
10957 result = (wxLog *)new wxLog();
10958 wxPyEndAllowThreads(__tstate);
10959 if (PyErr_Occurred()) SWIG_fail;
10960 }
10961 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_NEW | 0 );
10962 return resultobj;
10963 fail:
10964 return NULL;
10965 }
10966
10967
10968 SWIGINTERN PyObject *_wrap_delete_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10969 PyObject *resultobj = 0;
10970 wxLog *arg1 = (wxLog *) 0 ;
10971 void *argp1 = 0 ;
10972 int res1 = 0 ;
10973 PyObject *swig_obj[1] ;
10974
10975 if (!args) SWIG_fail;
10976 swig_obj[0] = args;
10977 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
10978 if (!SWIG_IsOK(res1)) {
10979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Log" "', expected argument " "1"" of type '" "wxLog *""'");
10980 }
10981 arg1 = reinterpret_cast< wxLog * >(argp1);
10982 {
10983 PyThreadState* __tstate = wxPyBeginAllowThreads();
10984 delete arg1;
10985
10986 wxPyEndAllowThreads(__tstate);
10987 if (PyErr_Occurred()) SWIG_fail;
10988 }
10989 resultobj = SWIG_Py_Void();
10990 return resultobj;
10991 fail:
10992 return NULL;
10993 }
10994
10995
10996 SWIGINTERN PyObject *_wrap_Log_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10997 PyObject *resultobj = 0;
10998 bool result;
10999
11000 if (!SWIG_Python_UnpackTuple(args,"Log_IsEnabled",0,0,0)) SWIG_fail;
11001 {
11002 PyThreadState* __tstate = wxPyBeginAllowThreads();
11003 result = (bool)wxLog::IsEnabled();
11004 wxPyEndAllowThreads(__tstate);
11005 if (PyErr_Occurred()) SWIG_fail;
11006 }
11007 {
11008 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11009 }
11010 return resultobj;
11011 fail:
11012 return NULL;
11013 }
11014
11015
11016 SWIGINTERN PyObject *_wrap_Log_EnableLogging(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11017 PyObject *resultobj = 0;
11018 bool arg1 = (bool) true ;
11019 bool result;
11020 bool val1 ;
11021 int ecode1 = 0 ;
11022 PyObject * obj0 = 0 ;
11023 char * kwnames[] = {
11024 (char *) "doIt", NULL
11025 };
11026
11027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) SWIG_fail;
11028 if (obj0) {
11029 ecode1 = SWIG_AsVal_bool(obj0, &val1);
11030 if (!SWIG_IsOK(ecode1)) {
11031 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_EnableLogging" "', expected argument " "1"" of type '" "bool""'");
11032 }
11033 arg1 = static_cast< bool >(val1);
11034 }
11035 {
11036 PyThreadState* __tstate = wxPyBeginAllowThreads();
11037 result = (bool)wxLog::EnableLogging(arg1);
11038 wxPyEndAllowThreads(__tstate);
11039 if (PyErr_Occurred()) SWIG_fail;
11040 }
11041 {
11042 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11043 }
11044 return resultobj;
11045 fail:
11046 return NULL;
11047 }
11048
11049
11050 SWIGINTERN PyObject *_wrap_Log_OnLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11051 PyObject *resultobj = 0;
11052 wxLogLevel arg1 ;
11053 wxChar *arg2 = (wxChar *) 0 ;
11054 time_t arg3 ;
11055 unsigned long val1 ;
11056 int ecode1 = 0 ;
11057 void *argp2 = 0 ;
11058 int res2 = 0 ;
11059 unsigned int val3 ;
11060 int ecode3 = 0 ;
11061 PyObject * obj0 = 0 ;
11062 PyObject * obj1 = 0 ;
11063 PyObject * obj2 = 0 ;
11064 char * kwnames[] = {
11065 (char *) "level",(char *) "szString",(char *) "t", NULL
11066 };
11067
11068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11069 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
11070 if (!SWIG_IsOK(ecode1)) {
11071 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_OnLog" "', expected argument " "1"" of type '" "wxLogLevel""'");
11072 }
11073 arg1 = static_cast< wxLogLevel >(val1);
11074 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxChar, 0 | 0 );
11075 if (!SWIG_IsOK(res2)) {
11076 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Log_OnLog" "', expected argument " "2"" of type '" "wxChar const *""'");
11077 }
11078 arg2 = reinterpret_cast< wxChar * >(argp2);
11079 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
11080 if (!SWIG_IsOK(ecode3)) {
11081 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Log_OnLog" "', expected argument " "3"" of type '" "time_t""'");
11082 }
11083 arg3 = static_cast< time_t >(val3);
11084 {
11085 PyThreadState* __tstate = wxPyBeginAllowThreads();
11086 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
11087 wxPyEndAllowThreads(__tstate);
11088 if (PyErr_Occurred()) SWIG_fail;
11089 }
11090 resultobj = SWIG_Py_Void();
11091 return resultobj;
11092 fail:
11093 return NULL;
11094 }
11095
11096
11097 SWIGINTERN PyObject *_wrap_Log_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11098 PyObject *resultobj = 0;
11099 wxLog *arg1 = (wxLog *) 0 ;
11100 void *argp1 = 0 ;
11101 int res1 = 0 ;
11102 PyObject *swig_obj[1] ;
11103
11104 if (!args) SWIG_fail;
11105 swig_obj[0] = args;
11106 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
11107 if (!SWIG_IsOK(res1)) {
11108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Flush" "', expected argument " "1"" of type '" "wxLog *""'");
11109 }
11110 arg1 = reinterpret_cast< wxLog * >(argp1);
11111 {
11112 PyThreadState* __tstate = wxPyBeginAllowThreads();
11113 (arg1)->Flush();
11114 wxPyEndAllowThreads(__tstate);
11115 if (PyErr_Occurred()) SWIG_fail;
11116 }
11117 resultobj = SWIG_Py_Void();
11118 return resultobj;
11119 fail:
11120 return NULL;
11121 }
11122
11123
11124 SWIGINTERN PyObject *_wrap_Log_FlushActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11125 PyObject *resultobj = 0;
11126
11127 if (!SWIG_Python_UnpackTuple(args,"Log_FlushActive",0,0,0)) SWIG_fail;
11128 {
11129 PyThreadState* __tstate = wxPyBeginAllowThreads();
11130 wxLog::FlushActive();
11131 wxPyEndAllowThreads(__tstate);
11132 if (PyErr_Occurred()) SWIG_fail;
11133 }
11134 resultobj = SWIG_Py_Void();
11135 return resultobj;
11136 fail:
11137 return NULL;
11138 }
11139
11140
11141 SWIGINTERN PyObject *_wrap_Log_GetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11142 PyObject *resultobj = 0;
11143 wxLog *result = 0 ;
11144
11145 if (!SWIG_Python_UnpackTuple(args,"Log_GetActiveTarget",0,0,0)) SWIG_fail;
11146 {
11147 PyThreadState* __tstate = wxPyBeginAllowThreads();
11148 result = (wxLog *)wxLog::GetActiveTarget();
11149 wxPyEndAllowThreads(__tstate);
11150 if (PyErr_Occurred()) SWIG_fail;
11151 }
11152 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
11153 return resultobj;
11154 fail:
11155 return NULL;
11156 }
11157
11158
11159 SWIGINTERN PyObject *_wrap_Log_SetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11160 PyObject *resultobj = 0;
11161 wxLog *arg1 = (wxLog *) 0 ;
11162 wxLog *result = 0 ;
11163 int res1 = 0 ;
11164 PyObject * obj0 = 0 ;
11165 char * kwnames[] = {
11166 (char *) "pLogger", NULL
11167 };
11168
11169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) SWIG_fail;
11170 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
11171 if (!SWIG_IsOK(res1)) {
11172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetActiveTarget" "', expected argument " "1"" of type '" "wxLog *""'");
11173 }
11174 {
11175 PyThreadState* __tstate = wxPyBeginAllowThreads();
11176 result = (wxLog *)wxLog::SetActiveTarget(arg1);
11177 wxPyEndAllowThreads(__tstate);
11178 if (PyErr_Occurred()) SWIG_fail;
11179 }
11180 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_OWN | 0 );
11181 return resultobj;
11182 fail:
11183 return NULL;
11184 }
11185
11186
11187 SWIGINTERN PyObject *_wrap_Log_Suspend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11188 PyObject *resultobj = 0;
11189
11190 if (!SWIG_Python_UnpackTuple(args,"Log_Suspend",0,0,0)) SWIG_fail;
11191 {
11192 PyThreadState* __tstate = wxPyBeginAllowThreads();
11193 wxLog::Suspend();
11194 wxPyEndAllowThreads(__tstate);
11195 if (PyErr_Occurred()) SWIG_fail;
11196 }
11197 resultobj = SWIG_Py_Void();
11198 return resultobj;
11199 fail:
11200 return NULL;
11201 }
11202
11203
11204 SWIGINTERN PyObject *_wrap_Log_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11205 PyObject *resultobj = 0;
11206
11207 if (!SWIG_Python_UnpackTuple(args,"Log_Resume",0,0,0)) SWIG_fail;
11208 {
11209 PyThreadState* __tstate = wxPyBeginAllowThreads();
11210 wxLog::Resume();
11211 wxPyEndAllowThreads(__tstate);
11212 if (PyErr_Occurred()) SWIG_fail;
11213 }
11214 resultobj = SWIG_Py_Void();
11215 return resultobj;
11216 fail:
11217 return NULL;
11218 }
11219
11220
11221 SWIGINTERN PyObject *_wrap_Log_SetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11222 PyObject *resultobj = 0;
11223 bool arg1 = (bool) true ;
11224 bool val1 ;
11225 int ecode1 = 0 ;
11226 PyObject * obj0 = 0 ;
11227 char * kwnames[] = {
11228 (char *) "bVerbose", NULL
11229 };
11230
11231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) SWIG_fail;
11232 if (obj0) {
11233 ecode1 = SWIG_AsVal_bool(obj0, &val1);
11234 if (!SWIG_IsOK(ecode1)) {
11235 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetVerbose" "', expected argument " "1"" of type '" "bool""'");
11236 }
11237 arg1 = static_cast< bool >(val1);
11238 }
11239 {
11240 PyThreadState* __tstate = wxPyBeginAllowThreads();
11241 wxLog::SetVerbose(arg1);
11242 wxPyEndAllowThreads(__tstate);
11243 if (PyErr_Occurred()) SWIG_fail;
11244 }
11245 resultobj = SWIG_Py_Void();
11246 return resultobj;
11247 fail:
11248 return NULL;
11249 }
11250
11251
11252 SWIGINTERN PyObject *_wrap_Log_SetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11253 PyObject *resultobj = 0;
11254 wxLogLevel arg1 ;
11255 unsigned long val1 ;
11256 int ecode1 = 0 ;
11257 PyObject * obj0 = 0 ;
11258 char * kwnames[] = {
11259 (char *) "logLevel", NULL
11260 };
11261
11262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) SWIG_fail;
11263 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
11264 if (!SWIG_IsOK(ecode1)) {
11265 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetLogLevel" "', expected argument " "1"" of type '" "wxLogLevel""'");
11266 }
11267 arg1 = static_cast< wxLogLevel >(val1);
11268 {
11269 PyThreadState* __tstate = wxPyBeginAllowThreads();
11270 wxLog::SetLogLevel(arg1);
11271 wxPyEndAllowThreads(__tstate);
11272 if (PyErr_Occurred()) SWIG_fail;
11273 }
11274 resultobj = SWIG_Py_Void();
11275 return resultobj;
11276 fail:
11277 return NULL;
11278 }
11279
11280
11281 SWIGINTERN PyObject *_wrap_Log_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11282 PyObject *resultobj = 0;
11283
11284 if (!SWIG_Python_UnpackTuple(args,"Log_DontCreateOnDemand",0,0,0)) SWIG_fail;
11285 {
11286 PyThreadState* __tstate = wxPyBeginAllowThreads();
11287 wxLog::DontCreateOnDemand();
11288 wxPyEndAllowThreads(__tstate);
11289 if (PyErr_Occurred()) SWIG_fail;
11290 }
11291 resultobj = SWIG_Py_Void();
11292 return resultobj;
11293 fail:
11294 return NULL;
11295 }
11296
11297
11298 SWIGINTERN PyObject *_wrap_Log_SetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11299 PyObject *resultobj = 0;
11300 wxTraceMask arg1 ;
11301 unsigned long val1 ;
11302 int ecode1 = 0 ;
11303 PyObject * obj0 = 0 ;
11304 char * kwnames[] = {
11305 (char *) "ulMask", NULL
11306 };
11307
11308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) SWIG_fail;
11309 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
11310 if (!SWIG_IsOK(ecode1)) {
11311 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetTraceMask" "', expected argument " "1"" of type '" "wxTraceMask""'");
11312 }
11313 arg1 = static_cast< wxTraceMask >(val1);
11314 {
11315 PyThreadState* __tstate = wxPyBeginAllowThreads();
11316 wxLog::SetTraceMask(arg1);
11317 wxPyEndAllowThreads(__tstate);
11318 if (PyErr_Occurred()) SWIG_fail;
11319 }
11320 resultobj = SWIG_Py_Void();
11321 return resultobj;
11322 fail:
11323 return NULL;
11324 }
11325
11326
11327 SWIGINTERN PyObject *_wrap_Log_AddTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11328 PyObject *resultobj = 0;
11329 wxString *arg1 = 0 ;
11330 bool temp1 = false ;
11331 PyObject * obj0 = 0 ;
11332 char * kwnames[] = {
11333 (char *) "str", NULL
11334 };
11335
11336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) SWIG_fail;
11337 {
11338 arg1 = wxString_in_helper(obj0);
11339 if (arg1 == NULL) SWIG_fail;
11340 temp1 = true;
11341 }
11342 {
11343 PyThreadState* __tstate = wxPyBeginAllowThreads();
11344 wxLog::AddTraceMask((wxString const &)*arg1);
11345 wxPyEndAllowThreads(__tstate);
11346 if (PyErr_Occurred()) SWIG_fail;
11347 }
11348 resultobj = SWIG_Py_Void();
11349 {
11350 if (temp1)
11351 delete arg1;
11352 }
11353 return resultobj;
11354 fail:
11355 {
11356 if (temp1)
11357 delete arg1;
11358 }
11359 return NULL;
11360 }
11361
11362
11363 SWIGINTERN PyObject *_wrap_Log_RemoveTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11364 PyObject *resultobj = 0;
11365 wxString *arg1 = 0 ;
11366 bool temp1 = false ;
11367 PyObject * obj0 = 0 ;
11368 char * kwnames[] = {
11369 (char *) "str", NULL
11370 };
11371
11372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) SWIG_fail;
11373 {
11374 arg1 = wxString_in_helper(obj0);
11375 if (arg1 == NULL) SWIG_fail;
11376 temp1 = true;
11377 }
11378 {
11379 PyThreadState* __tstate = wxPyBeginAllowThreads();
11380 wxLog::RemoveTraceMask((wxString const &)*arg1);
11381 wxPyEndAllowThreads(__tstate);
11382 if (PyErr_Occurred()) SWIG_fail;
11383 }
11384 resultobj = SWIG_Py_Void();
11385 {
11386 if (temp1)
11387 delete arg1;
11388 }
11389 return resultobj;
11390 fail:
11391 {
11392 if (temp1)
11393 delete arg1;
11394 }
11395 return NULL;
11396 }
11397
11398
11399 SWIGINTERN PyObject *_wrap_Log_ClearTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11400 PyObject *resultobj = 0;
11401
11402 if (!SWIG_Python_UnpackTuple(args,"Log_ClearTraceMasks",0,0,0)) SWIG_fail;
11403 {
11404 PyThreadState* __tstate = wxPyBeginAllowThreads();
11405 wxLog::ClearTraceMasks();
11406 wxPyEndAllowThreads(__tstate);
11407 if (PyErr_Occurred()) SWIG_fail;
11408 }
11409 resultobj = SWIG_Py_Void();
11410 return resultobj;
11411 fail:
11412 return NULL;
11413 }
11414
11415
11416 SWIGINTERN PyObject *_wrap_Log_GetTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11417 PyObject *resultobj = 0;
11418 wxArrayString *result = 0 ;
11419
11420 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMasks",0,0,0)) SWIG_fail;
11421 {
11422 PyThreadState* __tstate = wxPyBeginAllowThreads();
11423 {
11424 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
11425 result = (wxArrayString *) &_result_ref;
11426 }
11427 wxPyEndAllowThreads(__tstate);
11428 if (PyErr_Occurred()) SWIG_fail;
11429 }
11430 {
11431 resultobj = wxArrayString2PyList_helper(*result);
11432 }
11433 return resultobj;
11434 fail:
11435 return NULL;
11436 }
11437
11438
11439 SWIGINTERN PyObject *_wrap_Log_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11440 PyObject *resultobj = 0;
11441 wxChar *arg1 = (wxChar *) 0 ;
11442 void *argp1 = 0 ;
11443 int res1 = 0 ;
11444 PyObject * obj0 = 0 ;
11445 char * kwnames[] = {
11446 (char *) "ts", NULL
11447 };
11448
11449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) SWIG_fail;
11450 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
11451 if (!SWIG_IsOK(res1)) {
11452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetTimestamp" "', expected argument " "1"" of type '" "wxChar const *""'");
11453 }
11454 arg1 = reinterpret_cast< wxChar * >(argp1);
11455 {
11456 PyThreadState* __tstate = wxPyBeginAllowThreads();
11457 wxLog::SetTimestamp((wxChar const *)arg1);
11458 wxPyEndAllowThreads(__tstate);
11459 if (PyErr_Occurred()) SWIG_fail;
11460 }
11461 resultobj = SWIG_Py_Void();
11462 return resultobj;
11463 fail:
11464 return NULL;
11465 }
11466
11467
11468 SWIGINTERN PyObject *_wrap_Log_GetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11469 PyObject *resultobj = 0;
11470 bool result;
11471
11472 if (!SWIG_Python_UnpackTuple(args,"Log_GetVerbose",0,0,0)) SWIG_fail;
11473 {
11474 PyThreadState* __tstate = wxPyBeginAllowThreads();
11475 result = (bool)wxLog::GetVerbose();
11476 wxPyEndAllowThreads(__tstate);
11477 if (PyErr_Occurred()) SWIG_fail;
11478 }
11479 {
11480 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11481 }
11482 return resultobj;
11483 fail:
11484 return NULL;
11485 }
11486
11487
11488 SWIGINTERN PyObject *_wrap_Log_GetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11489 PyObject *resultobj = 0;
11490 wxTraceMask result;
11491
11492 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMask",0,0,0)) SWIG_fail;
11493 {
11494 PyThreadState* __tstate = wxPyBeginAllowThreads();
11495 result = (wxTraceMask)wxLog::GetTraceMask();
11496 wxPyEndAllowThreads(__tstate);
11497 if (PyErr_Occurred()) SWIG_fail;
11498 }
11499 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
11500 return resultobj;
11501 fail:
11502 return NULL;
11503 }
11504
11505
11506 SWIGINTERN PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11507 PyObject *resultobj = 0;
11508 wxChar *arg1 = (wxChar *) 0 ;
11509 bool result;
11510 void *argp1 = 0 ;
11511 int res1 = 0 ;
11512 PyObject * obj0 = 0 ;
11513 char * kwnames[] = {
11514 (char *) "mask", NULL
11515 };
11516
11517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) SWIG_fail;
11518 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
11519 if (!SWIG_IsOK(res1)) {
11520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_IsAllowedTraceMask" "', expected argument " "1"" of type '" "wxChar const *""'");
11521 }
11522 arg1 = reinterpret_cast< wxChar * >(argp1);
11523 {
11524 PyThreadState* __tstate = wxPyBeginAllowThreads();
11525 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
11526 wxPyEndAllowThreads(__tstate);
11527 if (PyErr_Occurred()) SWIG_fail;
11528 }
11529 {
11530 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11531 }
11532 return resultobj;
11533 fail:
11534 return NULL;
11535 }
11536
11537
11538 SWIGINTERN PyObject *_wrap_Log_GetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11539 PyObject *resultobj = 0;
11540 wxLogLevel result;
11541
11542 if (!SWIG_Python_UnpackTuple(args,"Log_GetLogLevel",0,0,0)) SWIG_fail;
11543 {
11544 PyThreadState* __tstate = wxPyBeginAllowThreads();
11545 result = (wxLogLevel)wxLog::GetLogLevel();
11546 wxPyEndAllowThreads(__tstate);
11547 if (PyErr_Occurred()) SWIG_fail;
11548 }
11549 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
11550 return resultobj;
11551 fail:
11552 return NULL;
11553 }
11554
11555
11556 SWIGINTERN PyObject *_wrap_Log_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11557 PyObject *resultobj = 0;
11558 wxChar *result = 0 ;
11559
11560 if (!SWIG_Python_UnpackTuple(args,"Log_GetTimestamp",0,0,0)) SWIG_fail;
11561 {
11562 PyThreadState* __tstate = wxPyBeginAllowThreads();
11563 result = (wxChar *)wxLog::GetTimestamp();
11564 wxPyEndAllowThreads(__tstate);
11565 if (PyErr_Occurred()) SWIG_fail;
11566 }
11567 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChar, 0 | 0 );
11568 return resultobj;
11569 fail:
11570 return NULL;
11571 }
11572
11573
11574 SWIGINTERN PyObject *_wrap_Log_TimeStamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11575 PyObject *resultobj = 0;
11576 wxString result;
11577
11578 if (!SWIG_Python_UnpackTuple(args,"Log_TimeStamp",0,0,0)) SWIG_fail;
11579 {
11580 PyThreadState* __tstate = wxPyBeginAllowThreads();
11581 result = wxLog_TimeStamp();
11582 wxPyEndAllowThreads(__tstate);
11583 if (PyErr_Occurred()) SWIG_fail;
11584 }
11585 {
11586 #if wxUSE_UNICODE
11587 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11588 #else
11589 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11590 #endif
11591 }
11592 return resultobj;
11593 fail:
11594 return NULL;
11595 }
11596
11597
11598 SWIGINTERN PyObject *_wrap_Log_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11599 PyObject *resultobj = 0;
11600 wxLog *arg1 = (wxLog *) 0 ;
11601 void *argp1 = 0 ;
11602 int res1 = 0 ;
11603 PyObject *swig_obj[1] ;
11604
11605 if (!args) SWIG_fail;
11606 swig_obj[0] = args;
11607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
11608 if (!SWIG_IsOK(res1)) {
11609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Destroy" "', expected argument " "1"" of type '" "wxLog *""'");
11610 }
11611 arg1 = reinterpret_cast< wxLog * >(argp1);
11612 {
11613 PyThreadState* __tstate = wxPyBeginAllowThreads();
11614 wxLog_Destroy(arg1);
11615 wxPyEndAllowThreads(__tstate);
11616 if (PyErr_Occurred()) SWIG_fail;
11617 }
11618 resultobj = SWIG_Py_Void();
11619 return resultobj;
11620 fail:
11621 return NULL;
11622 }
11623
11624
11625 SWIGINTERN PyObject *Log_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11626 PyObject *obj;
11627 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11628 SWIG_TypeNewClientData(SWIGTYPE_p_wxLog, SWIG_NewClientData(obj));
11629 return SWIG_Py_Void();
11630 }
11631
11632 SWIGINTERN PyObject *Log_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11633 return SWIG_Python_InitShadowInstance(args);
11634 }
11635
11636 SWIGINTERN PyObject *_wrap_new_LogStderr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11637 PyObject *resultobj = 0;
11638 wxLogStderr *result = 0 ;
11639
11640 if (!SWIG_Python_UnpackTuple(args,"new_LogStderr",0,0,0)) SWIG_fail;
11641 {
11642 PyThreadState* __tstate = wxPyBeginAllowThreads();
11643 result = (wxLogStderr *)new wxLogStderr();
11644 wxPyEndAllowThreads(__tstate);
11645 if (PyErr_Occurred()) SWIG_fail;
11646 }
11647 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogStderr, SWIG_POINTER_NEW | 0 );
11648 return resultobj;
11649 fail:
11650 return NULL;
11651 }
11652
11653
11654 SWIGINTERN PyObject *LogStderr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11655 PyObject *obj;
11656 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11657 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogStderr, SWIG_NewClientData(obj));
11658 return SWIG_Py_Void();
11659 }
11660
11661 SWIGINTERN PyObject *LogStderr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11662 return SWIG_Python_InitShadowInstance(args);
11663 }
11664
11665 SWIGINTERN PyObject *_wrap_new_LogTextCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11666 PyObject *resultobj = 0;
11667 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
11668 wxLogTextCtrl *result = 0 ;
11669 void *argp1 = 0 ;
11670 int res1 = 0 ;
11671 PyObject * obj0 = 0 ;
11672 char * kwnames[] = {
11673 (char *) "pTextCtrl", NULL
11674 };
11675
11676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) SWIG_fail;
11677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextCtrl, 0 | 0 );
11678 if (!SWIG_IsOK(res1)) {
11679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogTextCtrl" "', expected argument " "1"" of type '" "wxTextCtrl *""'");
11680 }
11681 arg1 = reinterpret_cast< wxTextCtrl * >(argp1);
11682 {
11683 PyThreadState* __tstate = wxPyBeginAllowThreads();
11684 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
11685 wxPyEndAllowThreads(__tstate);
11686 if (PyErr_Occurred()) SWIG_fail;
11687 }
11688 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogTextCtrl, SWIG_POINTER_NEW | 0 );
11689 return resultobj;
11690 fail:
11691 return NULL;
11692 }
11693
11694
11695 SWIGINTERN PyObject *LogTextCtrl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11696 PyObject *obj;
11697 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11698 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogTextCtrl, SWIG_NewClientData(obj));
11699 return SWIG_Py_Void();
11700 }
11701
11702 SWIGINTERN PyObject *LogTextCtrl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11703 return SWIG_Python_InitShadowInstance(args);
11704 }
11705
11706 SWIGINTERN PyObject *_wrap_new_LogGui(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11707 PyObject *resultobj = 0;
11708 wxLogGui *result = 0 ;
11709
11710 if (!SWIG_Python_UnpackTuple(args,"new_LogGui",0,0,0)) SWIG_fail;
11711 {
11712 PyThreadState* __tstate = wxPyBeginAllowThreads();
11713 result = (wxLogGui *)new wxLogGui();
11714 wxPyEndAllowThreads(__tstate);
11715 if (PyErr_Occurred()) SWIG_fail;
11716 }
11717 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogGui, SWIG_POINTER_NEW | 0 );
11718 return resultobj;
11719 fail:
11720 return NULL;
11721 }
11722
11723
11724 SWIGINTERN PyObject *LogGui_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11725 PyObject *obj;
11726 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11727 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogGui, SWIG_NewClientData(obj));
11728 return SWIG_Py_Void();
11729 }
11730
11731 SWIGINTERN PyObject *LogGui_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11732 return SWIG_Python_InitShadowInstance(args);
11733 }
11734
11735 SWIGINTERN PyObject *_wrap_new_LogWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11736 PyObject *resultobj = 0;
11737 wxFrame *arg1 = (wxFrame *) 0 ;
11738 wxString *arg2 = 0 ;
11739 bool arg3 = (bool) true ;
11740 bool arg4 = (bool) true ;
11741 wxLogWindow *result = 0 ;
11742 void *argp1 = 0 ;
11743 int res1 = 0 ;
11744 bool temp2 = false ;
11745 bool val3 ;
11746 int ecode3 = 0 ;
11747 bool val4 ;
11748 int ecode4 = 0 ;
11749 PyObject * obj0 = 0 ;
11750 PyObject * obj1 = 0 ;
11751 PyObject * obj2 = 0 ;
11752 PyObject * obj3 = 0 ;
11753 char * kwnames[] = {
11754 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
11755 };
11756
11757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11758 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
11759 if (!SWIG_IsOK(res1)) {
11760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogWindow" "', expected argument " "1"" of type '" "wxFrame *""'");
11761 }
11762 arg1 = reinterpret_cast< wxFrame * >(argp1);
11763 {
11764 arg2 = wxString_in_helper(obj1);
11765 if (arg2 == NULL) SWIG_fail;
11766 temp2 = true;
11767 }
11768 if (obj2) {
11769 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11770 if (!SWIG_IsOK(ecode3)) {
11771 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_LogWindow" "', expected argument " "3"" of type '" "bool""'");
11772 }
11773 arg3 = static_cast< bool >(val3);
11774 }
11775 if (obj3) {
11776 ecode4 = SWIG_AsVal_bool(obj3, &val4);
11777 if (!SWIG_IsOK(ecode4)) {
11778 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LogWindow" "', expected argument " "4"" of type '" "bool""'");
11779 }
11780 arg4 = static_cast< bool >(val4);
11781 }
11782 {
11783 PyThreadState* __tstate = wxPyBeginAllowThreads();
11784 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
11785 wxPyEndAllowThreads(__tstate);
11786 if (PyErr_Occurred()) SWIG_fail;
11787 }
11788 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogWindow, SWIG_POINTER_NEW | 0 );
11789 {
11790 if (temp2)
11791 delete arg2;
11792 }
11793 return resultobj;
11794 fail:
11795 {
11796 if (temp2)
11797 delete arg2;
11798 }
11799 return NULL;
11800 }
11801
11802
11803 SWIGINTERN PyObject *_wrap_LogWindow_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11804 PyObject *resultobj = 0;
11805 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
11806 bool arg2 = (bool) true ;
11807 void *argp1 = 0 ;
11808 int res1 = 0 ;
11809 bool val2 ;
11810 int ecode2 = 0 ;
11811 PyObject * obj0 = 0 ;
11812 PyObject * obj1 = 0 ;
11813 char * kwnames[] = {
11814 (char *) "self",(char *) "bShow", NULL
11815 };
11816
11817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) SWIG_fail;
11818 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
11819 if (!SWIG_IsOK(res1)) {
11820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_Show" "', expected argument " "1"" of type '" "wxLogWindow *""'");
11821 }
11822 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
11823 if (obj1) {
11824 ecode2 = SWIG_AsVal_bool(obj1, &val2);
11825 if (!SWIG_IsOK(ecode2)) {
11826 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_Show" "', expected argument " "2"" of type '" "bool""'");
11827 }
11828 arg2 = static_cast< bool >(val2);
11829 }
11830 {
11831 PyThreadState* __tstate = wxPyBeginAllowThreads();
11832 (arg1)->Show(arg2);
11833 wxPyEndAllowThreads(__tstate);
11834 if (PyErr_Occurred()) SWIG_fail;
11835 }
11836 resultobj = SWIG_Py_Void();
11837 return resultobj;
11838 fail:
11839 return NULL;
11840 }
11841
11842
11843 SWIGINTERN PyObject *_wrap_LogWindow_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11844 PyObject *resultobj = 0;
11845 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
11846 wxFrame *result = 0 ;
11847 void *argp1 = 0 ;
11848 int res1 = 0 ;
11849 PyObject *swig_obj[1] ;
11850
11851 if (!args) SWIG_fail;
11852 swig_obj[0] = args;
11853 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
11854 if (!SWIG_IsOK(res1)) {
11855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetFrame" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
11856 }
11857 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
11858 {
11859 PyThreadState* __tstate = wxPyBeginAllowThreads();
11860 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
11861 wxPyEndAllowThreads(__tstate);
11862 if (PyErr_Occurred()) SWIG_fail;
11863 }
11864 {
11865 resultobj = wxPyMake_wxObject(result, (bool)0);
11866 }
11867 return resultobj;
11868 fail:
11869 return NULL;
11870 }
11871
11872
11873 SWIGINTERN PyObject *_wrap_LogWindow_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11874 PyObject *resultobj = 0;
11875 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
11876 wxLog *result = 0 ;
11877 void *argp1 = 0 ;
11878 int res1 = 0 ;
11879 PyObject *swig_obj[1] ;
11880
11881 if (!args) SWIG_fail;
11882 swig_obj[0] = args;
11883 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
11884 if (!SWIG_IsOK(res1)) {
11885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetOldLog" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
11886 }
11887 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
11888 {
11889 PyThreadState* __tstate = wxPyBeginAllowThreads();
11890 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
11891 wxPyEndAllowThreads(__tstate);
11892 if (PyErr_Occurred()) SWIG_fail;
11893 }
11894 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
11895 return resultobj;
11896 fail:
11897 return NULL;
11898 }
11899
11900
11901 SWIGINTERN PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11902 PyObject *resultobj = 0;
11903 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
11904 bool result;
11905 void *argp1 = 0 ;
11906 int res1 = 0 ;
11907 PyObject *swig_obj[1] ;
11908
11909 if (!args) SWIG_fail;
11910 swig_obj[0] = args;
11911 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
11912 if (!SWIG_IsOK(res1)) {
11913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
11914 }
11915 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
11916 {
11917 PyThreadState* __tstate = wxPyBeginAllowThreads();
11918 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
11919 wxPyEndAllowThreads(__tstate);
11920 if (PyErr_Occurred()) SWIG_fail;
11921 }
11922 {
11923 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11924 }
11925 return resultobj;
11926 fail:
11927 return NULL;
11928 }
11929
11930
11931 SWIGINTERN PyObject *_wrap_LogWindow_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11932 PyObject *resultobj = 0;
11933 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
11934 bool arg2 ;
11935 void *argp1 = 0 ;
11936 int res1 = 0 ;
11937 bool val2 ;
11938 int ecode2 = 0 ;
11939 PyObject * obj0 = 0 ;
11940 PyObject * obj1 = 0 ;
11941 char * kwnames[] = {
11942 (char *) "self",(char *) "bDoPass", NULL
11943 };
11944
11945 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
11946 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
11947 if (!SWIG_IsOK(res1)) {
11948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_PassMessages" "', expected argument " "1"" of type '" "wxLogWindow *""'");
11949 }
11950 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
11951 ecode2 = SWIG_AsVal_bool(obj1, &val2);
11952 if (!SWIG_IsOK(ecode2)) {
11953 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_PassMessages" "', expected argument " "2"" of type '" "bool""'");
11954 }
11955 arg2 = static_cast< bool >(val2);
11956 {
11957 PyThreadState* __tstate = wxPyBeginAllowThreads();
11958 (arg1)->PassMessages(arg2);
11959 wxPyEndAllowThreads(__tstate);
11960 if (PyErr_Occurred()) SWIG_fail;
11961 }
11962 resultobj = SWIG_Py_Void();
11963 return resultobj;
11964 fail:
11965 return NULL;
11966 }
11967
11968
11969 SWIGINTERN PyObject *LogWindow_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11970 PyObject *obj;
11971 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11972 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogWindow, SWIG_NewClientData(obj));
11973 return SWIG_Py_Void();
11974 }
11975
11976 SWIGINTERN PyObject *LogWindow_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11977 return SWIG_Python_InitShadowInstance(args);
11978 }
11979
11980 SWIGINTERN PyObject *_wrap_new_LogChain(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11981 PyObject *resultobj = 0;
11982 wxLog *arg1 = (wxLog *) 0 ;
11983 wxLogChain *result = 0 ;
11984 void *argp1 = 0 ;
11985 int res1 = 0 ;
11986 PyObject * obj0 = 0 ;
11987 char * kwnames[] = {
11988 (char *) "logger", NULL
11989 };
11990
11991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) SWIG_fail;
11992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
11993 if (!SWIG_IsOK(res1)) {
11994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogChain" "', expected argument " "1"" of type '" "wxLog *""'");
11995 }
11996 arg1 = reinterpret_cast< wxLog * >(argp1);
11997 {
11998 PyThreadState* __tstate = wxPyBeginAllowThreads();
11999 result = (wxLogChain *)new wxLogChain(arg1);
12000 wxPyEndAllowThreads(__tstate);
12001 if (PyErr_Occurred()) SWIG_fail;
12002 }
12003 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogChain, SWIG_POINTER_NEW | 0 );
12004 return resultobj;
12005 fail:
12006 return NULL;
12007 }
12008
12009
12010 SWIGINTERN PyObject *_wrap_LogChain_SetLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12011 PyObject *resultobj = 0;
12012 wxLogChain *arg1 = (wxLogChain *) 0 ;
12013 wxLog *arg2 = (wxLog *) 0 ;
12014 void *argp1 = 0 ;
12015 int res1 = 0 ;
12016 void *argp2 = 0 ;
12017 int res2 = 0 ;
12018 PyObject * obj0 = 0 ;
12019 PyObject * obj1 = 0 ;
12020 char * kwnames[] = {
12021 (char *) "self",(char *) "logger", NULL
12022 };
12023
12024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) SWIG_fail;
12025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
12026 if (!SWIG_IsOK(res1)) {
12027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_SetLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
12028 }
12029 arg1 = reinterpret_cast< wxLogChain * >(argp1);
12030 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLog, 0 | 0 );
12031 if (!SWIG_IsOK(res2)) {
12032 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LogChain_SetLog" "', expected argument " "2"" of type '" "wxLog *""'");
12033 }
12034 arg2 = reinterpret_cast< wxLog * >(argp2);
12035 {
12036 PyThreadState* __tstate = wxPyBeginAllowThreads();
12037 (arg1)->SetLog(arg2);
12038 wxPyEndAllowThreads(__tstate);
12039 if (PyErr_Occurred()) SWIG_fail;
12040 }
12041 resultobj = SWIG_Py_Void();
12042 return resultobj;
12043 fail:
12044 return NULL;
12045 }
12046
12047
12048 SWIGINTERN PyObject *_wrap_LogChain_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12049 PyObject *resultobj = 0;
12050 wxLogChain *arg1 = (wxLogChain *) 0 ;
12051 bool arg2 ;
12052 void *argp1 = 0 ;
12053 int res1 = 0 ;
12054 bool val2 ;
12055 int ecode2 = 0 ;
12056 PyObject * obj0 = 0 ;
12057 PyObject * obj1 = 0 ;
12058 char * kwnames[] = {
12059 (char *) "self",(char *) "bDoPass", NULL
12060 };
12061
12062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
12063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
12064 if (!SWIG_IsOK(res1)) {
12065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_PassMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
12066 }
12067 arg1 = reinterpret_cast< wxLogChain * >(argp1);
12068 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12069 if (!SWIG_IsOK(ecode2)) {
12070 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogChain_PassMessages" "', expected argument " "2"" of type '" "bool""'");
12071 }
12072 arg2 = static_cast< bool >(val2);
12073 {
12074 PyThreadState* __tstate = wxPyBeginAllowThreads();
12075 (arg1)->PassMessages(arg2);
12076 wxPyEndAllowThreads(__tstate);
12077 if (PyErr_Occurred()) SWIG_fail;
12078 }
12079 resultobj = SWIG_Py_Void();
12080 return resultobj;
12081 fail:
12082 return NULL;
12083 }
12084
12085
12086 SWIGINTERN PyObject *_wrap_LogChain_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12087 PyObject *resultobj = 0;
12088 wxLogChain *arg1 = (wxLogChain *) 0 ;
12089 bool result;
12090 void *argp1 = 0 ;
12091 int res1 = 0 ;
12092 PyObject *swig_obj[1] ;
12093
12094 if (!args) SWIG_fail;
12095 swig_obj[0] = args;
12096 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
12097 if (!SWIG_IsOK(res1)) {
12098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
12099 }
12100 arg1 = reinterpret_cast< wxLogChain * >(argp1);
12101 {
12102 PyThreadState* __tstate = wxPyBeginAllowThreads();
12103 result = (bool)(arg1)->IsPassingMessages();
12104 wxPyEndAllowThreads(__tstate);
12105 if (PyErr_Occurred()) SWIG_fail;
12106 }
12107 {
12108 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12109 }
12110 return resultobj;
12111 fail:
12112 return NULL;
12113 }
12114
12115
12116 SWIGINTERN PyObject *_wrap_LogChain_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12117 PyObject *resultobj = 0;
12118 wxLogChain *arg1 = (wxLogChain *) 0 ;
12119 wxLog *result = 0 ;
12120 void *argp1 = 0 ;
12121 int res1 = 0 ;
12122 PyObject *swig_obj[1] ;
12123
12124 if (!args) SWIG_fail;
12125 swig_obj[0] = args;
12126 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
12127 if (!SWIG_IsOK(res1)) {
12128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_GetOldLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
12129 }
12130 arg1 = reinterpret_cast< wxLogChain * >(argp1);
12131 {
12132 PyThreadState* __tstate = wxPyBeginAllowThreads();
12133 result = (wxLog *)(arg1)->GetOldLog();
12134 wxPyEndAllowThreads(__tstate);
12135 if (PyErr_Occurred()) SWIG_fail;
12136 }
12137 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
12138 return resultobj;
12139 fail:
12140 return NULL;
12141 }
12142
12143
12144 SWIGINTERN PyObject *LogChain_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12145 PyObject *obj;
12146 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12147 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogChain, SWIG_NewClientData(obj));
12148 return SWIG_Py_Void();
12149 }
12150
12151 SWIGINTERN PyObject *LogChain_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12152 return SWIG_Python_InitShadowInstance(args);
12153 }
12154
12155 SWIGINTERN PyObject *_wrap_new_LogBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12156 PyObject *resultobj = 0;
12157 wxLogBuffer *result = 0 ;
12158
12159 if (!SWIG_Python_UnpackTuple(args,"new_LogBuffer",0,0,0)) SWIG_fail;
12160 {
12161 PyThreadState* __tstate = wxPyBeginAllowThreads();
12162 result = (wxLogBuffer *)new wxLogBuffer();
12163 wxPyEndAllowThreads(__tstate);
12164 if (PyErr_Occurred()) SWIG_fail;
12165 }
12166 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogBuffer, SWIG_POINTER_NEW | 0 );
12167 return resultobj;
12168 fail:
12169 return NULL;
12170 }
12171
12172
12173 SWIGINTERN PyObject *_wrap_LogBuffer_GetBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12174 PyObject *resultobj = 0;
12175 wxLogBuffer *arg1 = (wxLogBuffer *) 0 ;
12176 wxString *result = 0 ;
12177 void *argp1 = 0 ;
12178 int res1 = 0 ;
12179 PyObject *swig_obj[1] ;
12180
12181 if (!args) SWIG_fail;
12182 swig_obj[0] = args;
12183 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogBuffer, 0 | 0 );
12184 if (!SWIG_IsOK(res1)) {
12185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogBuffer_GetBuffer" "', expected argument " "1"" of type '" "wxLogBuffer const *""'");
12186 }
12187 arg1 = reinterpret_cast< wxLogBuffer * >(argp1);
12188 {
12189 PyThreadState* __tstate = wxPyBeginAllowThreads();
12190 {
12191 wxString const &_result_ref = ((wxLogBuffer const *)arg1)->GetBuffer();
12192 result = (wxString *) &_result_ref;
12193 }
12194 wxPyEndAllowThreads(__tstate);
12195 if (PyErr_Occurred()) SWIG_fail;
12196 }
12197 {
12198 #if wxUSE_UNICODE
12199 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12200 #else
12201 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12202 #endif
12203 }
12204 return resultobj;
12205 fail:
12206 return NULL;
12207 }
12208
12209
12210 SWIGINTERN PyObject *LogBuffer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12211 PyObject *obj;
12212 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12213 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogBuffer, SWIG_NewClientData(obj));
12214 return SWIG_Py_Void();
12215 }
12216
12217 SWIGINTERN PyObject *LogBuffer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12218 return SWIG_Python_InitShadowInstance(args);
12219 }
12220
12221 SWIGINTERN PyObject *_wrap_SysErrorCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12222 PyObject *resultobj = 0;
12223 unsigned long result;
12224
12225 if (!SWIG_Python_UnpackTuple(args,"SysErrorCode",0,0,0)) SWIG_fail;
12226 {
12227 PyThreadState* __tstate = wxPyBeginAllowThreads();
12228 result = (unsigned long)wxSysErrorCode();
12229 wxPyEndAllowThreads(__tstate);
12230 if (PyErr_Occurred()) SWIG_fail;
12231 }
12232 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12233 return resultobj;
12234 fail:
12235 return NULL;
12236 }
12237
12238
12239 SWIGINTERN PyObject *_wrap_SysErrorMsg(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12240 PyObject *resultobj = 0;
12241 unsigned long arg1 = (unsigned long) 0 ;
12242 wxString result;
12243 unsigned long val1 ;
12244 int ecode1 = 0 ;
12245 PyObject * obj0 = 0 ;
12246 char * kwnames[] = {
12247 (char *) "nErrCode", NULL
12248 };
12249
12250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) SWIG_fail;
12251 if (obj0) {
12252 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12253 if (!SWIG_IsOK(ecode1)) {
12254 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SysErrorMsg" "', expected argument " "1"" of type '" "unsigned long""'");
12255 }
12256 arg1 = static_cast< unsigned long >(val1);
12257 }
12258 {
12259 PyThreadState* __tstate = wxPyBeginAllowThreads();
12260 result = wxSysErrorMsg(arg1);
12261 wxPyEndAllowThreads(__tstate);
12262 if (PyErr_Occurred()) SWIG_fail;
12263 }
12264 {
12265 #if wxUSE_UNICODE
12266 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12267 #else
12268 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12269 #endif
12270 }
12271 return resultobj;
12272 fail:
12273 return NULL;
12274 }
12275
12276
12277 SWIGINTERN PyObject *_wrap_LogFatalError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12278 PyObject *resultobj = 0;
12279 wxString *arg1 = 0 ;
12280 bool temp1 = false ;
12281 PyObject * obj0 = 0 ;
12282 char * kwnames[] = {
12283 (char *) "msg", NULL
12284 };
12285
12286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) SWIG_fail;
12287 {
12288 arg1 = wxString_in_helper(obj0);
12289 if (arg1 == NULL) SWIG_fail;
12290 temp1 = true;
12291 }
12292 {
12293 PyThreadState* __tstate = wxPyBeginAllowThreads();
12294 wxPyLogFatalError((wxString const &)*arg1);
12295 wxPyEndAllowThreads(__tstate);
12296 if (PyErr_Occurred()) SWIG_fail;
12297 }
12298 resultobj = SWIG_Py_Void();
12299 {
12300 if (temp1)
12301 delete arg1;
12302 }
12303 return resultobj;
12304 fail:
12305 {
12306 if (temp1)
12307 delete arg1;
12308 }
12309 return NULL;
12310 }
12311
12312
12313 SWIGINTERN PyObject *_wrap_LogError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12314 PyObject *resultobj = 0;
12315 wxString *arg1 = 0 ;
12316 bool temp1 = false ;
12317 PyObject * obj0 = 0 ;
12318 char * kwnames[] = {
12319 (char *) "msg", NULL
12320 };
12321
12322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) SWIG_fail;
12323 {
12324 arg1 = wxString_in_helper(obj0);
12325 if (arg1 == NULL) SWIG_fail;
12326 temp1 = true;
12327 }
12328 {
12329 PyThreadState* __tstate = wxPyBeginAllowThreads();
12330 wxPyLogError((wxString const &)*arg1);
12331 wxPyEndAllowThreads(__tstate);
12332 if (PyErr_Occurred()) SWIG_fail;
12333 }
12334 resultobj = SWIG_Py_Void();
12335 {
12336 if (temp1)
12337 delete arg1;
12338 }
12339 return resultobj;
12340 fail:
12341 {
12342 if (temp1)
12343 delete arg1;
12344 }
12345 return NULL;
12346 }
12347
12348
12349 SWIGINTERN PyObject *_wrap_LogWarning(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12350 PyObject *resultobj = 0;
12351 wxString *arg1 = 0 ;
12352 bool temp1 = false ;
12353 PyObject * obj0 = 0 ;
12354 char * kwnames[] = {
12355 (char *) "msg", NULL
12356 };
12357
12358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) SWIG_fail;
12359 {
12360 arg1 = wxString_in_helper(obj0);
12361 if (arg1 == NULL) SWIG_fail;
12362 temp1 = true;
12363 }
12364 {
12365 PyThreadState* __tstate = wxPyBeginAllowThreads();
12366 wxPyLogWarning((wxString const &)*arg1);
12367 wxPyEndAllowThreads(__tstate);
12368 if (PyErr_Occurred()) SWIG_fail;
12369 }
12370 resultobj = SWIG_Py_Void();
12371 {
12372 if (temp1)
12373 delete arg1;
12374 }
12375 return resultobj;
12376 fail:
12377 {
12378 if (temp1)
12379 delete arg1;
12380 }
12381 return NULL;
12382 }
12383
12384
12385 SWIGINTERN PyObject *_wrap_LogMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12386 PyObject *resultobj = 0;
12387 wxString *arg1 = 0 ;
12388 bool temp1 = false ;
12389 PyObject * obj0 = 0 ;
12390 char * kwnames[] = {
12391 (char *) "msg", NULL
12392 };
12393
12394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) SWIG_fail;
12395 {
12396 arg1 = wxString_in_helper(obj0);
12397 if (arg1 == NULL) SWIG_fail;
12398 temp1 = true;
12399 }
12400 {
12401 PyThreadState* __tstate = wxPyBeginAllowThreads();
12402 wxPyLogMessage((wxString const &)*arg1);
12403 wxPyEndAllowThreads(__tstate);
12404 if (PyErr_Occurred()) SWIG_fail;
12405 }
12406 resultobj = SWIG_Py_Void();
12407 {
12408 if (temp1)
12409 delete arg1;
12410 }
12411 return resultobj;
12412 fail:
12413 {
12414 if (temp1)
12415 delete arg1;
12416 }
12417 return NULL;
12418 }
12419
12420
12421 SWIGINTERN PyObject *_wrap_LogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12422 PyObject *resultobj = 0;
12423 wxString *arg1 = 0 ;
12424 bool temp1 = false ;
12425 PyObject * obj0 = 0 ;
12426 char * kwnames[] = {
12427 (char *) "msg", NULL
12428 };
12429
12430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) SWIG_fail;
12431 {
12432 arg1 = wxString_in_helper(obj0);
12433 if (arg1 == NULL) SWIG_fail;
12434 temp1 = true;
12435 }
12436 {
12437 PyThreadState* __tstate = wxPyBeginAllowThreads();
12438 wxPyLogInfo((wxString const &)*arg1);
12439 wxPyEndAllowThreads(__tstate);
12440 if (PyErr_Occurred()) SWIG_fail;
12441 }
12442 resultobj = SWIG_Py_Void();
12443 {
12444 if (temp1)
12445 delete arg1;
12446 }
12447 return resultobj;
12448 fail:
12449 {
12450 if (temp1)
12451 delete arg1;
12452 }
12453 return NULL;
12454 }
12455
12456
12457 SWIGINTERN PyObject *_wrap_LogDebug(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12458 PyObject *resultobj = 0;
12459 wxString *arg1 = 0 ;
12460 bool temp1 = false ;
12461 PyObject * obj0 = 0 ;
12462 char * kwnames[] = {
12463 (char *) "msg", NULL
12464 };
12465
12466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) SWIG_fail;
12467 {
12468 arg1 = wxString_in_helper(obj0);
12469 if (arg1 == NULL) SWIG_fail;
12470 temp1 = true;
12471 }
12472 {
12473 PyThreadState* __tstate = wxPyBeginAllowThreads();
12474 wxPyLogDebug((wxString const &)*arg1);
12475 wxPyEndAllowThreads(__tstate);
12476 if (PyErr_Occurred()) SWIG_fail;
12477 }
12478 resultobj = SWIG_Py_Void();
12479 {
12480 if (temp1)
12481 delete arg1;
12482 }
12483 return resultobj;
12484 fail:
12485 {
12486 if (temp1)
12487 delete arg1;
12488 }
12489 return NULL;
12490 }
12491
12492
12493 SWIGINTERN PyObject *_wrap_LogVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12494 PyObject *resultobj = 0;
12495 wxString *arg1 = 0 ;
12496 bool temp1 = false ;
12497 PyObject * obj0 = 0 ;
12498 char * kwnames[] = {
12499 (char *) "msg", NULL
12500 };
12501
12502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) SWIG_fail;
12503 {
12504 arg1 = wxString_in_helper(obj0);
12505 if (arg1 == NULL) SWIG_fail;
12506 temp1 = true;
12507 }
12508 {
12509 PyThreadState* __tstate = wxPyBeginAllowThreads();
12510 wxPyLogVerbose((wxString const &)*arg1);
12511 wxPyEndAllowThreads(__tstate);
12512 if (PyErr_Occurred()) SWIG_fail;
12513 }
12514 resultobj = SWIG_Py_Void();
12515 {
12516 if (temp1)
12517 delete arg1;
12518 }
12519 return resultobj;
12520 fail:
12521 {
12522 if (temp1)
12523 delete arg1;
12524 }
12525 return NULL;
12526 }
12527
12528
12529 SWIGINTERN PyObject *_wrap_LogStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12530 PyObject *resultobj = 0;
12531 wxString *arg1 = 0 ;
12532 bool temp1 = false ;
12533 PyObject * obj0 = 0 ;
12534 char * kwnames[] = {
12535 (char *) "msg", NULL
12536 };
12537
12538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) SWIG_fail;
12539 {
12540 arg1 = wxString_in_helper(obj0);
12541 if (arg1 == NULL) SWIG_fail;
12542 temp1 = true;
12543 }
12544 {
12545 PyThreadState* __tstate = wxPyBeginAllowThreads();
12546 wxPyLogStatus((wxString const &)*arg1);
12547 wxPyEndAllowThreads(__tstate);
12548 if (PyErr_Occurred()) SWIG_fail;
12549 }
12550 resultobj = SWIG_Py_Void();
12551 {
12552 if (temp1)
12553 delete arg1;
12554 }
12555 return resultobj;
12556 fail:
12557 {
12558 if (temp1)
12559 delete arg1;
12560 }
12561 return NULL;
12562 }
12563
12564
12565 SWIGINTERN PyObject *_wrap_LogStatusFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12566 PyObject *resultobj = 0;
12567 wxFrame *arg1 = (wxFrame *) 0 ;
12568 wxString *arg2 = 0 ;
12569 void *argp1 = 0 ;
12570 int res1 = 0 ;
12571 bool temp2 = false ;
12572 PyObject * obj0 = 0 ;
12573 PyObject * obj1 = 0 ;
12574 char * kwnames[] = {
12575 (char *) "pFrame",(char *) "msg", NULL
12576 };
12577
12578 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) SWIG_fail;
12579 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
12580 if (!SWIG_IsOK(res1)) {
12581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogStatusFrame" "', expected argument " "1"" of type '" "wxFrame *""'");
12582 }
12583 arg1 = reinterpret_cast< wxFrame * >(argp1);
12584 {
12585 arg2 = wxString_in_helper(obj1);
12586 if (arg2 == NULL) SWIG_fail;
12587 temp2 = true;
12588 }
12589 {
12590 PyThreadState* __tstate = wxPyBeginAllowThreads();
12591 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
12592 wxPyEndAllowThreads(__tstate);
12593 if (PyErr_Occurred()) SWIG_fail;
12594 }
12595 resultobj = SWIG_Py_Void();
12596 {
12597 if (temp2)
12598 delete arg2;
12599 }
12600 return resultobj;
12601 fail:
12602 {
12603 if (temp2)
12604 delete arg2;
12605 }
12606 return NULL;
12607 }
12608
12609
12610 SWIGINTERN PyObject *_wrap_LogSysError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12611 PyObject *resultobj = 0;
12612 wxString *arg1 = 0 ;
12613 bool temp1 = false ;
12614 PyObject * obj0 = 0 ;
12615 char * kwnames[] = {
12616 (char *) "msg", NULL
12617 };
12618
12619 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) SWIG_fail;
12620 {
12621 arg1 = wxString_in_helper(obj0);
12622 if (arg1 == NULL) SWIG_fail;
12623 temp1 = true;
12624 }
12625 {
12626 PyThreadState* __tstate = wxPyBeginAllowThreads();
12627 wxPyLogSysError((wxString const &)*arg1);
12628 wxPyEndAllowThreads(__tstate);
12629 if (PyErr_Occurred()) SWIG_fail;
12630 }
12631 resultobj = SWIG_Py_Void();
12632 {
12633 if (temp1)
12634 delete arg1;
12635 }
12636 return resultobj;
12637 fail:
12638 {
12639 if (temp1)
12640 delete arg1;
12641 }
12642 return NULL;
12643 }
12644
12645
12646 SWIGINTERN PyObject *_wrap_LogGeneric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12647 PyObject *resultobj = 0;
12648 unsigned long arg1 ;
12649 wxString *arg2 = 0 ;
12650 unsigned long val1 ;
12651 int ecode1 = 0 ;
12652 bool temp2 = false ;
12653 PyObject * obj0 = 0 ;
12654 PyObject * obj1 = 0 ;
12655 char * kwnames[] = {
12656 (char *) "level",(char *) "msg", NULL
12657 };
12658
12659 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) SWIG_fail;
12660 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12661 if (!SWIG_IsOK(ecode1)) {
12662 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogGeneric" "', expected argument " "1"" of type '" "unsigned long""'");
12663 }
12664 arg1 = static_cast< unsigned long >(val1);
12665 {
12666 arg2 = wxString_in_helper(obj1);
12667 if (arg2 == NULL) SWIG_fail;
12668 temp2 = true;
12669 }
12670 {
12671 PyThreadState* __tstate = wxPyBeginAllowThreads();
12672 wxPyLogGeneric(arg1,(wxString const &)*arg2);
12673 wxPyEndAllowThreads(__tstate);
12674 if (PyErr_Occurred()) SWIG_fail;
12675 }
12676 resultobj = SWIG_Py_Void();
12677 {
12678 if (temp2)
12679 delete arg2;
12680 }
12681 return resultobj;
12682 fail:
12683 {
12684 if (temp2)
12685 delete arg2;
12686 }
12687 return NULL;
12688 }
12689
12690
12691 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
12692 PyObject *resultobj = 0;
12693 unsigned long arg1 ;
12694 wxString *arg2 = 0 ;
12695 unsigned long val1 ;
12696 int ecode1 = 0 ;
12697 bool temp2 = false ;
12698
12699 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
12700 ecode1 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val1);
12701 if (!SWIG_IsOK(ecode1)) {
12702 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogTrace" "', expected argument " "1"" of type '" "unsigned long""'");
12703 }
12704 arg1 = static_cast< unsigned long >(val1);
12705 {
12706 arg2 = wxString_in_helper(swig_obj[1]);
12707 if (arg2 == NULL) SWIG_fail;
12708 temp2 = true;
12709 }
12710 {
12711 PyThreadState* __tstate = wxPyBeginAllowThreads();
12712 wxPyLogTrace(arg1,(wxString const &)*arg2);
12713 wxPyEndAllowThreads(__tstate);
12714 if (PyErr_Occurred()) SWIG_fail;
12715 }
12716 resultobj = SWIG_Py_Void();
12717 {
12718 if (temp2)
12719 delete arg2;
12720 }
12721 return resultobj;
12722 fail:
12723 {
12724 if (temp2)
12725 delete arg2;
12726 }
12727 return NULL;
12728 }
12729
12730
12731 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
12732 PyObject *resultobj = 0;
12733 wxString *arg1 = 0 ;
12734 wxString *arg2 = 0 ;
12735 bool temp1 = false ;
12736 bool temp2 = false ;
12737
12738 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
12739 {
12740 arg1 = wxString_in_helper(swig_obj[0]);
12741 if (arg1 == NULL) SWIG_fail;
12742 temp1 = true;
12743 }
12744 {
12745 arg2 = wxString_in_helper(swig_obj[1]);
12746 if (arg2 == NULL) SWIG_fail;
12747 temp2 = true;
12748 }
12749 {
12750 PyThreadState* __tstate = wxPyBeginAllowThreads();
12751 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
12752 wxPyEndAllowThreads(__tstate);
12753 if (PyErr_Occurred()) SWIG_fail;
12754 }
12755 resultobj = SWIG_Py_Void();
12756 {
12757 if (temp1)
12758 delete arg1;
12759 }
12760 {
12761 if (temp2)
12762 delete arg2;
12763 }
12764 return resultobj;
12765 fail:
12766 {
12767 if (temp1)
12768 delete arg1;
12769 }
12770 {
12771 if (temp2)
12772 delete arg2;
12773 }
12774 return NULL;
12775 }
12776
12777
12778 SWIGINTERN PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
12779 int argc;
12780 PyObject *argv[3];
12781
12782 if (!(argc = SWIG_Python_UnpackTuple(args,"LogTrace",0,2,argv))) SWIG_fail;
12783 --argc;
12784 if (argc == 2) {
12785 int _v = 0;
12786 {
12787 {
12788 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
12789 }
12790 }
12791 if (!_v) goto check_1;
12792 return _wrap_LogTrace__SWIG_1(self, argc, argv);
12793 }
12794 check_1:
12795
12796 if (argc == 2) {
12797 return _wrap_LogTrace__SWIG_0(self, argc, argv);
12798 }
12799
12800 fail:
12801 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
12802 return NULL;
12803 }
12804
12805
12806 SWIGINTERN PyObject *_wrap_SafeShowMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12807 PyObject *resultobj = 0;
12808 wxString *arg1 = 0 ;
12809 wxString *arg2 = 0 ;
12810 bool temp1 = false ;
12811 bool temp2 = false ;
12812 PyObject * obj0 = 0 ;
12813 PyObject * obj1 = 0 ;
12814 char * kwnames[] = {
12815 (char *) "title",(char *) "text", NULL
12816 };
12817
12818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) SWIG_fail;
12819 {
12820 arg1 = wxString_in_helper(obj0);
12821 if (arg1 == NULL) SWIG_fail;
12822 temp1 = true;
12823 }
12824 {
12825 arg2 = wxString_in_helper(obj1);
12826 if (arg2 == NULL) SWIG_fail;
12827 temp2 = true;
12828 }
12829 {
12830 PyThreadState* __tstate = wxPyBeginAllowThreads();
12831 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
12832 wxPyEndAllowThreads(__tstate);
12833 if (PyErr_Occurred()) SWIG_fail;
12834 }
12835 resultobj = SWIG_Py_Void();
12836 {
12837 if (temp1)
12838 delete arg1;
12839 }
12840 {
12841 if (temp2)
12842 delete arg2;
12843 }
12844 return resultobj;
12845 fail:
12846 {
12847 if (temp1)
12848 delete arg1;
12849 }
12850 {
12851 if (temp2)
12852 delete arg2;
12853 }
12854 return NULL;
12855 }
12856
12857
12858 SWIGINTERN PyObject *_wrap_new_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12859 PyObject *resultobj = 0;
12860 wxLogNull *result = 0 ;
12861
12862 if (!SWIG_Python_UnpackTuple(args,"new_LogNull",0,0,0)) SWIG_fail;
12863 {
12864 PyThreadState* __tstate = wxPyBeginAllowThreads();
12865 result = (wxLogNull *)new wxLogNull();
12866 wxPyEndAllowThreads(__tstate);
12867 if (PyErr_Occurred()) SWIG_fail;
12868 }
12869 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogNull, SWIG_POINTER_NEW | 0 );
12870 return resultobj;
12871 fail:
12872 return NULL;
12873 }
12874
12875
12876 SWIGINTERN PyObject *_wrap_delete_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12877 PyObject *resultobj = 0;
12878 wxLogNull *arg1 = (wxLogNull *) 0 ;
12879 void *argp1 = 0 ;
12880 int res1 = 0 ;
12881 PyObject *swig_obj[1] ;
12882
12883 if (!args) SWIG_fail;
12884 swig_obj[0] = args;
12885 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogNull, SWIG_POINTER_DISOWN | 0 );
12886 if (!SWIG_IsOK(res1)) {
12887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LogNull" "', expected argument " "1"" of type '" "wxLogNull *""'");
12888 }
12889 arg1 = reinterpret_cast< wxLogNull * >(argp1);
12890 {
12891 PyThreadState* __tstate = wxPyBeginAllowThreads();
12892 delete arg1;
12893
12894 wxPyEndAllowThreads(__tstate);
12895 if (PyErr_Occurred()) SWIG_fail;
12896 }
12897 resultobj = SWIG_Py_Void();
12898 return resultobj;
12899 fail:
12900 return NULL;
12901 }
12902
12903
12904 SWIGINTERN PyObject *LogNull_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12905 PyObject *obj;
12906 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12907 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogNull, SWIG_NewClientData(obj));
12908 return SWIG_Py_Void();
12909 }
12910
12911 SWIGINTERN PyObject *LogNull_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12912 return SWIG_Python_InitShadowInstance(args);
12913 }
12914
12915 SWIGINTERN PyObject *_wrap_new_PyLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12916 PyObject *resultobj = 0;
12917 wxPyLog *result = 0 ;
12918
12919 if (!SWIG_Python_UnpackTuple(args,"new_PyLog",0,0,0)) SWIG_fail;
12920 {
12921 PyThreadState* __tstate = wxPyBeginAllowThreads();
12922 result = (wxPyLog *)new wxPyLog();
12923 wxPyEndAllowThreads(__tstate);
12924 if (PyErr_Occurred()) SWIG_fail;
12925 }
12926 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyLog, SWIG_POINTER_NEW | 0 );
12927 return resultobj;
12928 fail:
12929 return NULL;
12930 }
12931
12932
12933 SWIGINTERN PyObject *_wrap_PyLog__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12934 PyObject *resultobj = 0;
12935 wxPyLog *arg1 = (wxPyLog *) 0 ;
12936 PyObject *arg2 = (PyObject *) 0 ;
12937 PyObject *arg3 = (PyObject *) 0 ;
12938 void *argp1 = 0 ;
12939 int res1 = 0 ;
12940 PyObject * obj0 = 0 ;
12941 PyObject * obj1 = 0 ;
12942 PyObject * obj2 = 0 ;
12943 char * kwnames[] = {
12944 (char *) "self",(char *) "self",(char *) "_class", NULL
12945 };
12946
12947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12948 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyLog, 0 | 0 );
12949 if (!SWIG_IsOK(res1)) {
12950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyLog__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyLog *""'");
12951 }
12952 arg1 = reinterpret_cast< wxPyLog * >(argp1);
12953 arg2 = obj1;
12954 arg3 = obj2;
12955 {
12956 PyThreadState* __tstate = wxPyBeginAllowThreads();
12957 (arg1)->_setCallbackInfo(arg2,arg3);
12958 wxPyEndAllowThreads(__tstate);
12959 if (PyErr_Occurred()) SWIG_fail;
12960 }
12961 resultobj = SWIG_Py_Void();
12962 return resultobj;
12963 fail:
12964 return NULL;
12965 }
12966
12967
12968 SWIGINTERN PyObject *PyLog_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12969 PyObject *obj;
12970 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12971 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyLog, SWIG_NewClientData(obj));
12972 return SWIG_Py_Void();
12973 }
12974
12975 SWIGINTERN PyObject *PyLog_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12976 return SWIG_Python_InitShadowInstance(args);
12977 }
12978
12979 SWIGINTERN PyObject *_wrap_Process_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12980 PyObject *resultobj = 0;
12981 int arg1 ;
12982 wxSignal arg2 = (wxSignal) wxSIGTERM ;
12983 int arg3 = (int) wxKILL_NOCHILDREN ;
12984 wxKillError result;
12985 int val1 ;
12986 int ecode1 = 0 ;
12987 int val2 ;
12988 int ecode2 = 0 ;
12989 int val3 ;
12990 int ecode3 = 0 ;
12991 PyObject * obj0 = 0 ;
12992 PyObject * obj1 = 0 ;
12993 PyObject * obj2 = 0 ;
12994 char * kwnames[] = {
12995 (char *) "pid",(char *) "sig",(char *) "flags", NULL
12996 };
12997
12998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12999 ecode1 = SWIG_AsVal_int(obj0, &val1);
13000 if (!SWIG_IsOK(ecode1)) {
13001 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Kill" "', expected argument " "1"" of type '" "int""'");
13002 }
13003 arg1 = static_cast< int >(val1);
13004 if (obj1) {
13005 ecode2 = SWIG_AsVal_int(obj1, &val2);
13006 if (!SWIG_IsOK(ecode2)) {
13007 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Kill" "', expected argument " "2"" of type '" "wxSignal""'");
13008 }
13009 arg2 = static_cast< wxSignal >(val2);
13010 }
13011 if (obj2) {
13012 ecode3 = SWIG_AsVal_int(obj2, &val3);
13013 if (!SWIG_IsOK(ecode3)) {
13014 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_Kill" "', expected argument " "3"" of type '" "int""'");
13015 }
13016 arg3 = static_cast< int >(val3);
13017 }
13018 {
13019 PyThreadState* __tstate = wxPyBeginAllowThreads();
13020 result = (wxKillError)wxPyProcess::Kill(arg1,arg2,arg3);
13021 wxPyEndAllowThreads(__tstate);
13022 if (PyErr_Occurred()) SWIG_fail;
13023 }
13024 resultobj = SWIG_From_int(static_cast< int >(result));
13025 return resultobj;
13026 fail:
13027 return NULL;
13028 }
13029
13030
13031 SWIGINTERN PyObject *_wrap_Process_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13032 PyObject *resultobj = 0;
13033 int arg1 ;
13034 bool result;
13035 int val1 ;
13036 int ecode1 = 0 ;
13037 PyObject * obj0 = 0 ;
13038 char * kwnames[] = {
13039 (char *) "pid", NULL
13040 };
13041
13042 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) SWIG_fail;
13043 ecode1 = SWIG_AsVal_int(obj0, &val1);
13044 if (!SWIG_IsOK(ecode1)) {
13045 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Exists" "', expected argument " "1"" of type '" "int""'");
13046 }
13047 arg1 = static_cast< int >(val1);
13048 {
13049 PyThreadState* __tstate = wxPyBeginAllowThreads();
13050 result = (bool)wxPyProcess::Exists(arg1);
13051 wxPyEndAllowThreads(__tstate);
13052 if (PyErr_Occurred()) SWIG_fail;
13053 }
13054 {
13055 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13056 }
13057 return resultobj;
13058 fail:
13059 return NULL;
13060 }
13061
13062
13063 SWIGINTERN PyObject *_wrap_Process_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13064 PyObject *resultobj = 0;
13065 wxString *arg1 = 0 ;
13066 int arg2 = (int) wxEXEC_ASYNC ;
13067 wxPyProcess *result = 0 ;
13068 bool temp1 = false ;
13069 int val2 ;
13070 int ecode2 = 0 ;
13071 PyObject * obj0 = 0 ;
13072 PyObject * obj1 = 0 ;
13073 char * kwnames[] = {
13074 (char *) "cmd",(char *) "flags", NULL
13075 };
13076
13077 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) SWIG_fail;
13078 {
13079 arg1 = wxString_in_helper(obj0);
13080 if (arg1 == NULL) SWIG_fail;
13081 temp1 = true;
13082 }
13083 if (obj1) {
13084 ecode2 = SWIG_AsVal_int(obj1, &val2);
13085 if (!SWIG_IsOK(ecode2)) {
13086 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Open" "', expected argument " "2"" of type '" "int""'");
13087 }
13088 arg2 = static_cast< int >(val2);
13089 }
13090 {
13091 PyThreadState* __tstate = wxPyBeginAllowThreads();
13092 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
13093 wxPyEndAllowThreads(__tstate);
13094 if (PyErr_Occurred()) SWIG_fail;
13095 }
13096 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, 0 | 0 );
13097 {
13098 if (temp1)
13099 delete arg1;
13100 }
13101 return resultobj;
13102 fail:
13103 {
13104 if (temp1)
13105 delete arg1;
13106 }
13107 return NULL;
13108 }
13109
13110
13111 SWIGINTERN PyObject *_wrap_new_Process(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13112 PyObject *resultobj = 0;
13113 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
13114 int arg2 = (int) -1 ;
13115 wxPyProcess *result = 0 ;
13116 void *argp1 = 0 ;
13117 int res1 = 0 ;
13118 int val2 ;
13119 int ecode2 = 0 ;
13120 PyObject * obj0 = 0 ;
13121 PyObject * obj1 = 0 ;
13122 char * kwnames[] = {
13123 (char *) "parent",(char *) "id", NULL
13124 };
13125
13126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) SWIG_fail;
13127 if (obj0) {
13128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
13129 if (!SWIG_IsOK(res1)) {
13130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Process" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
13131 }
13132 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
13133 }
13134 if (obj1) {
13135 ecode2 = SWIG_AsVal_int(obj1, &val2);
13136 if (!SWIG_IsOK(ecode2)) {
13137 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Process" "', expected argument " "2"" of type '" "int""'");
13138 }
13139 arg2 = static_cast< int >(val2);
13140 }
13141 {
13142 PyThreadState* __tstate = wxPyBeginAllowThreads();
13143 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
13144 wxPyEndAllowThreads(__tstate);
13145 if (PyErr_Occurred()) SWIG_fail;
13146 }
13147 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, SWIG_POINTER_NEW | 0 );
13148 return resultobj;
13149 fail:
13150 return NULL;
13151 }
13152
13153
13154 SWIGINTERN PyObject *_wrap_Process__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13155 PyObject *resultobj = 0;
13156 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13157 PyObject *arg2 = (PyObject *) 0 ;
13158 PyObject *arg3 = (PyObject *) 0 ;
13159 void *argp1 = 0 ;
13160 int res1 = 0 ;
13161 PyObject * obj0 = 0 ;
13162 PyObject * obj1 = 0 ;
13163 PyObject * obj2 = 0 ;
13164 char * kwnames[] = {
13165 (char *) "self",(char *) "self",(char *) "_class", NULL
13166 };
13167
13168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13170 if (!SWIG_IsOK(res1)) {
13171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13172 }
13173 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13174 arg2 = obj1;
13175 arg3 = obj2;
13176 {
13177 PyThreadState* __tstate = wxPyBeginAllowThreads();
13178 (arg1)->_setCallbackInfo(arg2,arg3);
13179 wxPyEndAllowThreads(__tstate);
13180 if (PyErr_Occurred()) SWIG_fail;
13181 }
13182 resultobj = SWIG_Py_Void();
13183 return resultobj;
13184 fail:
13185 return NULL;
13186 }
13187
13188
13189 SWIGINTERN PyObject *_wrap_Process_OnTerminate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13190 PyObject *resultobj = 0;
13191 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13192 int arg2 ;
13193 int arg3 ;
13194 void *argp1 = 0 ;
13195 int res1 = 0 ;
13196 int val2 ;
13197 int ecode2 = 0 ;
13198 int val3 ;
13199 int ecode3 = 0 ;
13200 PyObject * obj0 = 0 ;
13201 PyObject * obj1 = 0 ;
13202 PyObject * obj2 = 0 ;
13203 char * kwnames[] = {
13204 (char *) "self",(char *) "pid",(char *) "status", NULL
13205 };
13206
13207 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_OnTerminate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13208 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13209 if (!SWIG_IsOK(res1)) {
13210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_OnTerminate" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13211 }
13212 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13213 ecode2 = SWIG_AsVal_int(obj1, &val2);
13214 if (!SWIG_IsOK(ecode2)) {
13215 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_OnTerminate" "', expected argument " "2"" of type '" "int""'");
13216 }
13217 arg2 = static_cast< int >(val2);
13218 ecode3 = SWIG_AsVal_int(obj2, &val3);
13219 if (!SWIG_IsOK(ecode3)) {
13220 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_OnTerminate" "', expected argument " "3"" of type '" "int""'");
13221 }
13222 arg3 = static_cast< int >(val3);
13223 {
13224 PyThreadState* __tstate = wxPyBeginAllowThreads();
13225 (arg1)->OnTerminate(arg2,arg3);
13226 wxPyEndAllowThreads(__tstate);
13227 if (PyErr_Occurred()) SWIG_fail;
13228 }
13229 resultobj = SWIG_Py_Void();
13230 return resultobj;
13231 fail:
13232 return NULL;
13233 }
13234
13235
13236 SWIGINTERN PyObject *_wrap_Process_Redirect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13237 PyObject *resultobj = 0;
13238 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13239 void *argp1 = 0 ;
13240 int res1 = 0 ;
13241 PyObject *swig_obj[1] ;
13242
13243 if (!args) SWIG_fail;
13244 swig_obj[0] = args;
13245 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13246 if (!SWIG_IsOK(res1)) {
13247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Redirect" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13248 }
13249 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13250 {
13251 PyThreadState* __tstate = wxPyBeginAllowThreads();
13252 (arg1)->Redirect();
13253 wxPyEndAllowThreads(__tstate);
13254 if (PyErr_Occurred()) SWIG_fail;
13255 }
13256 resultobj = SWIG_Py_Void();
13257 return resultobj;
13258 fail:
13259 return NULL;
13260 }
13261
13262
13263 SWIGINTERN PyObject *_wrap_Process_IsRedirected(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13264 PyObject *resultobj = 0;
13265 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13266 bool result;
13267 void *argp1 = 0 ;
13268 int res1 = 0 ;
13269 PyObject *swig_obj[1] ;
13270
13271 if (!args) SWIG_fail;
13272 swig_obj[0] = args;
13273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13274 if (!SWIG_IsOK(res1)) {
13275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsRedirected" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13276 }
13277 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13278 {
13279 PyThreadState* __tstate = wxPyBeginAllowThreads();
13280 result = (bool)(arg1)->IsRedirected();
13281 wxPyEndAllowThreads(__tstate);
13282 if (PyErr_Occurred()) SWIG_fail;
13283 }
13284 {
13285 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13286 }
13287 return resultobj;
13288 fail:
13289 return NULL;
13290 }
13291
13292
13293 SWIGINTERN PyObject *_wrap_Process_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13294 PyObject *resultobj = 0;
13295 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13296 void *argp1 = 0 ;
13297 int res1 = 0 ;
13298 PyObject *swig_obj[1] ;
13299
13300 if (!args) SWIG_fail;
13301 swig_obj[0] = args;
13302 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13303 if (!SWIG_IsOK(res1)) {
13304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Detach" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13305 }
13306 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13307 {
13308 PyThreadState* __tstate = wxPyBeginAllowThreads();
13309 (arg1)->Detach();
13310 wxPyEndAllowThreads(__tstate);
13311 if (PyErr_Occurred()) SWIG_fail;
13312 }
13313 resultobj = SWIG_Py_Void();
13314 return resultobj;
13315 fail:
13316 return NULL;
13317 }
13318
13319
13320 SWIGINTERN PyObject *_wrap_Process_GetInputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13321 PyObject *resultobj = 0;
13322 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13323 wxInputStream *result = 0 ;
13324 void *argp1 = 0 ;
13325 int res1 = 0 ;
13326 PyObject *swig_obj[1] ;
13327
13328 if (!args) SWIG_fail;
13329 swig_obj[0] = args;
13330 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13331 if (!SWIG_IsOK(res1)) {
13332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetInputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13333 }
13334 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13335 {
13336 PyThreadState* __tstate = wxPyBeginAllowThreads();
13337 result = (wxInputStream *)(arg1)->GetInputStream();
13338 wxPyEndAllowThreads(__tstate);
13339 if (PyErr_Occurred()) SWIG_fail;
13340 }
13341 {
13342 wxPyInputStream * _ptr = NULL;
13343
13344 if (result) {
13345 _ptr = new wxPyInputStream(result);
13346 }
13347 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
13348 }
13349 return resultobj;
13350 fail:
13351 return NULL;
13352 }
13353
13354
13355 SWIGINTERN PyObject *_wrap_Process_GetErrorStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13356 PyObject *resultobj = 0;
13357 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13358 wxInputStream *result = 0 ;
13359 void *argp1 = 0 ;
13360 int res1 = 0 ;
13361 PyObject *swig_obj[1] ;
13362
13363 if (!args) SWIG_fail;
13364 swig_obj[0] = args;
13365 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13366 if (!SWIG_IsOK(res1)) {
13367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetErrorStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13368 }
13369 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13370 {
13371 PyThreadState* __tstate = wxPyBeginAllowThreads();
13372 result = (wxInputStream *)(arg1)->GetErrorStream();
13373 wxPyEndAllowThreads(__tstate);
13374 if (PyErr_Occurred()) SWIG_fail;
13375 }
13376 {
13377 wxPyInputStream * _ptr = NULL;
13378
13379 if (result) {
13380 _ptr = new wxPyInputStream(result);
13381 }
13382 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
13383 }
13384 return resultobj;
13385 fail:
13386 return NULL;
13387 }
13388
13389
13390 SWIGINTERN PyObject *_wrap_Process_GetOutputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13391 PyObject *resultobj = 0;
13392 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13393 wxOutputStream *result = 0 ;
13394 void *argp1 = 0 ;
13395 int res1 = 0 ;
13396 PyObject *swig_obj[1] ;
13397
13398 if (!args) SWIG_fail;
13399 swig_obj[0] = args;
13400 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13401 if (!SWIG_IsOK(res1)) {
13402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetOutputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13403 }
13404 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13405 {
13406 PyThreadState* __tstate = wxPyBeginAllowThreads();
13407 result = (wxOutputStream *)(arg1)->GetOutputStream();
13408 wxPyEndAllowThreads(__tstate);
13409 if (PyErr_Occurred()) SWIG_fail;
13410 }
13411 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxOutputStream, 0 | 0 );
13412 return resultobj;
13413 fail:
13414 return NULL;
13415 }
13416
13417
13418 SWIGINTERN PyObject *_wrap_Process_CloseOutput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13419 PyObject *resultobj = 0;
13420 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13421 void *argp1 = 0 ;
13422 int res1 = 0 ;
13423 PyObject *swig_obj[1] ;
13424
13425 if (!args) SWIG_fail;
13426 swig_obj[0] = args;
13427 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13428 if (!SWIG_IsOK(res1)) {
13429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_CloseOutput" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13430 }
13431 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13432 {
13433 PyThreadState* __tstate = wxPyBeginAllowThreads();
13434 (arg1)->CloseOutput();
13435 wxPyEndAllowThreads(__tstate);
13436 if (PyErr_Occurred()) SWIG_fail;
13437 }
13438 resultobj = SWIG_Py_Void();
13439 return resultobj;
13440 fail:
13441 return NULL;
13442 }
13443
13444
13445 SWIGINTERN PyObject *_wrap_Process_IsInputOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13446 PyObject *resultobj = 0;
13447 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13448 bool result;
13449 void *argp1 = 0 ;
13450 int res1 = 0 ;
13451 PyObject *swig_obj[1] ;
13452
13453 if (!args) SWIG_fail;
13454 swig_obj[0] = args;
13455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13456 if (!SWIG_IsOK(res1)) {
13457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputOpened" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
13458 }
13459 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13460 {
13461 PyThreadState* __tstate = wxPyBeginAllowThreads();
13462 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
13463 wxPyEndAllowThreads(__tstate);
13464 if (PyErr_Occurred()) SWIG_fail;
13465 }
13466 {
13467 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13468 }
13469 return resultobj;
13470 fail:
13471 return NULL;
13472 }
13473
13474
13475 SWIGINTERN PyObject *_wrap_Process_IsInputAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13476 PyObject *resultobj = 0;
13477 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13478 bool result;
13479 void *argp1 = 0 ;
13480 int res1 = 0 ;
13481 PyObject *swig_obj[1] ;
13482
13483 if (!args) SWIG_fail;
13484 swig_obj[0] = args;
13485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13486 if (!SWIG_IsOK(res1)) {
13487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
13488 }
13489 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13490 {
13491 PyThreadState* __tstate = wxPyBeginAllowThreads();
13492 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
13493 wxPyEndAllowThreads(__tstate);
13494 if (PyErr_Occurred()) SWIG_fail;
13495 }
13496 {
13497 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13498 }
13499 return resultobj;
13500 fail:
13501 return NULL;
13502 }
13503
13504
13505 SWIGINTERN PyObject *_wrap_Process_IsErrorAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13506 PyObject *resultobj = 0;
13507 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13508 bool result;
13509 void *argp1 = 0 ;
13510 int res1 = 0 ;
13511 PyObject *swig_obj[1] ;
13512
13513 if (!args) SWIG_fail;
13514 swig_obj[0] = args;
13515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13516 if (!SWIG_IsOK(res1)) {
13517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsErrorAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
13518 }
13519 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13520 {
13521 PyThreadState* __tstate = wxPyBeginAllowThreads();
13522 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
13523 wxPyEndAllowThreads(__tstate);
13524 if (PyErr_Occurred()) SWIG_fail;
13525 }
13526 {
13527 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13528 }
13529 return resultobj;
13530 fail:
13531 return NULL;
13532 }
13533
13534
13535 SWIGINTERN PyObject *Process_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13536 PyObject *obj;
13537 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13538 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyProcess, SWIG_NewClientData(obj));
13539 return SWIG_Py_Void();
13540 }
13541
13542 SWIGINTERN PyObject *Process_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13543 return SWIG_Python_InitShadowInstance(args);
13544 }
13545
13546 SWIGINTERN PyObject *_wrap_new_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13547 PyObject *resultobj = 0;
13548 int arg1 = (int) 0 ;
13549 int arg2 = (int) 0 ;
13550 int arg3 = (int) 0 ;
13551 wxProcessEvent *result = 0 ;
13552 int val1 ;
13553 int ecode1 = 0 ;
13554 int val2 ;
13555 int ecode2 = 0 ;
13556 int val3 ;
13557 int ecode3 = 0 ;
13558 PyObject * obj0 = 0 ;
13559 PyObject * obj1 = 0 ;
13560 PyObject * obj2 = 0 ;
13561 char * kwnames[] = {
13562 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
13563 };
13564
13565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13566 if (obj0) {
13567 ecode1 = SWIG_AsVal_int(obj0, &val1);
13568 if (!SWIG_IsOK(ecode1)) {
13569 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ProcessEvent" "', expected argument " "1"" of type '" "int""'");
13570 }
13571 arg1 = static_cast< int >(val1);
13572 }
13573 if (obj1) {
13574 ecode2 = SWIG_AsVal_int(obj1, &val2);
13575 if (!SWIG_IsOK(ecode2)) {
13576 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ProcessEvent" "', expected argument " "2"" of type '" "int""'");
13577 }
13578 arg2 = static_cast< int >(val2);
13579 }
13580 if (obj2) {
13581 ecode3 = SWIG_AsVal_int(obj2, &val3);
13582 if (!SWIG_IsOK(ecode3)) {
13583 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ProcessEvent" "', expected argument " "3"" of type '" "int""'");
13584 }
13585 arg3 = static_cast< int >(val3);
13586 }
13587 {
13588 PyThreadState* __tstate = wxPyBeginAllowThreads();
13589 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
13590 wxPyEndAllowThreads(__tstate);
13591 if (PyErr_Occurred()) SWIG_fail;
13592 }
13593 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_NEW | 0 );
13594 return resultobj;
13595 fail:
13596 return NULL;
13597 }
13598
13599
13600 SWIGINTERN PyObject *_wrap_ProcessEvent_GetPid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13601 PyObject *resultobj = 0;
13602 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13603 int result;
13604 void *argp1 = 0 ;
13605 int res1 = 0 ;
13606 PyObject *swig_obj[1] ;
13607
13608 if (!args) SWIG_fail;
13609 swig_obj[0] = args;
13610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13611 if (!SWIG_IsOK(res1)) {
13612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetPid" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13613 }
13614 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13615 {
13616 PyThreadState* __tstate = wxPyBeginAllowThreads();
13617 result = (int)(arg1)->GetPid();
13618 wxPyEndAllowThreads(__tstate);
13619 if (PyErr_Occurred()) SWIG_fail;
13620 }
13621 resultobj = SWIG_From_int(static_cast< int >(result));
13622 return resultobj;
13623 fail:
13624 return NULL;
13625 }
13626
13627
13628 SWIGINTERN PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13629 PyObject *resultobj = 0;
13630 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13631 int result;
13632 void *argp1 = 0 ;
13633 int res1 = 0 ;
13634 PyObject *swig_obj[1] ;
13635
13636 if (!args) SWIG_fail;
13637 swig_obj[0] = args;
13638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13639 if (!SWIG_IsOK(res1)) {
13640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetExitCode" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13641 }
13642 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13643 {
13644 PyThreadState* __tstate = wxPyBeginAllowThreads();
13645 result = (int)(arg1)->GetExitCode();
13646 wxPyEndAllowThreads(__tstate);
13647 if (PyErr_Occurred()) SWIG_fail;
13648 }
13649 resultobj = SWIG_From_int(static_cast< int >(result));
13650 return resultobj;
13651 fail:
13652 return NULL;
13653 }
13654
13655
13656 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13657 PyObject *resultobj = 0;
13658 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13659 int arg2 ;
13660 void *argp1 = 0 ;
13661 int res1 = 0 ;
13662 int val2 ;
13663 int ecode2 = 0 ;
13664 PyObject *swig_obj[2] ;
13665
13666 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_pid_set",2,2,swig_obj)) SWIG_fail;
13667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13668 if (!SWIG_IsOK(res1)) {
13669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13670 }
13671 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13672 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
13673 if (!SWIG_IsOK(ecode2)) {
13674 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "2"" of type '" "int""'");
13675 }
13676 arg2 = static_cast< int >(val2);
13677 if (arg1) (arg1)->m_pid = arg2;
13678
13679 resultobj = SWIG_Py_Void();
13680 return resultobj;
13681 fail:
13682 return NULL;
13683 }
13684
13685
13686 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13687 PyObject *resultobj = 0;
13688 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13689 int result;
13690 void *argp1 = 0 ;
13691 int res1 = 0 ;
13692 PyObject *swig_obj[1] ;
13693
13694 if (!args) SWIG_fail;
13695 swig_obj[0] = args;
13696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13697 if (!SWIG_IsOK(res1)) {
13698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13699 }
13700 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13701 result = (int) ((arg1)->m_pid);
13702 resultobj = SWIG_From_int(static_cast< int >(result));
13703 return resultobj;
13704 fail:
13705 return NULL;
13706 }
13707
13708
13709 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13710 PyObject *resultobj = 0;
13711 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13712 int arg2 ;
13713 void *argp1 = 0 ;
13714 int res1 = 0 ;
13715 int val2 ;
13716 int ecode2 = 0 ;
13717 PyObject *swig_obj[2] ;
13718
13719 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_exitcode_set",2,2,swig_obj)) SWIG_fail;
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_exitcode_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13723 }
13724 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13725 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
13726 if (!SWIG_IsOK(ecode2)) {
13727 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "2"" of type '" "int""'");
13728 }
13729 arg2 = static_cast< int >(val2);
13730 if (arg1) (arg1)->m_exitcode = arg2;
13731
13732 resultobj = SWIG_Py_Void();
13733 return resultobj;
13734 fail:
13735 return NULL;
13736 }
13737
13738
13739 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13740 PyObject *resultobj = 0;
13741 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13742 int result;
13743 void *argp1 = 0 ;
13744 int res1 = 0 ;
13745 PyObject *swig_obj[1] ;
13746
13747 if (!args) SWIG_fail;
13748 swig_obj[0] = args;
13749 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13750 if (!SWIG_IsOK(res1)) {
13751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13752 }
13753 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13754 result = (int) ((arg1)->m_exitcode);
13755 resultobj = SWIG_From_int(static_cast< int >(result));
13756 return resultobj;
13757 fail:
13758 return NULL;
13759 }
13760
13761
13762 SWIGINTERN PyObject *ProcessEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13763 PyObject *obj;
13764 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13765 SWIG_TypeNewClientData(SWIGTYPE_p_wxProcessEvent, SWIG_NewClientData(obj));
13766 return SWIG_Py_Void();
13767 }
13768
13769 SWIGINTERN PyObject *ProcessEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13770 return SWIG_Python_InitShadowInstance(args);
13771 }
13772
13773 SWIGINTERN PyObject *_wrap_Execute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13774 PyObject *resultobj = 0;
13775 wxString *arg1 = 0 ;
13776 int arg2 = (int) wxEXEC_ASYNC ;
13777 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
13778 long result;
13779 bool temp1 = false ;
13780 int val2 ;
13781 int ecode2 = 0 ;
13782 void *argp3 = 0 ;
13783 int res3 = 0 ;
13784 PyObject * obj0 = 0 ;
13785 PyObject * obj1 = 0 ;
13786 PyObject * obj2 = 0 ;
13787 char * kwnames[] = {
13788 (char *) "command",(char *) "flags",(char *) "process", NULL
13789 };
13790
13791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13792 {
13793 arg1 = wxString_in_helper(obj0);
13794 if (arg1 == NULL) SWIG_fail;
13795 temp1 = true;
13796 }
13797 if (obj1) {
13798 ecode2 = SWIG_AsVal_int(obj1, &val2);
13799 if (!SWIG_IsOK(ecode2)) {
13800 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Execute" "', expected argument " "2"" of type '" "int""'");
13801 }
13802 arg2 = static_cast< int >(val2);
13803 }
13804 if (obj2) {
13805 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13806 if (!SWIG_IsOK(res3)) {
13807 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Execute" "', expected argument " "3"" of type '" "wxPyProcess *""'");
13808 }
13809 arg3 = reinterpret_cast< wxPyProcess * >(argp3);
13810 }
13811 {
13812 if (!wxPyCheckForApp()) SWIG_fail;
13813 PyThreadState* __tstate = wxPyBeginAllowThreads();
13814 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
13815 wxPyEndAllowThreads(__tstate);
13816 if (PyErr_Occurred()) SWIG_fail;
13817 }
13818 resultobj = SWIG_From_long(static_cast< long >(result));
13819 {
13820 if (temp1)
13821 delete arg1;
13822 }
13823 return resultobj;
13824 fail:
13825 {
13826 if (temp1)
13827 delete arg1;
13828 }
13829 return NULL;
13830 }
13831
13832
13833 SWIGINTERN PyObject *_wrap_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13834 PyObject *resultobj = 0;
13835 long arg1 ;
13836 wxSignal arg2 = (wxSignal) wxSIGTERM ;
13837 wxKillError *arg3 = (wxKillError *) 0 ;
13838 int arg4 = (int) wxKILL_NOCHILDREN ;
13839 int result;
13840 long val1 ;
13841 int ecode1 = 0 ;
13842 int val2 ;
13843 int ecode2 = 0 ;
13844 wxKillError temp3 ;
13845 int val4 ;
13846 int ecode4 = 0 ;
13847 PyObject * obj0 = 0 ;
13848 PyObject * obj1 = 0 ;
13849 PyObject * obj2 = 0 ;
13850 char * kwnames[] = {
13851 (char *) "pid",(char *) "sig",(char *) "flags", NULL
13852 };
13853
13854 {
13855 arg3 = &temp3;
13856 }
13857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13858 ecode1 = SWIG_AsVal_long(obj0, &val1);
13859 if (!SWIG_IsOK(ecode1)) {
13860 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Kill" "', expected argument " "1"" of type '" "long""'");
13861 }
13862 arg1 = static_cast< long >(val1);
13863 if (obj1) {
13864 ecode2 = SWIG_AsVal_int(obj1, &val2);
13865 if (!SWIG_IsOK(ecode2)) {
13866 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Kill" "', expected argument " "2"" of type '" "wxSignal""'");
13867 }
13868 arg2 = static_cast< wxSignal >(val2);
13869 }
13870 if (obj2) {
13871 ecode4 = SWIG_AsVal_int(obj2, &val4);
13872 if (!SWIG_IsOK(ecode4)) {
13873 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Kill" "', expected argument " "4"" of type '" "int""'");
13874 }
13875 arg4 = static_cast< int >(val4);
13876 }
13877 {
13878 PyThreadState* __tstate = wxPyBeginAllowThreads();
13879 result = (int)wxKill(arg1,arg2,arg3,arg4);
13880 wxPyEndAllowThreads(__tstate);
13881 if (PyErr_Occurred()) SWIG_fail;
13882 }
13883 resultobj = SWIG_From_int(static_cast< int >(result));
13884 {
13885 PyObject* o;
13886 o = PyInt_FromLong((long) (*arg3));
13887
13888
13889
13890 resultobj = SWIG_Python_AppendOutput(resultobj, o);
13891
13892 }
13893 return resultobj;
13894 fail:
13895 return NULL;
13896 }
13897
13898
13899 SWIGINTERN PyObject *_wrap_new_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13900 PyObject *resultobj = 0;
13901 int arg1 = (int) wxJOYSTICK1 ;
13902 wxJoystick *result = 0 ;
13903 int val1 ;
13904 int ecode1 = 0 ;
13905 PyObject * obj0 = 0 ;
13906 char * kwnames[] = {
13907 (char *) "joystick", NULL
13908 };
13909
13910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) SWIG_fail;
13911 if (obj0) {
13912 ecode1 = SWIG_AsVal_int(obj0, &val1);
13913 if (!SWIG_IsOK(ecode1)) {
13914 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Joystick" "', expected argument " "1"" of type '" "int""'");
13915 }
13916 arg1 = static_cast< int >(val1);
13917 }
13918 {
13919 if (!wxPyCheckForApp()) SWIG_fail;
13920 PyThreadState* __tstate = wxPyBeginAllowThreads();
13921 result = (wxJoystick *)new wxJoystick(arg1);
13922 wxPyEndAllowThreads(__tstate);
13923 if (PyErr_Occurred()) SWIG_fail;
13924 }
13925 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystick, SWIG_POINTER_NEW | 0 );
13926 return resultobj;
13927 fail:
13928 return NULL;
13929 }
13930
13931
13932 SWIGINTERN PyObject *_wrap_delete_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13933 PyObject *resultobj = 0;
13934 wxJoystick *arg1 = (wxJoystick *) 0 ;
13935 void *argp1 = 0 ;
13936 int res1 = 0 ;
13937 PyObject *swig_obj[1] ;
13938
13939 if (!args) SWIG_fail;
13940 swig_obj[0] = args;
13941 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, SWIG_POINTER_DISOWN | 0 );
13942 if (!SWIG_IsOK(res1)) {
13943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Joystick" "', expected argument " "1"" of type '" "wxJoystick *""'");
13944 }
13945 arg1 = reinterpret_cast< wxJoystick * >(argp1);
13946 {
13947 PyThreadState* __tstate = wxPyBeginAllowThreads();
13948 delete arg1;
13949
13950 wxPyEndAllowThreads(__tstate);
13951 if (PyErr_Occurred()) SWIG_fail;
13952 }
13953 resultobj = SWIG_Py_Void();
13954 return resultobj;
13955 fail:
13956 return NULL;
13957 }
13958
13959
13960 SWIGINTERN PyObject *_wrap_Joystick_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13961 PyObject *resultobj = 0;
13962 wxJoystick *arg1 = (wxJoystick *) 0 ;
13963 wxPoint result;
13964 void *argp1 = 0 ;
13965 int res1 = 0 ;
13966 PyObject *swig_obj[1] ;
13967
13968 if (!args) SWIG_fail;
13969 swig_obj[0] = args;
13970 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
13971 if (!SWIG_IsOK(res1)) {
13972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
13973 }
13974 arg1 = reinterpret_cast< wxJoystick * >(argp1);
13975 {
13976 PyThreadState* __tstate = wxPyBeginAllowThreads();
13977 result = (arg1)->GetPosition();
13978 wxPyEndAllowThreads(__tstate);
13979 if (PyErr_Occurred()) SWIG_fail;
13980 }
13981 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
13982 return resultobj;
13983 fail:
13984 return NULL;
13985 }
13986
13987
13988 SWIGINTERN PyObject *_wrap_Joystick_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13989 PyObject *resultobj = 0;
13990 wxJoystick *arg1 = (wxJoystick *) 0 ;
13991 int result;
13992 void *argp1 = 0 ;
13993 int res1 = 0 ;
13994 PyObject *swig_obj[1] ;
13995
13996 if (!args) SWIG_fail;
13997 swig_obj[0] = args;
13998 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
13999 if (!SWIG_IsOK(res1)) {
14000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14001 }
14002 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14003 {
14004 PyThreadState* __tstate = wxPyBeginAllowThreads();
14005 result = (int)(arg1)->GetZPosition();
14006 wxPyEndAllowThreads(__tstate);
14007 if (PyErr_Occurred()) SWIG_fail;
14008 }
14009 resultobj = SWIG_From_int(static_cast< int >(result));
14010 return resultobj;
14011 fail:
14012 return NULL;
14013 }
14014
14015
14016 SWIGINTERN PyObject *_wrap_Joystick_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14017 PyObject *resultobj = 0;
14018 wxJoystick *arg1 = (wxJoystick *) 0 ;
14019 int result;
14020 void *argp1 = 0 ;
14021 int res1 = 0 ;
14022 PyObject *swig_obj[1] ;
14023
14024 if (!args) SWIG_fail;
14025 swig_obj[0] = args;
14026 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14027 if (!SWIG_IsOK(res1)) {
14028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetButtonState" "', expected argument " "1"" of type '" "wxJoystick *""'");
14029 }
14030 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14031 {
14032 PyThreadState* __tstate = wxPyBeginAllowThreads();
14033 result = (int)(arg1)->GetButtonState();
14034 wxPyEndAllowThreads(__tstate);
14035 if (PyErr_Occurred()) SWIG_fail;
14036 }
14037 resultobj = SWIG_From_int(static_cast< int >(result));
14038 return resultobj;
14039 fail:
14040 return NULL;
14041 }
14042
14043
14044 SWIGINTERN PyObject *_wrap_Joystick_GetPOVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14045 PyObject *resultobj = 0;
14046 wxJoystick *arg1 = (wxJoystick *) 0 ;
14047 int result;
14048 void *argp1 = 0 ;
14049 int res1 = 0 ;
14050 PyObject *swig_obj[1] ;
14051
14052 if (!args) SWIG_fail;
14053 swig_obj[0] = args;
14054 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14055 if (!SWIG_IsOK(res1)) {
14056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14057 }
14058 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14059 {
14060 PyThreadState* __tstate = wxPyBeginAllowThreads();
14061 result = (int)(arg1)->GetPOVPosition();
14062 wxPyEndAllowThreads(__tstate);
14063 if (PyErr_Occurred()) SWIG_fail;
14064 }
14065 resultobj = SWIG_From_int(static_cast< int >(result));
14066 return resultobj;
14067 fail:
14068 return NULL;
14069 }
14070
14071
14072 SWIGINTERN PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14073 PyObject *resultobj = 0;
14074 wxJoystick *arg1 = (wxJoystick *) 0 ;
14075 int result;
14076 void *argp1 = 0 ;
14077 int res1 = 0 ;
14078 PyObject *swig_obj[1] ;
14079
14080 if (!args) SWIG_fail;
14081 swig_obj[0] = args;
14082 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14083 if (!SWIG_IsOK(res1)) {
14084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVCTSPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14085 }
14086 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14087 {
14088 PyThreadState* __tstate = wxPyBeginAllowThreads();
14089 result = (int)(arg1)->GetPOVCTSPosition();
14090 wxPyEndAllowThreads(__tstate);
14091 if (PyErr_Occurred()) SWIG_fail;
14092 }
14093 resultobj = SWIG_From_int(static_cast< int >(result));
14094 return resultobj;
14095 fail:
14096 return NULL;
14097 }
14098
14099
14100 SWIGINTERN PyObject *_wrap_Joystick_GetRudderPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14101 PyObject *resultobj = 0;
14102 wxJoystick *arg1 = (wxJoystick *) 0 ;
14103 int result;
14104 void *argp1 = 0 ;
14105 int res1 = 0 ;
14106 PyObject *swig_obj[1] ;
14107
14108 if (!args) SWIG_fail;
14109 swig_obj[0] = args;
14110 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14111 if (!SWIG_IsOK(res1)) {
14112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14113 }
14114 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14115 {
14116 PyThreadState* __tstate = wxPyBeginAllowThreads();
14117 result = (int)(arg1)->GetRudderPosition();
14118 wxPyEndAllowThreads(__tstate);
14119 if (PyErr_Occurred()) SWIG_fail;
14120 }
14121 resultobj = SWIG_From_int(static_cast< int >(result));
14122 return resultobj;
14123 fail:
14124 return NULL;
14125 }
14126
14127
14128 SWIGINTERN PyObject *_wrap_Joystick_GetUPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14129 PyObject *resultobj = 0;
14130 wxJoystick *arg1 = (wxJoystick *) 0 ;
14131 int result;
14132 void *argp1 = 0 ;
14133 int res1 = 0 ;
14134 PyObject *swig_obj[1] ;
14135
14136 if (!args) SWIG_fail;
14137 swig_obj[0] = args;
14138 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14139 if (!SWIG_IsOK(res1)) {
14140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14141 }
14142 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14143 {
14144 PyThreadState* __tstate = wxPyBeginAllowThreads();
14145 result = (int)(arg1)->GetUPosition();
14146 wxPyEndAllowThreads(__tstate);
14147 if (PyErr_Occurred()) SWIG_fail;
14148 }
14149 resultobj = SWIG_From_int(static_cast< int >(result));
14150 return resultobj;
14151 fail:
14152 return NULL;
14153 }
14154
14155
14156 SWIGINTERN PyObject *_wrap_Joystick_GetVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14157 PyObject *resultobj = 0;
14158 wxJoystick *arg1 = (wxJoystick *) 0 ;
14159 int result;
14160 void *argp1 = 0 ;
14161 int res1 = 0 ;
14162 PyObject *swig_obj[1] ;
14163
14164 if (!args) SWIG_fail;
14165 swig_obj[0] = args;
14166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14167 if (!SWIG_IsOK(res1)) {
14168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14169 }
14170 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14171 {
14172 PyThreadState* __tstate = wxPyBeginAllowThreads();
14173 result = (int)(arg1)->GetVPosition();
14174 wxPyEndAllowThreads(__tstate);
14175 if (PyErr_Occurred()) SWIG_fail;
14176 }
14177 resultobj = SWIG_From_int(static_cast< int >(result));
14178 return resultobj;
14179 fail:
14180 return NULL;
14181 }
14182
14183
14184 SWIGINTERN PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14185 PyObject *resultobj = 0;
14186 wxJoystick *arg1 = (wxJoystick *) 0 ;
14187 int result;
14188 void *argp1 = 0 ;
14189 int res1 = 0 ;
14190 PyObject *swig_obj[1] ;
14191
14192 if (!args) SWIG_fail;
14193 swig_obj[0] = args;
14194 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14195 if (!SWIG_IsOK(res1)) {
14196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
14197 }
14198 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14199 {
14200 PyThreadState* __tstate = wxPyBeginAllowThreads();
14201 result = (int)(arg1)->GetMovementThreshold();
14202 wxPyEndAllowThreads(__tstate);
14203 if (PyErr_Occurred()) SWIG_fail;
14204 }
14205 resultobj = SWIG_From_int(static_cast< int >(result));
14206 return resultobj;
14207 fail:
14208 return NULL;
14209 }
14210
14211
14212 SWIGINTERN PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14213 PyObject *resultobj = 0;
14214 wxJoystick *arg1 = (wxJoystick *) 0 ;
14215 int arg2 ;
14216 void *argp1 = 0 ;
14217 int res1 = 0 ;
14218 int val2 ;
14219 int ecode2 = 0 ;
14220 PyObject * obj0 = 0 ;
14221 PyObject * obj1 = 0 ;
14222 char * kwnames[] = {
14223 (char *) "self",(char *) "threshold", NULL
14224 };
14225
14226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) SWIG_fail;
14227 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14228 if (!SWIG_IsOK(res1)) {
14229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
14230 }
14231 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14232 ecode2 = SWIG_AsVal_int(obj1, &val2);
14233 if (!SWIG_IsOK(ecode2)) {
14234 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "2"" of type '" "int""'");
14235 }
14236 arg2 = static_cast< int >(val2);
14237 {
14238 PyThreadState* __tstate = wxPyBeginAllowThreads();
14239 (arg1)->SetMovementThreshold(arg2);
14240 wxPyEndAllowThreads(__tstate);
14241 if (PyErr_Occurred()) SWIG_fail;
14242 }
14243 resultobj = SWIG_Py_Void();
14244 return resultobj;
14245 fail:
14246 return NULL;
14247 }
14248
14249
14250 SWIGINTERN PyObject *_wrap_Joystick_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14251 PyObject *resultobj = 0;
14252 wxJoystick *arg1 = (wxJoystick *) 0 ;
14253 bool result;
14254 void *argp1 = 0 ;
14255 int res1 = 0 ;
14256 PyObject *swig_obj[1] ;
14257
14258 if (!args) SWIG_fail;
14259 swig_obj[0] = args;
14260 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14261 if (!SWIG_IsOK(res1)) {
14262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_IsOk" "', expected argument " "1"" of type '" "wxJoystick *""'");
14263 }
14264 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14265 {
14266 PyThreadState* __tstate = wxPyBeginAllowThreads();
14267 result = (bool)(arg1)->IsOk();
14268 wxPyEndAllowThreads(__tstate);
14269 if (PyErr_Occurred()) SWIG_fail;
14270 }
14271 {
14272 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14273 }
14274 return resultobj;
14275 fail:
14276 return NULL;
14277 }
14278
14279
14280 SWIGINTERN PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14281 PyObject *resultobj = 0;
14282 wxJoystick *arg1 = (wxJoystick *) 0 ;
14283 int result;
14284 void *argp1 = 0 ;
14285 int res1 = 0 ;
14286 PyObject *swig_obj[1] ;
14287
14288 if (!args) SWIG_fail;
14289 swig_obj[0] = args;
14290 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14291 if (!SWIG_IsOK(res1)) {
14292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberJoysticks" "', expected argument " "1"" of type '" "wxJoystick *""'");
14293 }
14294 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14295 {
14296 PyThreadState* __tstate = wxPyBeginAllowThreads();
14297 result = (int)(arg1)->GetNumberJoysticks();
14298 wxPyEndAllowThreads(__tstate);
14299 if (PyErr_Occurred()) SWIG_fail;
14300 }
14301 resultobj = SWIG_From_int(static_cast< int >(result));
14302 return resultobj;
14303 fail:
14304 return NULL;
14305 }
14306
14307
14308 SWIGINTERN PyObject *_wrap_Joystick_GetManufacturerId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14309 PyObject *resultobj = 0;
14310 wxJoystick *arg1 = (wxJoystick *) 0 ;
14311 int result;
14312 void *argp1 = 0 ;
14313 int res1 = 0 ;
14314 PyObject *swig_obj[1] ;
14315
14316 if (!args) SWIG_fail;
14317 swig_obj[0] = args;
14318 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14319 if (!SWIG_IsOK(res1)) {
14320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetManufacturerId" "', expected argument " "1"" of type '" "wxJoystick *""'");
14321 }
14322 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14323 {
14324 PyThreadState* __tstate = wxPyBeginAllowThreads();
14325 result = (int)(arg1)->GetManufacturerId();
14326 wxPyEndAllowThreads(__tstate);
14327 if (PyErr_Occurred()) SWIG_fail;
14328 }
14329 resultobj = SWIG_From_int(static_cast< int >(result));
14330 return resultobj;
14331 fail:
14332 return NULL;
14333 }
14334
14335
14336 SWIGINTERN PyObject *_wrap_Joystick_GetProductId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14337 PyObject *resultobj = 0;
14338 wxJoystick *arg1 = (wxJoystick *) 0 ;
14339 int result;
14340 void *argp1 = 0 ;
14341 int res1 = 0 ;
14342 PyObject *swig_obj[1] ;
14343
14344 if (!args) SWIG_fail;
14345 swig_obj[0] = args;
14346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14347 if (!SWIG_IsOK(res1)) {
14348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductId" "', expected argument " "1"" of type '" "wxJoystick *""'");
14349 }
14350 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14351 {
14352 PyThreadState* __tstate = wxPyBeginAllowThreads();
14353 result = (int)(arg1)->GetProductId();
14354 wxPyEndAllowThreads(__tstate);
14355 if (PyErr_Occurred()) SWIG_fail;
14356 }
14357 resultobj = SWIG_From_int(static_cast< int >(result));
14358 return resultobj;
14359 fail:
14360 return NULL;
14361 }
14362
14363
14364 SWIGINTERN PyObject *_wrap_Joystick_GetProductName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14365 PyObject *resultobj = 0;
14366 wxJoystick *arg1 = (wxJoystick *) 0 ;
14367 wxString result;
14368 void *argp1 = 0 ;
14369 int res1 = 0 ;
14370 PyObject *swig_obj[1] ;
14371
14372 if (!args) SWIG_fail;
14373 swig_obj[0] = args;
14374 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14375 if (!SWIG_IsOK(res1)) {
14376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductName" "', expected argument " "1"" of type '" "wxJoystick *""'");
14377 }
14378 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14379 {
14380 PyThreadState* __tstate = wxPyBeginAllowThreads();
14381 result = (arg1)->GetProductName();
14382 wxPyEndAllowThreads(__tstate);
14383 if (PyErr_Occurred()) SWIG_fail;
14384 }
14385 {
14386 #if wxUSE_UNICODE
14387 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14388 #else
14389 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14390 #endif
14391 }
14392 return resultobj;
14393 fail:
14394 return NULL;
14395 }
14396
14397
14398 SWIGINTERN PyObject *_wrap_Joystick_GetXMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14399 PyObject *resultobj = 0;
14400 wxJoystick *arg1 = (wxJoystick *) 0 ;
14401 int result;
14402 void *argp1 = 0 ;
14403 int res1 = 0 ;
14404 PyObject *swig_obj[1] ;
14405
14406 if (!args) SWIG_fail;
14407 swig_obj[0] = args;
14408 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14409 if (!SWIG_IsOK(res1)) {
14410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14411 }
14412 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14413 {
14414 PyThreadState* __tstate = wxPyBeginAllowThreads();
14415 result = (int)(arg1)->GetXMin();
14416 wxPyEndAllowThreads(__tstate);
14417 if (PyErr_Occurred()) SWIG_fail;
14418 }
14419 resultobj = SWIG_From_int(static_cast< int >(result));
14420 return resultobj;
14421 fail:
14422 return NULL;
14423 }
14424
14425
14426 SWIGINTERN PyObject *_wrap_Joystick_GetYMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14427 PyObject *resultobj = 0;
14428 wxJoystick *arg1 = (wxJoystick *) 0 ;
14429 int result;
14430 void *argp1 = 0 ;
14431 int res1 = 0 ;
14432 PyObject *swig_obj[1] ;
14433
14434 if (!args) SWIG_fail;
14435 swig_obj[0] = args;
14436 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14437 if (!SWIG_IsOK(res1)) {
14438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14439 }
14440 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14441 {
14442 PyThreadState* __tstate = wxPyBeginAllowThreads();
14443 result = (int)(arg1)->GetYMin();
14444 wxPyEndAllowThreads(__tstate);
14445 if (PyErr_Occurred()) SWIG_fail;
14446 }
14447 resultobj = SWIG_From_int(static_cast< int >(result));
14448 return resultobj;
14449 fail:
14450 return NULL;
14451 }
14452
14453
14454 SWIGINTERN PyObject *_wrap_Joystick_GetZMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14455 PyObject *resultobj = 0;
14456 wxJoystick *arg1 = (wxJoystick *) 0 ;
14457 int result;
14458 void *argp1 = 0 ;
14459 int res1 = 0 ;
14460 PyObject *swig_obj[1] ;
14461
14462 if (!args) SWIG_fail;
14463 swig_obj[0] = args;
14464 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14465 if (!SWIG_IsOK(res1)) {
14466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14467 }
14468 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14469 {
14470 PyThreadState* __tstate = wxPyBeginAllowThreads();
14471 result = (int)(arg1)->GetZMin();
14472 wxPyEndAllowThreads(__tstate);
14473 if (PyErr_Occurred()) SWIG_fail;
14474 }
14475 resultobj = SWIG_From_int(static_cast< int >(result));
14476 return resultobj;
14477 fail:
14478 return NULL;
14479 }
14480
14481
14482 SWIGINTERN PyObject *_wrap_Joystick_GetXMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14483 PyObject *resultobj = 0;
14484 wxJoystick *arg1 = (wxJoystick *) 0 ;
14485 int result;
14486 void *argp1 = 0 ;
14487 int res1 = 0 ;
14488 PyObject *swig_obj[1] ;
14489
14490 if (!args) SWIG_fail;
14491 swig_obj[0] = args;
14492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14493 if (!SWIG_IsOK(res1)) {
14494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14495 }
14496 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14497 {
14498 PyThreadState* __tstate = wxPyBeginAllowThreads();
14499 result = (int)(arg1)->GetXMax();
14500 wxPyEndAllowThreads(__tstate);
14501 if (PyErr_Occurred()) SWIG_fail;
14502 }
14503 resultobj = SWIG_From_int(static_cast< int >(result));
14504 return resultobj;
14505 fail:
14506 return NULL;
14507 }
14508
14509
14510 SWIGINTERN PyObject *_wrap_Joystick_GetYMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14511 PyObject *resultobj = 0;
14512 wxJoystick *arg1 = (wxJoystick *) 0 ;
14513 int result;
14514 void *argp1 = 0 ;
14515 int res1 = 0 ;
14516 PyObject *swig_obj[1] ;
14517
14518 if (!args) SWIG_fail;
14519 swig_obj[0] = args;
14520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14521 if (!SWIG_IsOK(res1)) {
14522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14523 }
14524 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14525 {
14526 PyThreadState* __tstate = wxPyBeginAllowThreads();
14527 result = (int)(arg1)->GetYMax();
14528 wxPyEndAllowThreads(__tstate);
14529 if (PyErr_Occurred()) SWIG_fail;
14530 }
14531 resultobj = SWIG_From_int(static_cast< int >(result));
14532 return resultobj;
14533 fail:
14534 return NULL;
14535 }
14536
14537
14538 SWIGINTERN PyObject *_wrap_Joystick_GetZMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14539 PyObject *resultobj = 0;
14540 wxJoystick *arg1 = (wxJoystick *) 0 ;
14541 int result;
14542 void *argp1 = 0 ;
14543 int res1 = 0 ;
14544 PyObject *swig_obj[1] ;
14545
14546 if (!args) SWIG_fail;
14547 swig_obj[0] = args;
14548 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14549 if (!SWIG_IsOK(res1)) {
14550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14551 }
14552 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14553 {
14554 PyThreadState* __tstate = wxPyBeginAllowThreads();
14555 result = (int)(arg1)->GetZMax();
14556 wxPyEndAllowThreads(__tstate);
14557 if (PyErr_Occurred()) SWIG_fail;
14558 }
14559 resultobj = SWIG_From_int(static_cast< int >(result));
14560 return resultobj;
14561 fail:
14562 return NULL;
14563 }
14564
14565
14566 SWIGINTERN PyObject *_wrap_Joystick_GetNumberButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14567 PyObject *resultobj = 0;
14568 wxJoystick *arg1 = (wxJoystick *) 0 ;
14569 int result;
14570 void *argp1 = 0 ;
14571 int res1 = 0 ;
14572 PyObject *swig_obj[1] ;
14573
14574 if (!args) SWIG_fail;
14575 swig_obj[0] = args;
14576 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14577 if (!SWIG_IsOK(res1)) {
14578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
14579 }
14580 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14581 {
14582 PyThreadState* __tstate = wxPyBeginAllowThreads();
14583 result = (int)(arg1)->GetNumberButtons();
14584 wxPyEndAllowThreads(__tstate);
14585 if (PyErr_Occurred()) SWIG_fail;
14586 }
14587 resultobj = SWIG_From_int(static_cast< int >(result));
14588 return resultobj;
14589 fail:
14590 return NULL;
14591 }
14592
14593
14594 SWIGINTERN PyObject *_wrap_Joystick_GetNumberAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14595 PyObject *resultobj = 0;
14596 wxJoystick *arg1 = (wxJoystick *) 0 ;
14597 int result;
14598 void *argp1 = 0 ;
14599 int res1 = 0 ;
14600 PyObject *swig_obj[1] ;
14601
14602 if (!args) SWIG_fail;
14603 swig_obj[0] = args;
14604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14605 if (!SWIG_IsOK(res1)) {
14606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
14607 }
14608 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14609 {
14610 PyThreadState* __tstate = wxPyBeginAllowThreads();
14611 result = (int)(arg1)->GetNumberAxes();
14612 wxPyEndAllowThreads(__tstate);
14613 if (PyErr_Occurred()) SWIG_fail;
14614 }
14615 resultobj = SWIG_From_int(static_cast< int >(result));
14616 return resultobj;
14617 fail:
14618 return NULL;
14619 }
14620
14621
14622 SWIGINTERN PyObject *_wrap_Joystick_GetMaxButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14623 PyObject *resultobj = 0;
14624 wxJoystick *arg1 = (wxJoystick *) 0 ;
14625 int result;
14626 void *argp1 = 0 ;
14627 int res1 = 0 ;
14628 PyObject *swig_obj[1] ;
14629
14630 if (!args) SWIG_fail;
14631 swig_obj[0] = args;
14632 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14633 if (!SWIG_IsOK(res1)) {
14634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
14635 }
14636 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14637 {
14638 PyThreadState* __tstate = wxPyBeginAllowThreads();
14639 result = (int)(arg1)->GetMaxButtons();
14640 wxPyEndAllowThreads(__tstate);
14641 if (PyErr_Occurred()) SWIG_fail;
14642 }
14643 resultobj = SWIG_From_int(static_cast< int >(result));
14644 return resultobj;
14645 fail:
14646 return NULL;
14647 }
14648
14649
14650 SWIGINTERN PyObject *_wrap_Joystick_GetMaxAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14651 PyObject *resultobj = 0;
14652 wxJoystick *arg1 = (wxJoystick *) 0 ;
14653 int result;
14654 void *argp1 = 0 ;
14655 int res1 = 0 ;
14656 PyObject *swig_obj[1] ;
14657
14658 if (!args) SWIG_fail;
14659 swig_obj[0] = args;
14660 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14661 if (!SWIG_IsOK(res1)) {
14662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
14663 }
14664 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14665 {
14666 PyThreadState* __tstate = wxPyBeginAllowThreads();
14667 result = (int)(arg1)->GetMaxAxes();
14668 wxPyEndAllowThreads(__tstate);
14669 if (PyErr_Occurred()) SWIG_fail;
14670 }
14671 resultobj = SWIG_From_int(static_cast< int >(result));
14672 return resultobj;
14673 fail:
14674 return NULL;
14675 }
14676
14677
14678 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14679 PyObject *resultobj = 0;
14680 wxJoystick *arg1 = (wxJoystick *) 0 ;
14681 int result;
14682 void *argp1 = 0 ;
14683 int res1 = 0 ;
14684 PyObject *swig_obj[1] ;
14685
14686 if (!args) SWIG_fail;
14687 swig_obj[0] = args;
14688 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14689 if (!SWIG_IsOK(res1)) {
14690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14691 }
14692 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14693 {
14694 PyThreadState* __tstate = wxPyBeginAllowThreads();
14695 result = (int)(arg1)->GetPollingMin();
14696 wxPyEndAllowThreads(__tstate);
14697 if (PyErr_Occurred()) SWIG_fail;
14698 }
14699 resultobj = SWIG_From_int(static_cast< int >(result));
14700 return resultobj;
14701 fail:
14702 return NULL;
14703 }
14704
14705
14706 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14707 PyObject *resultobj = 0;
14708 wxJoystick *arg1 = (wxJoystick *) 0 ;
14709 int result;
14710 void *argp1 = 0 ;
14711 int res1 = 0 ;
14712 PyObject *swig_obj[1] ;
14713
14714 if (!args) SWIG_fail;
14715 swig_obj[0] = args;
14716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14717 if (!SWIG_IsOK(res1)) {
14718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14719 }
14720 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14721 {
14722 PyThreadState* __tstate = wxPyBeginAllowThreads();
14723 result = (int)(arg1)->GetPollingMax();
14724 wxPyEndAllowThreads(__tstate);
14725 if (PyErr_Occurred()) SWIG_fail;
14726 }
14727 resultobj = SWIG_From_int(static_cast< int >(result));
14728 return resultobj;
14729 fail:
14730 return NULL;
14731 }
14732
14733
14734 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14735 PyObject *resultobj = 0;
14736 wxJoystick *arg1 = (wxJoystick *) 0 ;
14737 int result;
14738 void *argp1 = 0 ;
14739 int res1 = 0 ;
14740 PyObject *swig_obj[1] ;
14741
14742 if (!args) SWIG_fail;
14743 swig_obj[0] = args;
14744 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14745 if (!SWIG_IsOK(res1)) {
14746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14747 }
14748 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14749 {
14750 PyThreadState* __tstate = wxPyBeginAllowThreads();
14751 result = (int)(arg1)->GetRudderMin();
14752 wxPyEndAllowThreads(__tstate);
14753 if (PyErr_Occurred()) SWIG_fail;
14754 }
14755 resultobj = SWIG_From_int(static_cast< int >(result));
14756 return resultobj;
14757 fail:
14758 return NULL;
14759 }
14760
14761
14762 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14763 PyObject *resultobj = 0;
14764 wxJoystick *arg1 = (wxJoystick *) 0 ;
14765 int result;
14766 void *argp1 = 0 ;
14767 int res1 = 0 ;
14768 PyObject *swig_obj[1] ;
14769
14770 if (!args) SWIG_fail;
14771 swig_obj[0] = args;
14772 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14773 if (!SWIG_IsOK(res1)) {
14774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14775 }
14776 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14777 {
14778 PyThreadState* __tstate = wxPyBeginAllowThreads();
14779 result = (int)(arg1)->GetRudderMax();
14780 wxPyEndAllowThreads(__tstate);
14781 if (PyErr_Occurred()) SWIG_fail;
14782 }
14783 resultobj = SWIG_From_int(static_cast< int >(result));
14784 return resultobj;
14785 fail:
14786 return NULL;
14787 }
14788
14789
14790 SWIGINTERN PyObject *_wrap_Joystick_GetUMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14791 PyObject *resultobj = 0;
14792 wxJoystick *arg1 = (wxJoystick *) 0 ;
14793 int result;
14794 void *argp1 = 0 ;
14795 int res1 = 0 ;
14796 PyObject *swig_obj[1] ;
14797
14798 if (!args) SWIG_fail;
14799 swig_obj[0] = args;
14800 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14801 if (!SWIG_IsOK(res1)) {
14802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14803 }
14804 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14805 {
14806 PyThreadState* __tstate = wxPyBeginAllowThreads();
14807 result = (int)(arg1)->GetUMin();
14808 wxPyEndAllowThreads(__tstate);
14809 if (PyErr_Occurred()) SWIG_fail;
14810 }
14811 resultobj = SWIG_From_int(static_cast< int >(result));
14812 return resultobj;
14813 fail:
14814 return NULL;
14815 }
14816
14817
14818 SWIGINTERN PyObject *_wrap_Joystick_GetUMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14819 PyObject *resultobj = 0;
14820 wxJoystick *arg1 = (wxJoystick *) 0 ;
14821 int result;
14822 void *argp1 = 0 ;
14823 int res1 = 0 ;
14824 PyObject *swig_obj[1] ;
14825
14826 if (!args) SWIG_fail;
14827 swig_obj[0] = args;
14828 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14829 if (!SWIG_IsOK(res1)) {
14830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14831 }
14832 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14833 {
14834 PyThreadState* __tstate = wxPyBeginAllowThreads();
14835 result = (int)(arg1)->GetUMax();
14836 wxPyEndAllowThreads(__tstate);
14837 if (PyErr_Occurred()) SWIG_fail;
14838 }
14839 resultobj = SWIG_From_int(static_cast< int >(result));
14840 return resultobj;
14841 fail:
14842 return NULL;
14843 }
14844
14845
14846 SWIGINTERN PyObject *_wrap_Joystick_GetVMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14847 PyObject *resultobj = 0;
14848 wxJoystick *arg1 = (wxJoystick *) 0 ;
14849 int result;
14850 void *argp1 = 0 ;
14851 int res1 = 0 ;
14852 PyObject *swig_obj[1] ;
14853
14854 if (!args) SWIG_fail;
14855 swig_obj[0] = args;
14856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14857 if (!SWIG_IsOK(res1)) {
14858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14859 }
14860 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14861 {
14862 PyThreadState* __tstate = wxPyBeginAllowThreads();
14863 result = (int)(arg1)->GetVMin();
14864 wxPyEndAllowThreads(__tstate);
14865 if (PyErr_Occurred()) SWIG_fail;
14866 }
14867 resultobj = SWIG_From_int(static_cast< int >(result));
14868 return resultobj;
14869 fail:
14870 return NULL;
14871 }
14872
14873
14874 SWIGINTERN PyObject *_wrap_Joystick_GetVMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14875 PyObject *resultobj = 0;
14876 wxJoystick *arg1 = (wxJoystick *) 0 ;
14877 int result;
14878 void *argp1 = 0 ;
14879 int res1 = 0 ;
14880 PyObject *swig_obj[1] ;
14881
14882 if (!args) SWIG_fail;
14883 swig_obj[0] = args;
14884 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14885 if (!SWIG_IsOK(res1)) {
14886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14887 }
14888 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14889 {
14890 PyThreadState* __tstate = wxPyBeginAllowThreads();
14891 result = (int)(arg1)->GetVMax();
14892 wxPyEndAllowThreads(__tstate);
14893 if (PyErr_Occurred()) SWIG_fail;
14894 }
14895 resultobj = SWIG_From_int(static_cast< int >(result));
14896 return resultobj;
14897 fail:
14898 return NULL;
14899 }
14900
14901
14902 SWIGINTERN PyObject *_wrap_Joystick_HasRudder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14903 PyObject *resultobj = 0;
14904 wxJoystick *arg1 = (wxJoystick *) 0 ;
14905 bool result;
14906 void *argp1 = 0 ;
14907 int res1 = 0 ;
14908 PyObject *swig_obj[1] ;
14909
14910 if (!args) SWIG_fail;
14911 swig_obj[0] = args;
14912 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14913 if (!SWIG_IsOK(res1)) {
14914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasRudder" "', expected argument " "1"" of type '" "wxJoystick *""'");
14915 }
14916 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14917 {
14918 PyThreadState* __tstate = wxPyBeginAllowThreads();
14919 result = (bool)(arg1)->HasRudder();
14920 wxPyEndAllowThreads(__tstate);
14921 if (PyErr_Occurred()) SWIG_fail;
14922 }
14923 {
14924 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14925 }
14926 return resultobj;
14927 fail:
14928 return NULL;
14929 }
14930
14931
14932 SWIGINTERN PyObject *_wrap_Joystick_HasZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14933 PyObject *resultobj = 0;
14934 wxJoystick *arg1 = (wxJoystick *) 0 ;
14935 bool result;
14936 void *argp1 = 0 ;
14937 int res1 = 0 ;
14938 PyObject *swig_obj[1] ;
14939
14940 if (!args) SWIG_fail;
14941 swig_obj[0] = args;
14942 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14943 if (!SWIG_IsOK(res1)) {
14944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasZ" "', expected argument " "1"" of type '" "wxJoystick *""'");
14945 }
14946 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14947 {
14948 PyThreadState* __tstate = wxPyBeginAllowThreads();
14949 result = (bool)(arg1)->HasZ();
14950 wxPyEndAllowThreads(__tstate);
14951 if (PyErr_Occurred()) SWIG_fail;
14952 }
14953 {
14954 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14955 }
14956 return resultobj;
14957 fail:
14958 return NULL;
14959 }
14960
14961
14962 SWIGINTERN PyObject *_wrap_Joystick_HasU(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14963 PyObject *resultobj = 0;
14964 wxJoystick *arg1 = (wxJoystick *) 0 ;
14965 bool result;
14966 void *argp1 = 0 ;
14967 int res1 = 0 ;
14968 PyObject *swig_obj[1] ;
14969
14970 if (!args) SWIG_fail;
14971 swig_obj[0] = args;
14972 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14973 if (!SWIG_IsOK(res1)) {
14974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasU" "', expected argument " "1"" of type '" "wxJoystick *""'");
14975 }
14976 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14977 {
14978 PyThreadState* __tstate = wxPyBeginAllowThreads();
14979 result = (bool)(arg1)->HasU();
14980 wxPyEndAllowThreads(__tstate);
14981 if (PyErr_Occurred()) SWIG_fail;
14982 }
14983 {
14984 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14985 }
14986 return resultobj;
14987 fail:
14988 return NULL;
14989 }
14990
14991
14992 SWIGINTERN PyObject *_wrap_Joystick_HasV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14993 PyObject *resultobj = 0;
14994 wxJoystick *arg1 = (wxJoystick *) 0 ;
14995 bool result;
14996 void *argp1 = 0 ;
14997 int res1 = 0 ;
14998 PyObject *swig_obj[1] ;
14999
15000 if (!args) SWIG_fail;
15001 swig_obj[0] = args;
15002 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15003 if (!SWIG_IsOK(res1)) {
15004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasV" "', expected argument " "1"" of type '" "wxJoystick *""'");
15005 }
15006 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15007 {
15008 PyThreadState* __tstate = wxPyBeginAllowThreads();
15009 result = (bool)(arg1)->HasV();
15010 wxPyEndAllowThreads(__tstate);
15011 if (PyErr_Occurred()) SWIG_fail;
15012 }
15013 {
15014 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15015 }
15016 return resultobj;
15017 fail:
15018 return NULL;
15019 }
15020
15021
15022 SWIGINTERN PyObject *_wrap_Joystick_HasPOV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15023 PyObject *resultobj = 0;
15024 wxJoystick *arg1 = (wxJoystick *) 0 ;
15025 bool result;
15026 void *argp1 = 0 ;
15027 int res1 = 0 ;
15028 PyObject *swig_obj[1] ;
15029
15030 if (!args) SWIG_fail;
15031 swig_obj[0] = args;
15032 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15033 if (!SWIG_IsOK(res1)) {
15034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV" "', expected argument " "1"" of type '" "wxJoystick *""'");
15035 }
15036 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15037 {
15038 PyThreadState* __tstate = wxPyBeginAllowThreads();
15039 result = (bool)(arg1)->HasPOV();
15040 wxPyEndAllowThreads(__tstate);
15041 if (PyErr_Occurred()) SWIG_fail;
15042 }
15043 {
15044 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15045 }
15046 return resultobj;
15047 fail:
15048 return NULL;
15049 }
15050
15051
15052 SWIGINTERN PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15053 PyObject *resultobj = 0;
15054 wxJoystick *arg1 = (wxJoystick *) 0 ;
15055 bool result;
15056 void *argp1 = 0 ;
15057 int res1 = 0 ;
15058 PyObject *swig_obj[1] ;
15059
15060 if (!args) SWIG_fail;
15061 swig_obj[0] = args;
15062 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15063 if (!SWIG_IsOK(res1)) {
15064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV4Dir" "', expected argument " "1"" of type '" "wxJoystick *""'");
15065 }
15066 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15067 {
15068 PyThreadState* __tstate = wxPyBeginAllowThreads();
15069 result = (bool)(arg1)->HasPOV4Dir();
15070 wxPyEndAllowThreads(__tstate);
15071 if (PyErr_Occurred()) SWIG_fail;
15072 }
15073 {
15074 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15075 }
15076 return resultobj;
15077 fail:
15078 return NULL;
15079 }
15080
15081
15082 SWIGINTERN PyObject *_wrap_Joystick_HasPOVCTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15083 PyObject *resultobj = 0;
15084 wxJoystick *arg1 = (wxJoystick *) 0 ;
15085 bool result;
15086 void *argp1 = 0 ;
15087 int res1 = 0 ;
15088 PyObject *swig_obj[1] ;
15089
15090 if (!args) SWIG_fail;
15091 swig_obj[0] = args;
15092 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15093 if (!SWIG_IsOK(res1)) {
15094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOVCTS" "', expected argument " "1"" of type '" "wxJoystick *""'");
15095 }
15096 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15097 {
15098 PyThreadState* __tstate = wxPyBeginAllowThreads();
15099 result = (bool)(arg1)->HasPOVCTS();
15100 wxPyEndAllowThreads(__tstate);
15101 if (PyErr_Occurred()) SWIG_fail;
15102 }
15103 {
15104 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15105 }
15106 return resultobj;
15107 fail:
15108 return NULL;
15109 }
15110
15111
15112 SWIGINTERN PyObject *_wrap_Joystick_SetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15113 PyObject *resultobj = 0;
15114 wxJoystick *arg1 = (wxJoystick *) 0 ;
15115 wxWindow *arg2 = (wxWindow *) 0 ;
15116 int arg3 = (int) 0 ;
15117 bool result;
15118 void *argp1 = 0 ;
15119 int res1 = 0 ;
15120 void *argp2 = 0 ;
15121 int res2 = 0 ;
15122 int val3 ;
15123 int ecode3 = 0 ;
15124 PyObject * obj0 = 0 ;
15125 PyObject * obj1 = 0 ;
15126 PyObject * obj2 = 0 ;
15127 char * kwnames[] = {
15128 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
15129 };
15130
15131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15133 if (!SWIG_IsOK(res1)) {
15134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
15135 }
15136 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15137 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
15138 if (!SWIG_IsOK(res2)) {
15139 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Joystick_SetCapture" "', expected argument " "2"" of type '" "wxWindow *""'");
15140 }
15141 arg2 = reinterpret_cast< wxWindow * >(argp2);
15142 if (obj2) {
15143 ecode3 = SWIG_AsVal_int(obj2, &val3);
15144 if (!SWIG_IsOK(ecode3)) {
15145 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Joystick_SetCapture" "', expected argument " "3"" of type '" "int""'");
15146 }
15147 arg3 = static_cast< int >(val3);
15148 }
15149 {
15150 PyThreadState* __tstate = wxPyBeginAllowThreads();
15151 result = (bool)(arg1)->SetCapture(arg2,arg3);
15152 wxPyEndAllowThreads(__tstate);
15153 if (PyErr_Occurred()) SWIG_fail;
15154 }
15155 {
15156 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15157 }
15158 return resultobj;
15159 fail:
15160 return NULL;
15161 }
15162
15163
15164 SWIGINTERN PyObject *_wrap_Joystick_ReleaseCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15165 PyObject *resultobj = 0;
15166 wxJoystick *arg1 = (wxJoystick *) 0 ;
15167 bool result;
15168 void *argp1 = 0 ;
15169 int res1 = 0 ;
15170 PyObject *swig_obj[1] ;
15171
15172 if (!args) SWIG_fail;
15173 swig_obj[0] = args;
15174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15175 if (!SWIG_IsOK(res1)) {
15176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_ReleaseCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
15177 }
15178 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15179 {
15180 PyThreadState* __tstate = wxPyBeginAllowThreads();
15181 result = (bool)(arg1)->ReleaseCapture();
15182 wxPyEndAllowThreads(__tstate);
15183 if (PyErr_Occurred()) SWIG_fail;
15184 }
15185 {
15186 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15187 }
15188 return resultobj;
15189 fail:
15190 return NULL;
15191 }
15192
15193
15194 SWIGINTERN PyObject *Joystick_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15195 PyObject *obj;
15196 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15197 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystick, SWIG_NewClientData(obj));
15198 return SWIG_Py_Void();
15199 }
15200
15201 SWIGINTERN PyObject *Joystick_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15202 return SWIG_Python_InitShadowInstance(args);
15203 }
15204
15205 SWIGINTERN PyObject *_wrap_new_JoystickEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15206 PyObject *resultobj = 0;
15207 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15208 int arg2 = (int) 0 ;
15209 int arg3 = (int) wxJOYSTICK1 ;
15210 int arg4 = (int) 0 ;
15211 wxJoystickEvent *result = 0 ;
15212 int val1 ;
15213 int ecode1 = 0 ;
15214 int val2 ;
15215 int ecode2 = 0 ;
15216 int val3 ;
15217 int ecode3 = 0 ;
15218 int val4 ;
15219 int ecode4 = 0 ;
15220 PyObject * obj0 = 0 ;
15221 PyObject * obj1 = 0 ;
15222 PyObject * obj2 = 0 ;
15223 PyObject * obj3 = 0 ;
15224 char * kwnames[] = {
15225 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
15226 };
15227
15228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15229 if (obj0) {
15230 ecode1 = SWIG_AsVal_int(obj0, &val1);
15231 if (!SWIG_IsOK(ecode1)) {
15232 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_JoystickEvent" "', expected argument " "1"" of type '" "wxEventType""'");
15233 }
15234 arg1 = static_cast< wxEventType >(val1);
15235 }
15236 if (obj1) {
15237 ecode2 = SWIG_AsVal_int(obj1, &val2);
15238 if (!SWIG_IsOK(ecode2)) {
15239 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_JoystickEvent" "', expected argument " "2"" of type '" "int""'");
15240 }
15241 arg2 = static_cast< int >(val2);
15242 }
15243 if (obj2) {
15244 ecode3 = SWIG_AsVal_int(obj2, &val3);
15245 if (!SWIG_IsOK(ecode3)) {
15246 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_JoystickEvent" "', expected argument " "3"" of type '" "int""'");
15247 }
15248 arg3 = static_cast< int >(val3);
15249 }
15250 if (obj3) {
15251 ecode4 = SWIG_AsVal_int(obj3, &val4);
15252 if (!SWIG_IsOK(ecode4)) {
15253 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_JoystickEvent" "', expected argument " "4"" of type '" "int""'");
15254 }
15255 arg4 = static_cast< int >(val4);
15256 }
15257 {
15258 PyThreadState* __tstate = wxPyBeginAllowThreads();
15259 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
15260 wxPyEndAllowThreads(__tstate);
15261 if (PyErr_Occurred()) SWIG_fail;
15262 }
15263 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_NEW | 0 );
15264 return resultobj;
15265 fail:
15266 return NULL;
15267 }
15268
15269
15270 SWIGINTERN PyObject *_wrap_JoystickEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15271 PyObject *resultobj = 0;
15272 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15273 wxPoint result;
15274 void *argp1 = 0 ;
15275 int res1 = 0 ;
15276 PyObject *swig_obj[1] ;
15277
15278 if (!args) SWIG_fail;
15279 swig_obj[0] = args;
15280 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15281 if (!SWIG_IsOK(res1)) {
15282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15283 }
15284 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15285 {
15286 PyThreadState* __tstate = wxPyBeginAllowThreads();
15287 result = ((wxJoystickEvent const *)arg1)->GetPosition();
15288 wxPyEndAllowThreads(__tstate);
15289 if (PyErr_Occurred()) SWIG_fail;
15290 }
15291 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
15292 return resultobj;
15293 fail:
15294 return NULL;
15295 }
15296
15297
15298 SWIGINTERN PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15299 PyObject *resultobj = 0;
15300 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15301 int result;
15302 void *argp1 = 0 ;
15303 int res1 = 0 ;
15304 PyObject *swig_obj[1] ;
15305
15306 if (!args) SWIG_fail;
15307 swig_obj[0] = args;
15308 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15309 if (!SWIG_IsOK(res1)) {
15310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15311 }
15312 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15313 {
15314 PyThreadState* __tstate = wxPyBeginAllowThreads();
15315 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
15316 wxPyEndAllowThreads(__tstate);
15317 if (PyErr_Occurred()) SWIG_fail;
15318 }
15319 resultobj = SWIG_From_int(static_cast< int >(result));
15320 return resultobj;
15321 fail:
15322 return NULL;
15323 }
15324
15325
15326 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15327 PyObject *resultobj = 0;
15328 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15329 int result;
15330 void *argp1 = 0 ;
15331 int res1 = 0 ;
15332 PyObject *swig_obj[1] ;
15333
15334 if (!args) SWIG_fail;
15335 swig_obj[0] = args;
15336 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15337 if (!SWIG_IsOK(res1)) {
15338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15339 }
15340 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15341 {
15342 PyThreadState* __tstate = wxPyBeginAllowThreads();
15343 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
15344 wxPyEndAllowThreads(__tstate);
15345 if (PyErr_Occurred()) SWIG_fail;
15346 }
15347 resultobj = SWIG_From_int(static_cast< int >(result));
15348 return resultobj;
15349 fail:
15350 return NULL;
15351 }
15352
15353
15354 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15355 PyObject *resultobj = 0;
15356 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15357 int result;
15358 void *argp1 = 0 ;
15359 int res1 = 0 ;
15360 PyObject *swig_obj[1] ;
15361
15362 if (!args) SWIG_fail;
15363 swig_obj[0] = args;
15364 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15365 if (!SWIG_IsOK(res1)) {
15366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15367 }
15368 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15369 {
15370 PyThreadState* __tstate = wxPyBeginAllowThreads();
15371 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
15372 wxPyEndAllowThreads(__tstate);
15373 if (PyErr_Occurred()) SWIG_fail;
15374 }
15375 resultobj = SWIG_From_int(static_cast< int >(result));
15376 return resultobj;
15377 fail:
15378 return NULL;
15379 }
15380
15381
15382 SWIGINTERN PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15383 PyObject *resultobj = 0;
15384 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15385 int result;
15386 void *argp1 = 0 ;
15387 int res1 = 0 ;
15388 PyObject *swig_obj[1] ;
15389
15390 if (!args) SWIG_fail;
15391 swig_obj[0] = args;
15392 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15393 if (!SWIG_IsOK(res1)) {
15394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15395 }
15396 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15397 {
15398 PyThreadState* __tstate = wxPyBeginAllowThreads();
15399 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
15400 wxPyEndAllowThreads(__tstate);
15401 if (PyErr_Occurred()) SWIG_fail;
15402 }
15403 resultobj = SWIG_From_int(static_cast< int >(result));
15404 return resultobj;
15405 fail:
15406 return NULL;
15407 }
15408
15409
15410 SWIGINTERN PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15411 PyObject *resultobj = 0;
15412 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15413 int arg2 ;
15414 void *argp1 = 0 ;
15415 int res1 = 0 ;
15416 int val2 ;
15417 int ecode2 = 0 ;
15418 PyObject * obj0 = 0 ;
15419 PyObject * obj1 = 0 ;
15420 char * kwnames[] = {
15421 (char *) "self",(char *) "stick", NULL
15422 };
15423
15424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) SWIG_fail;
15425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15426 if (!SWIG_IsOK(res1)) {
15427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15428 }
15429 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15430 ecode2 = SWIG_AsVal_int(obj1, &val2);
15431 if (!SWIG_IsOK(ecode2)) {
15432 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "2"" of type '" "int""'");
15433 }
15434 arg2 = static_cast< int >(val2);
15435 {
15436 PyThreadState* __tstate = wxPyBeginAllowThreads();
15437 (arg1)->SetJoystick(arg2);
15438 wxPyEndAllowThreads(__tstate);
15439 if (PyErr_Occurred()) SWIG_fail;
15440 }
15441 resultobj = SWIG_Py_Void();
15442 return resultobj;
15443 fail:
15444 return NULL;
15445 }
15446
15447
15448 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15449 PyObject *resultobj = 0;
15450 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15451 int arg2 ;
15452 void *argp1 = 0 ;
15453 int res1 = 0 ;
15454 int val2 ;
15455 int ecode2 = 0 ;
15456 PyObject * obj0 = 0 ;
15457 PyObject * obj1 = 0 ;
15458 char * kwnames[] = {
15459 (char *) "self",(char *) "state", NULL
15460 };
15461
15462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) SWIG_fail;
15463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15464 if (!SWIG_IsOK(res1)) {
15465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15466 }
15467 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15468 ecode2 = SWIG_AsVal_int(obj1, &val2);
15469 if (!SWIG_IsOK(ecode2)) {
15470 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "2"" of type '" "int""'");
15471 }
15472 arg2 = static_cast< int >(val2);
15473 {
15474 PyThreadState* __tstate = wxPyBeginAllowThreads();
15475 (arg1)->SetButtonState(arg2);
15476 wxPyEndAllowThreads(__tstate);
15477 if (PyErr_Occurred()) SWIG_fail;
15478 }
15479 resultobj = SWIG_Py_Void();
15480 return resultobj;
15481 fail:
15482 return NULL;
15483 }
15484
15485
15486 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15487 PyObject *resultobj = 0;
15488 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15489 int arg2 ;
15490 void *argp1 = 0 ;
15491 int res1 = 0 ;
15492 int val2 ;
15493 int ecode2 = 0 ;
15494 PyObject * obj0 = 0 ;
15495 PyObject * obj1 = 0 ;
15496 char * kwnames[] = {
15497 (char *) "self",(char *) "change", NULL
15498 };
15499
15500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) SWIG_fail;
15501 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15502 if (!SWIG_IsOK(res1)) {
15503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15504 }
15505 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15506 ecode2 = SWIG_AsVal_int(obj1, &val2);
15507 if (!SWIG_IsOK(ecode2)) {
15508 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "2"" of type '" "int""'");
15509 }
15510 arg2 = static_cast< int >(val2);
15511 {
15512 PyThreadState* __tstate = wxPyBeginAllowThreads();
15513 (arg1)->SetButtonChange(arg2);
15514 wxPyEndAllowThreads(__tstate);
15515 if (PyErr_Occurred()) SWIG_fail;
15516 }
15517 resultobj = SWIG_Py_Void();
15518 return resultobj;
15519 fail:
15520 return NULL;
15521 }
15522
15523
15524 SWIGINTERN PyObject *_wrap_JoystickEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15525 PyObject *resultobj = 0;
15526 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15527 wxPoint *arg2 = 0 ;
15528 void *argp1 = 0 ;
15529 int res1 = 0 ;
15530 wxPoint temp2 ;
15531 PyObject * obj0 = 0 ;
15532 PyObject * obj1 = 0 ;
15533 char * kwnames[] = {
15534 (char *) "self",(char *) "pos", NULL
15535 };
15536
15537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
15538 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15539 if (!SWIG_IsOK(res1)) {
15540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15541 }
15542 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15543 {
15544 arg2 = &temp2;
15545 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
15546 }
15547 {
15548 PyThreadState* __tstate = wxPyBeginAllowThreads();
15549 (arg1)->SetPosition((wxPoint const &)*arg2);
15550 wxPyEndAllowThreads(__tstate);
15551 if (PyErr_Occurred()) SWIG_fail;
15552 }
15553 resultobj = SWIG_Py_Void();
15554 return resultobj;
15555 fail:
15556 return NULL;
15557 }
15558
15559
15560 SWIGINTERN PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15561 PyObject *resultobj = 0;
15562 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15563 int arg2 ;
15564 void *argp1 = 0 ;
15565 int res1 = 0 ;
15566 int val2 ;
15567 int ecode2 = 0 ;
15568 PyObject * obj0 = 0 ;
15569 PyObject * obj1 = 0 ;
15570 char * kwnames[] = {
15571 (char *) "self",(char *) "zPos", NULL
15572 };
15573
15574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) SWIG_fail;
15575 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15576 if (!SWIG_IsOK(res1)) {
15577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15578 }
15579 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15580 ecode2 = SWIG_AsVal_int(obj1, &val2);
15581 if (!SWIG_IsOK(ecode2)) {
15582 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "2"" of type '" "int""'");
15583 }
15584 arg2 = static_cast< int >(val2);
15585 {
15586 PyThreadState* __tstate = wxPyBeginAllowThreads();
15587 (arg1)->SetZPosition(arg2);
15588 wxPyEndAllowThreads(__tstate);
15589 if (PyErr_Occurred()) SWIG_fail;
15590 }
15591 resultobj = SWIG_Py_Void();
15592 return resultobj;
15593 fail:
15594 return NULL;
15595 }
15596
15597
15598 SWIGINTERN PyObject *_wrap_JoystickEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15599 PyObject *resultobj = 0;
15600 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15601 bool result;
15602 void *argp1 = 0 ;
15603 int res1 = 0 ;
15604 PyObject *swig_obj[1] ;
15605
15606 if (!args) SWIG_fail;
15607 swig_obj[0] = args;
15608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15609 if (!SWIG_IsOK(res1)) {
15610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsButton" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15611 }
15612 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15613 {
15614 PyThreadState* __tstate = wxPyBeginAllowThreads();
15615 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
15616 wxPyEndAllowThreads(__tstate);
15617 if (PyErr_Occurred()) SWIG_fail;
15618 }
15619 {
15620 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15621 }
15622 return resultobj;
15623 fail:
15624 return NULL;
15625 }
15626
15627
15628 SWIGINTERN PyObject *_wrap_JoystickEvent_IsMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15629 PyObject *resultobj = 0;
15630 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15631 bool result;
15632 void *argp1 = 0 ;
15633 int res1 = 0 ;
15634 PyObject *swig_obj[1] ;
15635
15636 if (!args) SWIG_fail;
15637 swig_obj[0] = args;
15638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15639 if (!SWIG_IsOK(res1)) {
15640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15641 }
15642 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15643 {
15644 PyThreadState* __tstate = wxPyBeginAllowThreads();
15645 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
15646 wxPyEndAllowThreads(__tstate);
15647 if (PyErr_Occurred()) SWIG_fail;
15648 }
15649 {
15650 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15651 }
15652 return resultobj;
15653 fail:
15654 return NULL;
15655 }
15656
15657
15658 SWIGINTERN PyObject *_wrap_JoystickEvent_IsZMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15659 PyObject *resultobj = 0;
15660 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15661 bool result;
15662 void *argp1 = 0 ;
15663 int res1 = 0 ;
15664 PyObject *swig_obj[1] ;
15665
15666 if (!args) SWIG_fail;
15667 swig_obj[0] = args;
15668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15669 if (!SWIG_IsOK(res1)) {
15670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsZMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15671 }
15672 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15673 {
15674 PyThreadState* __tstate = wxPyBeginAllowThreads();
15675 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
15676 wxPyEndAllowThreads(__tstate);
15677 if (PyErr_Occurred()) SWIG_fail;
15678 }
15679 {
15680 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15681 }
15682 return resultobj;
15683 fail:
15684 return NULL;
15685 }
15686
15687
15688 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15689 PyObject *resultobj = 0;
15690 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15691 int arg2 = (int) wxJOY_BUTTON_ANY ;
15692 bool result;
15693 void *argp1 = 0 ;
15694 int res1 = 0 ;
15695 int val2 ;
15696 int ecode2 = 0 ;
15697 PyObject * obj0 = 0 ;
15698 PyObject * obj1 = 0 ;
15699 char * kwnames[] = {
15700 (char *) "self",(char *) "but", NULL
15701 };
15702
15703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
15704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15705 if (!SWIG_IsOK(res1)) {
15706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15707 }
15708 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15709 if (obj1) {
15710 ecode2 = SWIG_AsVal_int(obj1, &val2);
15711 if (!SWIG_IsOK(ecode2)) {
15712 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
15713 }
15714 arg2 = static_cast< int >(val2);
15715 }
15716 {
15717 PyThreadState* __tstate = wxPyBeginAllowThreads();
15718 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
15719 wxPyEndAllowThreads(__tstate);
15720 if (PyErr_Occurred()) SWIG_fail;
15721 }
15722 {
15723 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15724 }
15725 return resultobj;
15726 fail:
15727 return NULL;
15728 }
15729
15730
15731 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15732 PyObject *resultobj = 0;
15733 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15734 int arg2 = (int) wxJOY_BUTTON_ANY ;
15735 bool result;
15736 void *argp1 = 0 ;
15737 int res1 = 0 ;
15738 int val2 ;
15739 int ecode2 = 0 ;
15740 PyObject * obj0 = 0 ;
15741 PyObject * obj1 = 0 ;
15742 char * kwnames[] = {
15743 (char *) "self",(char *) "but", NULL
15744 };
15745
15746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
15747 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15748 if (!SWIG_IsOK(res1)) {
15749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15750 }
15751 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15752 if (obj1) {
15753 ecode2 = SWIG_AsVal_int(obj1, &val2);
15754 if (!SWIG_IsOK(ecode2)) {
15755 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
15756 }
15757 arg2 = static_cast< int >(val2);
15758 }
15759 {
15760 PyThreadState* __tstate = wxPyBeginAllowThreads();
15761 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
15762 wxPyEndAllowThreads(__tstate);
15763 if (PyErr_Occurred()) SWIG_fail;
15764 }
15765 {
15766 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15767 }
15768 return resultobj;
15769 fail:
15770 return NULL;
15771 }
15772
15773
15774 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15775 PyObject *resultobj = 0;
15776 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15777 int arg2 = (int) wxJOY_BUTTON_ANY ;
15778 bool result;
15779 void *argp1 = 0 ;
15780 int res1 = 0 ;
15781 int val2 ;
15782 int ecode2 = 0 ;
15783 PyObject * obj0 = 0 ;
15784 PyObject * obj1 = 0 ;
15785 char * kwnames[] = {
15786 (char *) "self",(char *) "but", NULL
15787 };
15788
15789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
15790 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15791 if (!SWIG_IsOK(res1)) {
15792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15793 }
15794 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15795 if (obj1) {
15796 ecode2 = SWIG_AsVal_int(obj1, &val2);
15797 if (!SWIG_IsOK(ecode2)) {
15798 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
15799 }
15800 arg2 = static_cast< int >(val2);
15801 }
15802 {
15803 PyThreadState* __tstate = wxPyBeginAllowThreads();
15804 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
15805 wxPyEndAllowThreads(__tstate);
15806 if (PyErr_Occurred()) SWIG_fail;
15807 }
15808 {
15809 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15810 }
15811 return resultobj;
15812 fail:
15813 return NULL;
15814 }
15815
15816
15817 SWIGINTERN PyObject *JoystickEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15818 PyObject *obj;
15819 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15820 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystickEvent, SWIG_NewClientData(obj));
15821 return SWIG_Py_Void();
15822 }
15823
15824 SWIGINTERN PyObject *JoystickEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15825 return SWIG_Python_InitShadowInstance(args);
15826 }
15827
15828 SWIGINTERN PyObject *_wrap_new_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15829 PyObject *resultobj = 0;
15830 wxString const &arg1_defvalue = wxPyEmptyString ;
15831 wxString *arg1 = (wxString *) &arg1_defvalue ;
15832 wxSound *result = 0 ;
15833 bool temp1 = false ;
15834 PyObject * obj0 = 0 ;
15835 char * kwnames[] = {
15836 (char *) "fileName", NULL
15837 };
15838
15839 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) SWIG_fail;
15840 if (obj0) {
15841 {
15842 arg1 = wxString_in_helper(obj0);
15843 if (arg1 == NULL) SWIG_fail;
15844 temp1 = true;
15845 }
15846 }
15847 {
15848 if (!wxPyCheckForApp()) SWIG_fail;
15849 PyThreadState* __tstate = wxPyBeginAllowThreads();
15850 result = (wxSound *)new_wxSound((wxString const &)*arg1);
15851 wxPyEndAllowThreads(__tstate);
15852 if (PyErr_Occurred()) SWIG_fail;
15853 }
15854 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_NEW | 0 );
15855 {
15856 if (temp1)
15857 delete arg1;
15858 }
15859 return resultobj;
15860 fail:
15861 {
15862 if (temp1)
15863 delete arg1;
15864 }
15865 return NULL;
15866 }
15867
15868
15869 SWIGINTERN PyObject *_wrap_new_SoundFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15870 PyObject *resultobj = 0;
15871 PyObject *arg1 = (PyObject *) 0 ;
15872 wxSound *result = 0 ;
15873 PyObject * obj0 = 0 ;
15874 char * kwnames[] = {
15875 (char *) "data", NULL
15876 };
15877
15878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) SWIG_fail;
15879 arg1 = obj0;
15880 {
15881 if (!wxPyCheckForApp()) SWIG_fail;
15882 PyThreadState* __tstate = wxPyBeginAllowThreads();
15883 result = (wxSound *)new_wxSound(arg1);
15884 wxPyEndAllowThreads(__tstate);
15885 if (PyErr_Occurred()) SWIG_fail;
15886 }
15887 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_OWN | 0 );
15888 return resultobj;
15889 fail:
15890 return NULL;
15891 }
15892
15893
15894 SWIGINTERN PyObject *_wrap_delete_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15895 PyObject *resultobj = 0;
15896 wxSound *arg1 = (wxSound *) 0 ;
15897 void *argp1 = 0 ;
15898 int res1 = 0 ;
15899 PyObject *swig_obj[1] ;
15900
15901 if (!args) SWIG_fail;
15902 swig_obj[0] = args;
15903 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, SWIG_POINTER_DISOWN | 0 );
15904 if (!SWIG_IsOK(res1)) {
15905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sound" "', expected argument " "1"" of type '" "wxSound *""'");
15906 }
15907 arg1 = reinterpret_cast< wxSound * >(argp1);
15908 {
15909 PyThreadState* __tstate = wxPyBeginAllowThreads();
15910 delete arg1;
15911
15912 wxPyEndAllowThreads(__tstate);
15913 if (PyErr_Occurred()) SWIG_fail;
15914 }
15915 resultobj = SWIG_Py_Void();
15916 return resultobj;
15917 fail:
15918 return NULL;
15919 }
15920
15921
15922 SWIGINTERN PyObject *_wrap_Sound_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15923 PyObject *resultobj = 0;
15924 wxSound *arg1 = (wxSound *) 0 ;
15925 wxString *arg2 = 0 ;
15926 bool result;
15927 void *argp1 = 0 ;
15928 int res1 = 0 ;
15929 bool temp2 = false ;
15930 PyObject * obj0 = 0 ;
15931 PyObject * obj1 = 0 ;
15932 char * kwnames[] = {
15933 (char *) "self",(char *) "fileName", NULL
15934 };
15935
15936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) SWIG_fail;
15937 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
15938 if (!SWIG_IsOK(res1)) {
15939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Create" "', expected argument " "1"" of type '" "wxSound *""'");
15940 }
15941 arg1 = reinterpret_cast< wxSound * >(argp1);
15942 {
15943 arg2 = wxString_in_helper(obj1);
15944 if (arg2 == NULL) SWIG_fail;
15945 temp2 = true;
15946 }
15947 {
15948 PyThreadState* __tstate = wxPyBeginAllowThreads();
15949 result = (bool)(arg1)->Create((wxString const &)*arg2);
15950 wxPyEndAllowThreads(__tstate);
15951 if (PyErr_Occurred()) SWIG_fail;
15952 }
15953 {
15954 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15955 }
15956 {
15957 if (temp2)
15958 delete arg2;
15959 }
15960 return resultobj;
15961 fail:
15962 {
15963 if (temp2)
15964 delete arg2;
15965 }
15966 return NULL;
15967 }
15968
15969
15970 SWIGINTERN PyObject *_wrap_Sound_CreateFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15971 PyObject *resultobj = 0;
15972 wxSound *arg1 = (wxSound *) 0 ;
15973 PyObject *arg2 = (PyObject *) 0 ;
15974 bool result;
15975 void *argp1 = 0 ;
15976 int res1 = 0 ;
15977 PyObject * obj0 = 0 ;
15978 PyObject * obj1 = 0 ;
15979 char * kwnames[] = {
15980 (char *) "self",(char *) "data", NULL
15981 };
15982
15983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) SWIG_fail;
15984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
15985 if (!SWIG_IsOK(res1)) {
15986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_CreateFromData" "', expected argument " "1"" of type '" "wxSound *""'");
15987 }
15988 arg1 = reinterpret_cast< wxSound * >(argp1);
15989 arg2 = obj1;
15990 {
15991 PyThreadState* __tstate = wxPyBeginAllowThreads();
15992 result = (bool)wxSound_CreateFromData(arg1,arg2);
15993 wxPyEndAllowThreads(__tstate);
15994 if (PyErr_Occurred()) SWIG_fail;
15995 }
15996 {
15997 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15998 }
15999 return resultobj;
16000 fail:
16001 return NULL;
16002 }
16003
16004
16005 SWIGINTERN PyObject *_wrap_Sound_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16006 PyObject *resultobj = 0;
16007 wxSound *arg1 = (wxSound *) 0 ;
16008 bool result;
16009 void *argp1 = 0 ;
16010 int res1 = 0 ;
16011 PyObject *swig_obj[1] ;
16012
16013 if (!args) SWIG_fail;
16014 swig_obj[0] = args;
16015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
16016 if (!SWIG_IsOK(res1)) {
16017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_IsOk" "', expected argument " "1"" of type '" "wxSound *""'");
16018 }
16019 arg1 = reinterpret_cast< wxSound * >(argp1);
16020 {
16021 PyThreadState* __tstate = wxPyBeginAllowThreads();
16022 result = (bool)(arg1)->IsOk();
16023 wxPyEndAllowThreads(__tstate);
16024 if (PyErr_Occurred()) SWIG_fail;
16025 }
16026 {
16027 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16028 }
16029 return resultobj;
16030 fail:
16031 return NULL;
16032 }
16033
16034
16035 SWIGINTERN PyObject *_wrap_Sound_Play(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16036 PyObject *resultobj = 0;
16037 wxSound *arg1 = (wxSound *) 0 ;
16038 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
16039 bool result;
16040 void *argp1 = 0 ;
16041 int res1 = 0 ;
16042 unsigned int val2 ;
16043 int ecode2 = 0 ;
16044 PyObject * obj0 = 0 ;
16045 PyObject * obj1 = 0 ;
16046 char * kwnames[] = {
16047 (char *) "self",(char *) "flags", NULL
16048 };
16049
16050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) SWIG_fail;
16051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
16052 if (!SWIG_IsOK(res1)) {
16053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Play" "', expected argument " "1"" of type '" "wxSound const *""'");
16054 }
16055 arg1 = reinterpret_cast< wxSound * >(argp1);
16056 if (obj1) {
16057 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
16058 if (!SWIG_IsOK(ecode2)) {
16059 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_Play" "', expected argument " "2"" of type '" "unsigned int""'");
16060 }
16061 arg2 = static_cast< unsigned int >(val2);
16062 }
16063 {
16064 if (!wxPyCheckForApp()) SWIG_fail;
16065 PyThreadState* __tstate = wxPyBeginAllowThreads();
16066 result = (bool)((wxSound const *)arg1)->Play(arg2);
16067 wxPyEndAllowThreads(__tstate);
16068 if (PyErr_Occurred()) SWIG_fail;
16069 }
16070 {
16071 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16072 }
16073 return resultobj;
16074 fail:
16075 return NULL;
16076 }
16077
16078
16079 SWIGINTERN PyObject *_wrap_Sound_PlaySound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16080 PyObject *resultobj = 0;
16081 wxString *arg1 = 0 ;
16082 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
16083 bool result;
16084 bool temp1 = false ;
16085 unsigned int val2 ;
16086 int ecode2 = 0 ;
16087 PyObject * obj0 = 0 ;
16088 PyObject * obj1 = 0 ;
16089 char * kwnames[] = {
16090 (char *) "filename",(char *) "flags", NULL
16091 };
16092
16093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) SWIG_fail;
16094 {
16095 arg1 = wxString_in_helper(obj0);
16096 if (arg1 == NULL) SWIG_fail;
16097 temp1 = true;
16098 }
16099 if (obj1) {
16100 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
16101 if (!SWIG_IsOK(ecode2)) {
16102 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_PlaySound" "', expected argument " "2"" of type '" "unsigned int""'");
16103 }
16104 arg2 = static_cast< unsigned int >(val2);
16105 }
16106 {
16107 if (!wxPyCheckForApp()) SWIG_fail;
16108 PyThreadState* __tstate = wxPyBeginAllowThreads();
16109 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
16110 wxPyEndAllowThreads(__tstate);
16111 if (PyErr_Occurred()) SWIG_fail;
16112 }
16113 {
16114 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16115 }
16116 {
16117 if (temp1)
16118 delete arg1;
16119 }
16120 return resultobj;
16121 fail:
16122 {
16123 if (temp1)
16124 delete arg1;
16125 }
16126 return NULL;
16127 }
16128
16129
16130 SWIGINTERN PyObject *_wrap_Sound_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16131 PyObject *resultobj = 0;
16132
16133 if (!SWIG_Python_UnpackTuple(args,"Sound_Stop",0,0,0)) SWIG_fail;
16134 {
16135 if (!wxPyCheckForApp()) SWIG_fail;
16136 PyThreadState* __tstate = wxPyBeginAllowThreads();
16137 wxSound::Stop();
16138 wxPyEndAllowThreads(__tstate);
16139 if (PyErr_Occurred()) SWIG_fail;
16140 }
16141 resultobj = SWIG_Py_Void();
16142 return resultobj;
16143 fail:
16144 return NULL;
16145 }
16146
16147
16148 SWIGINTERN PyObject *Sound_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16149 PyObject *obj;
16150 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16151 SWIG_TypeNewClientData(SWIGTYPE_p_wxSound, SWIG_NewClientData(obj));
16152 return SWIG_Py_Void();
16153 }
16154
16155 SWIGINTERN PyObject *Sound_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16156 return SWIG_Python_InitShadowInstance(args);
16157 }
16158
16159 SWIGINTERN PyObject *_wrap_new_FileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16160 PyObject *resultobj = 0;
16161 wxString *arg1 = 0 ;
16162 wxString *arg2 = 0 ;
16163 wxString *arg3 = 0 ;
16164 wxString *arg4 = 0 ;
16165 wxFileTypeInfo *result = 0 ;
16166 bool temp1 = false ;
16167 bool temp2 = false ;
16168 bool temp3 = false ;
16169 bool temp4 = false ;
16170 PyObject * obj0 = 0 ;
16171 PyObject * obj1 = 0 ;
16172 PyObject * obj2 = 0 ;
16173 PyObject * obj3 = 0 ;
16174 char * kwnames[] = {
16175 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
16176 };
16177
16178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16179 {
16180 arg1 = wxString_in_helper(obj0);
16181 if (arg1 == NULL) SWIG_fail;
16182 temp1 = true;
16183 }
16184 {
16185 arg2 = wxString_in_helper(obj1);
16186 if (arg2 == NULL) SWIG_fail;
16187 temp2 = true;
16188 }
16189 {
16190 arg3 = wxString_in_helper(obj2);
16191 if (arg3 == NULL) SWIG_fail;
16192 temp3 = true;
16193 }
16194 {
16195 arg4 = wxString_in_helper(obj3);
16196 if (arg4 == NULL) SWIG_fail;
16197 temp4 = true;
16198 }
16199 {
16200 PyThreadState* __tstate = wxPyBeginAllowThreads();
16201 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
16202 wxPyEndAllowThreads(__tstate);
16203 if (PyErr_Occurred()) SWIG_fail;
16204 }
16205 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_NEW | 0 );
16206 {
16207 if (temp1)
16208 delete arg1;
16209 }
16210 {
16211 if (temp2)
16212 delete arg2;
16213 }
16214 {
16215 if (temp3)
16216 delete arg3;
16217 }
16218 {
16219 if (temp4)
16220 delete arg4;
16221 }
16222 return resultobj;
16223 fail:
16224 {
16225 if (temp1)
16226 delete arg1;
16227 }
16228 {
16229 if (temp2)
16230 delete arg2;
16231 }
16232 {
16233 if (temp3)
16234 delete arg3;
16235 }
16236 {
16237 if (temp4)
16238 delete arg4;
16239 }
16240 return NULL;
16241 }
16242
16243
16244 SWIGINTERN PyObject *_wrap_new_FileTypeInfoSequence(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16245 PyObject *resultobj = 0;
16246 wxArrayString *arg1 = 0 ;
16247 wxFileTypeInfo *result = 0 ;
16248 bool temp1 = false ;
16249 PyObject * obj0 = 0 ;
16250 char * kwnames[] = {
16251 (char *) "sArray", NULL
16252 };
16253
16254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) SWIG_fail;
16255 {
16256 if (! PySequence_Check(obj0)) {
16257 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
16258 SWIG_fail;
16259 }
16260 arg1 = new wxArrayString;
16261 temp1 = true;
16262 int i, len=PySequence_Length(obj0);
16263 for (i=0; i<len; i++) {
16264 PyObject* item = PySequence_GetItem(obj0, i);
16265 wxString* s = wxString_in_helper(item);
16266 if (PyErr_Occurred()) SWIG_fail;
16267 arg1->Add(*s);
16268 delete s;
16269 Py_DECREF(item);
16270 }
16271 }
16272 {
16273 PyThreadState* __tstate = wxPyBeginAllowThreads();
16274 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
16275 wxPyEndAllowThreads(__tstate);
16276 if (PyErr_Occurred()) SWIG_fail;
16277 }
16278 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
16279 {
16280 if (temp1) delete arg1;
16281 }
16282 return resultobj;
16283 fail:
16284 {
16285 if (temp1) delete arg1;
16286 }
16287 return NULL;
16288 }
16289
16290
16291 SWIGINTERN PyObject *_wrap_new_NullFileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16292 PyObject *resultobj = 0;
16293 wxFileTypeInfo *result = 0 ;
16294
16295 if (!SWIG_Python_UnpackTuple(args,"new_NullFileTypeInfo",0,0,0)) SWIG_fail;
16296 {
16297 PyThreadState* __tstate = wxPyBeginAllowThreads();
16298 result = (wxFileTypeInfo *)new wxFileTypeInfo();
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 return resultobj;
16304 fail:
16305 return NULL;
16306 }
16307
16308
16309 SWIGINTERN PyObject *_wrap_FileTypeInfo_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16310 PyObject *resultobj = 0;
16311 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16312 bool result;
16313 void *argp1 = 0 ;
16314 int res1 = 0 ;
16315 PyObject *swig_obj[1] ;
16316
16317 if (!args) SWIG_fail;
16318 swig_obj[0] = args;
16319 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16320 if (!SWIG_IsOK(res1)) {
16321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_IsValid" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16322 }
16323 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16324 {
16325 PyThreadState* __tstate = wxPyBeginAllowThreads();
16326 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
16327 wxPyEndAllowThreads(__tstate);
16328 if (PyErr_Occurred()) SWIG_fail;
16329 }
16330 {
16331 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16332 }
16333 return resultobj;
16334 fail:
16335 return NULL;
16336 }
16337
16338
16339 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16340 PyObject *resultobj = 0;
16341 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16342 wxString *arg2 = 0 ;
16343 int arg3 = (int) 0 ;
16344 void *argp1 = 0 ;
16345 int res1 = 0 ;
16346 bool temp2 = false ;
16347 int val3 ;
16348 int ecode3 = 0 ;
16349 PyObject * obj0 = 0 ;
16350 PyObject * obj1 = 0 ;
16351 PyObject * obj2 = 0 ;
16352 char * kwnames[] = {
16353 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
16354 };
16355
16356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16357 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16358 if (!SWIG_IsOK(res1)) {
16359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
16360 }
16361 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16362 {
16363 arg2 = wxString_in_helper(obj1);
16364 if (arg2 == NULL) SWIG_fail;
16365 temp2 = true;
16366 }
16367 if (obj2) {
16368 ecode3 = SWIG_AsVal_int(obj2, &val3);
16369 if (!SWIG_IsOK(ecode3)) {
16370 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "3"" of type '" "int""'");
16371 }
16372 arg3 = static_cast< int >(val3);
16373 }
16374 {
16375 PyThreadState* __tstate = wxPyBeginAllowThreads();
16376 (arg1)->SetIcon((wxString const &)*arg2,arg3);
16377 wxPyEndAllowThreads(__tstate);
16378 if (PyErr_Occurred()) SWIG_fail;
16379 }
16380 resultobj = SWIG_Py_Void();
16381 {
16382 if (temp2)
16383 delete arg2;
16384 }
16385 return resultobj;
16386 fail:
16387 {
16388 if (temp2)
16389 delete arg2;
16390 }
16391 return NULL;
16392 }
16393
16394
16395 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16396 PyObject *resultobj = 0;
16397 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16398 wxString *arg2 = 0 ;
16399 void *argp1 = 0 ;
16400 int res1 = 0 ;
16401 bool temp2 = false ;
16402 PyObject * obj0 = 0 ;
16403 PyObject * obj1 = 0 ;
16404 char * kwnames[] = {
16405 (char *) "self",(char *) "shortDesc", NULL
16406 };
16407
16408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) SWIG_fail;
16409 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16410 if (!SWIG_IsOK(res1)) {
16411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
16412 }
16413 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16414 {
16415 arg2 = wxString_in_helper(obj1);
16416 if (arg2 == NULL) SWIG_fail;
16417 temp2 = true;
16418 }
16419 {
16420 PyThreadState* __tstate = wxPyBeginAllowThreads();
16421 (arg1)->SetShortDesc((wxString const &)*arg2);
16422 wxPyEndAllowThreads(__tstate);
16423 if (PyErr_Occurred()) SWIG_fail;
16424 }
16425 resultobj = SWIG_Py_Void();
16426 {
16427 if (temp2)
16428 delete arg2;
16429 }
16430 return resultobj;
16431 fail:
16432 {
16433 if (temp2)
16434 delete arg2;
16435 }
16436 return NULL;
16437 }
16438
16439
16440 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16441 PyObject *resultobj = 0;
16442 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16443 wxString *result = 0 ;
16444 void *argp1 = 0 ;
16445 int res1 = 0 ;
16446 PyObject *swig_obj[1] ;
16447
16448 if (!args) SWIG_fail;
16449 swig_obj[0] = args;
16450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16451 if (!SWIG_IsOK(res1)) {
16452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetMimeType" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16453 }
16454 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16455 {
16456 PyThreadState* __tstate = wxPyBeginAllowThreads();
16457 {
16458 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
16459 result = (wxString *) &_result_ref;
16460 }
16461 wxPyEndAllowThreads(__tstate);
16462 if (PyErr_Occurred()) SWIG_fail;
16463 }
16464 {
16465 #if wxUSE_UNICODE
16466 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16467 #else
16468 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16469 #endif
16470 }
16471 return resultobj;
16472 fail:
16473 return NULL;
16474 }
16475
16476
16477 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16478 PyObject *resultobj = 0;
16479 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16480 wxString *result = 0 ;
16481 void *argp1 = 0 ;
16482 int res1 = 0 ;
16483 PyObject *swig_obj[1] ;
16484
16485 if (!args) SWIG_fail;
16486 swig_obj[0] = args;
16487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16488 if (!SWIG_IsOK(res1)) {
16489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16490 }
16491 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16492 {
16493 PyThreadState* __tstate = wxPyBeginAllowThreads();
16494 {
16495 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
16496 result = (wxString *) &_result_ref;
16497 }
16498 wxPyEndAllowThreads(__tstate);
16499 if (PyErr_Occurred()) SWIG_fail;
16500 }
16501 {
16502 #if wxUSE_UNICODE
16503 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16504 #else
16505 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16506 #endif
16507 }
16508 return resultobj;
16509 fail:
16510 return NULL;
16511 }
16512
16513
16514 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16515 PyObject *resultobj = 0;
16516 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16517 wxString *result = 0 ;
16518 void *argp1 = 0 ;
16519 int res1 = 0 ;
16520 PyObject *swig_obj[1] ;
16521
16522 if (!args) SWIG_fail;
16523 swig_obj[0] = args;
16524 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16525 if (!SWIG_IsOK(res1)) {
16526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16527 }
16528 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16529 {
16530 PyThreadState* __tstate = wxPyBeginAllowThreads();
16531 {
16532 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
16533 result = (wxString *) &_result_ref;
16534 }
16535 wxPyEndAllowThreads(__tstate);
16536 if (PyErr_Occurred()) SWIG_fail;
16537 }
16538 {
16539 #if wxUSE_UNICODE
16540 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16541 #else
16542 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16543 #endif
16544 }
16545 return resultobj;
16546 fail:
16547 return NULL;
16548 }
16549
16550
16551 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16552 PyObject *resultobj = 0;
16553 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16554 wxString *result = 0 ;
16555 void *argp1 = 0 ;
16556 int res1 = 0 ;
16557 PyObject *swig_obj[1] ;
16558
16559 if (!args) SWIG_fail;
16560 swig_obj[0] = args;
16561 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16562 if (!SWIG_IsOK(res1)) {
16563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16564 }
16565 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16566 {
16567 PyThreadState* __tstate = wxPyBeginAllowThreads();
16568 {
16569 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
16570 result = (wxString *) &_result_ref;
16571 }
16572 wxPyEndAllowThreads(__tstate);
16573 if (PyErr_Occurred()) SWIG_fail;
16574 }
16575 {
16576 #if wxUSE_UNICODE
16577 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16578 #else
16579 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16580 #endif
16581 }
16582 return resultobj;
16583 fail:
16584 return NULL;
16585 }
16586
16587
16588 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16589 PyObject *resultobj = 0;
16590 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16591 wxString *result = 0 ;
16592 void *argp1 = 0 ;
16593 int res1 = 0 ;
16594 PyObject *swig_obj[1] ;
16595
16596 if (!args) SWIG_fail;
16597 swig_obj[0] = args;
16598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16599 if (!SWIG_IsOK(res1)) {
16600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetDescription" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16601 }
16602 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16603 {
16604 PyThreadState* __tstate = wxPyBeginAllowThreads();
16605 {
16606 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
16607 result = (wxString *) &_result_ref;
16608 }
16609 wxPyEndAllowThreads(__tstate);
16610 if (PyErr_Occurred()) SWIG_fail;
16611 }
16612 {
16613 #if wxUSE_UNICODE
16614 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16615 #else
16616 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16617 #endif
16618 }
16619 return resultobj;
16620 fail:
16621 return NULL;
16622 }
16623
16624
16625 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16626 PyObject *resultobj = 0;
16627 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16628 wxArrayString *result = 0 ;
16629 void *argp1 = 0 ;
16630 int res1 = 0 ;
16631 PyObject *swig_obj[1] ;
16632
16633 if (!args) SWIG_fail;
16634 swig_obj[0] = args;
16635 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16636 if (!SWIG_IsOK(res1)) {
16637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensions" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16638 }
16639 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16640 {
16641 PyThreadState* __tstate = wxPyBeginAllowThreads();
16642 {
16643 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
16644 result = (wxArrayString *) &_result_ref;
16645 }
16646 wxPyEndAllowThreads(__tstate);
16647 if (PyErr_Occurred()) SWIG_fail;
16648 }
16649 {
16650 resultobj = wxArrayString2PyList_helper(*result);
16651 }
16652 return resultobj;
16653 fail:
16654 return NULL;
16655 }
16656
16657
16658 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16659 PyObject *resultobj = 0;
16660 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16661 size_t result;
16662 void *argp1 = 0 ;
16663 int res1 = 0 ;
16664 PyObject *swig_obj[1] ;
16665
16666 if (!args) SWIG_fail;
16667 swig_obj[0] = args;
16668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16669 if (!SWIG_IsOK(res1)) {
16670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensionsCount" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16671 }
16672 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16673 {
16674 PyThreadState* __tstate = wxPyBeginAllowThreads();
16675 result = (size_t)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
16676 wxPyEndAllowThreads(__tstate);
16677 if (PyErr_Occurred()) SWIG_fail;
16678 }
16679 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
16680 return resultobj;
16681 fail:
16682 return NULL;
16683 }
16684
16685
16686 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16687 PyObject *resultobj = 0;
16688 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16689 wxString *result = 0 ;
16690 void *argp1 = 0 ;
16691 int res1 = 0 ;
16692 PyObject *swig_obj[1] ;
16693
16694 if (!args) SWIG_fail;
16695 swig_obj[0] = args;
16696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16697 if (!SWIG_IsOK(res1)) {
16698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconFile" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16699 }
16700 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16701 {
16702 PyThreadState* __tstate = wxPyBeginAllowThreads();
16703 {
16704 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
16705 result = (wxString *) &_result_ref;
16706 }
16707 wxPyEndAllowThreads(__tstate);
16708 if (PyErr_Occurred()) SWIG_fail;
16709 }
16710 {
16711 #if wxUSE_UNICODE
16712 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16713 #else
16714 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16715 #endif
16716 }
16717 return resultobj;
16718 fail:
16719 return NULL;
16720 }
16721
16722
16723 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16724 PyObject *resultobj = 0;
16725 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16726 int result;
16727 void *argp1 = 0 ;
16728 int res1 = 0 ;
16729 PyObject *swig_obj[1] ;
16730
16731 if (!args) SWIG_fail;
16732 swig_obj[0] = args;
16733 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16734 if (!SWIG_IsOK(res1)) {
16735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconIndex" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16736 }
16737 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16738 {
16739 PyThreadState* __tstate = wxPyBeginAllowThreads();
16740 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
16741 wxPyEndAllowThreads(__tstate);
16742 if (PyErr_Occurred()) SWIG_fail;
16743 }
16744 resultobj = SWIG_From_int(static_cast< int >(result));
16745 return resultobj;
16746 fail:
16747 return NULL;
16748 }
16749
16750
16751 SWIGINTERN PyObject *FileTypeInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16752 PyObject *obj;
16753 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16754 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileTypeInfo, SWIG_NewClientData(obj));
16755 return SWIG_Py_Void();
16756 }
16757
16758 SWIGINTERN PyObject *FileTypeInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16759 return SWIG_Python_InitShadowInstance(args);
16760 }
16761
16762 SWIGINTERN PyObject *_wrap_new_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16763 PyObject *resultobj = 0;
16764 wxFileTypeInfo *arg1 = 0 ;
16765 wxFileType *result = 0 ;
16766 void *argp1 = 0 ;
16767 int res1 = 0 ;
16768 PyObject * obj0 = 0 ;
16769 char * kwnames[] = {
16770 (char *) "ftInfo", NULL
16771 };
16772
16773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) SWIG_fail;
16774 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
16775 if (!SWIG_IsOK(res1)) {
16776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
16777 }
16778 if (!argp1) {
16779 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
16780 }
16781 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16782 {
16783 PyThreadState* __tstate = wxPyBeginAllowThreads();
16784 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
16785 wxPyEndAllowThreads(__tstate);
16786 if (PyErr_Occurred()) SWIG_fail;
16787 }
16788 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_NEW | 0 );
16789 return resultobj;
16790 fail:
16791 return NULL;
16792 }
16793
16794
16795 SWIGINTERN PyObject *_wrap_delete_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16796 PyObject *resultobj = 0;
16797 wxFileType *arg1 = (wxFileType *) 0 ;
16798 void *argp1 = 0 ;
16799 int res1 = 0 ;
16800 PyObject *swig_obj[1] ;
16801
16802 if (!args) SWIG_fail;
16803 swig_obj[0] = args;
16804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, SWIG_POINTER_DISOWN | 0 );
16805 if (!SWIG_IsOK(res1)) {
16806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileType" "', expected argument " "1"" of type '" "wxFileType *""'");
16807 }
16808 arg1 = reinterpret_cast< wxFileType * >(argp1);
16809 {
16810 PyThreadState* __tstate = wxPyBeginAllowThreads();
16811 delete arg1;
16812
16813 wxPyEndAllowThreads(__tstate);
16814 if (PyErr_Occurred()) SWIG_fail;
16815 }
16816 resultobj = SWIG_Py_Void();
16817 return resultobj;
16818 fail:
16819 return NULL;
16820 }
16821
16822
16823 SWIGINTERN PyObject *_wrap_FileType_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16824 PyObject *resultobj = 0;
16825 wxFileType *arg1 = (wxFileType *) 0 ;
16826 PyObject *result = 0 ;
16827 void *argp1 = 0 ;
16828 int res1 = 0 ;
16829 PyObject *swig_obj[1] ;
16830
16831 if (!args) SWIG_fail;
16832 swig_obj[0] = args;
16833 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16834 if (!SWIG_IsOK(res1)) {
16835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeType" "', expected argument " "1"" of type '" "wxFileType *""'");
16836 }
16837 arg1 = reinterpret_cast< wxFileType * >(argp1);
16838 {
16839 PyThreadState* __tstate = wxPyBeginAllowThreads();
16840 result = (PyObject *)wxFileType_GetMimeType(arg1);
16841 wxPyEndAllowThreads(__tstate);
16842 if (PyErr_Occurred()) SWIG_fail;
16843 }
16844 resultobj = result;
16845 return resultobj;
16846 fail:
16847 return NULL;
16848 }
16849
16850
16851 SWIGINTERN PyObject *_wrap_FileType_GetMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16852 PyObject *resultobj = 0;
16853 wxFileType *arg1 = (wxFileType *) 0 ;
16854 PyObject *result = 0 ;
16855 void *argp1 = 0 ;
16856 int res1 = 0 ;
16857 PyObject *swig_obj[1] ;
16858
16859 if (!args) SWIG_fail;
16860 swig_obj[0] = args;
16861 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16862 if (!SWIG_IsOK(res1)) {
16863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeTypes" "', expected argument " "1"" of type '" "wxFileType *""'");
16864 }
16865 arg1 = reinterpret_cast< wxFileType * >(argp1);
16866 {
16867 PyThreadState* __tstate = wxPyBeginAllowThreads();
16868 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
16869 wxPyEndAllowThreads(__tstate);
16870 if (PyErr_Occurred()) SWIG_fail;
16871 }
16872 resultobj = result;
16873 return resultobj;
16874 fail:
16875 return NULL;
16876 }
16877
16878
16879 SWIGINTERN PyObject *_wrap_FileType_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16880 PyObject *resultobj = 0;
16881 wxFileType *arg1 = (wxFileType *) 0 ;
16882 PyObject *result = 0 ;
16883 void *argp1 = 0 ;
16884 int res1 = 0 ;
16885 PyObject *swig_obj[1] ;
16886
16887 if (!args) SWIG_fail;
16888 swig_obj[0] = args;
16889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16890 if (!SWIG_IsOK(res1)) {
16891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetExtensions" "', expected argument " "1"" of type '" "wxFileType *""'");
16892 }
16893 arg1 = reinterpret_cast< wxFileType * >(argp1);
16894 {
16895 PyThreadState* __tstate = wxPyBeginAllowThreads();
16896 result = (PyObject *)wxFileType_GetExtensions(arg1);
16897 wxPyEndAllowThreads(__tstate);
16898 if (PyErr_Occurred()) SWIG_fail;
16899 }
16900 resultobj = result;
16901 return resultobj;
16902 fail:
16903 return NULL;
16904 }
16905
16906
16907 SWIGINTERN PyObject *_wrap_FileType_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16908 PyObject *resultobj = 0;
16909 wxFileType *arg1 = (wxFileType *) 0 ;
16910 wxIcon *result = 0 ;
16911 void *argp1 = 0 ;
16912 int res1 = 0 ;
16913 PyObject *swig_obj[1] ;
16914
16915 if (!args) SWIG_fail;
16916 swig_obj[0] = args;
16917 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16918 if (!SWIG_IsOK(res1)) {
16919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
16920 }
16921 arg1 = reinterpret_cast< wxFileType * >(argp1);
16922 {
16923 PyThreadState* __tstate = wxPyBeginAllowThreads();
16924 result = (wxIcon *)wxFileType_GetIcon(arg1);
16925 wxPyEndAllowThreads(__tstate);
16926 if (PyErr_Occurred()) SWIG_fail;
16927 }
16928 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
16929 return resultobj;
16930 fail:
16931 return NULL;
16932 }
16933
16934
16935 SWIGINTERN PyObject *_wrap_FileType_GetIconInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16936 PyObject *resultobj = 0;
16937 wxFileType *arg1 = (wxFileType *) 0 ;
16938 PyObject *result = 0 ;
16939 void *argp1 = 0 ;
16940 int res1 = 0 ;
16941 PyObject *swig_obj[1] ;
16942
16943 if (!args) SWIG_fail;
16944 swig_obj[0] = args;
16945 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16946 if (!SWIG_IsOK(res1)) {
16947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIconInfo" "', expected argument " "1"" of type '" "wxFileType *""'");
16948 }
16949 arg1 = reinterpret_cast< wxFileType * >(argp1);
16950 {
16951 PyThreadState* __tstate = wxPyBeginAllowThreads();
16952 result = (PyObject *)wxFileType_GetIconInfo(arg1);
16953 wxPyEndAllowThreads(__tstate);
16954 if (PyErr_Occurred()) SWIG_fail;
16955 }
16956 resultobj = result;
16957 return resultobj;
16958 fail:
16959 return NULL;
16960 }
16961
16962
16963 SWIGINTERN PyObject *_wrap_FileType_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16964 PyObject *resultobj = 0;
16965 wxFileType *arg1 = (wxFileType *) 0 ;
16966 PyObject *result = 0 ;
16967 void *argp1 = 0 ;
16968 int res1 = 0 ;
16969 PyObject *swig_obj[1] ;
16970
16971 if (!args) SWIG_fail;
16972 swig_obj[0] = args;
16973 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16974 if (!SWIG_IsOK(res1)) {
16975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetDescription" "', expected argument " "1"" of type '" "wxFileType *""'");
16976 }
16977 arg1 = reinterpret_cast< wxFileType * >(argp1);
16978 {
16979 PyThreadState* __tstate = wxPyBeginAllowThreads();
16980 result = (PyObject *)wxFileType_GetDescription(arg1);
16981 wxPyEndAllowThreads(__tstate);
16982 if (PyErr_Occurred()) SWIG_fail;
16983 }
16984 resultobj = result;
16985 return resultobj;
16986 fail:
16987 return NULL;
16988 }
16989
16990
16991 SWIGINTERN PyObject *_wrap_FileType_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16992 PyObject *resultobj = 0;
16993 wxFileType *arg1 = (wxFileType *) 0 ;
16994 wxString *arg2 = 0 ;
16995 wxString const &arg3_defvalue = wxPyEmptyString ;
16996 wxString *arg3 = (wxString *) &arg3_defvalue ;
16997 PyObject *result = 0 ;
16998 void *argp1 = 0 ;
16999 int res1 = 0 ;
17000 bool temp2 = false ;
17001 bool temp3 = false ;
17002 PyObject * obj0 = 0 ;
17003 PyObject * obj1 = 0 ;
17004 PyObject * obj2 = 0 ;
17005 char * kwnames[] = {
17006 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
17007 };
17008
17009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17011 if (!SWIG_IsOK(res1)) {
17012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
17013 }
17014 arg1 = reinterpret_cast< wxFileType * >(argp1);
17015 {
17016 arg2 = wxString_in_helper(obj1);
17017 if (arg2 == NULL) SWIG_fail;
17018 temp2 = true;
17019 }
17020 if (obj2) {
17021 {
17022 arg3 = wxString_in_helper(obj2);
17023 if (arg3 == NULL) SWIG_fail;
17024 temp3 = true;
17025 }
17026 }
17027 {
17028 PyThreadState* __tstate = wxPyBeginAllowThreads();
17029 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
17030 wxPyEndAllowThreads(__tstate);
17031 if (PyErr_Occurred()) SWIG_fail;
17032 }
17033 resultobj = result;
17034 {
17035 if (temp2)
17036 delete arg2;
17037 }
17038 {
17039 if (temp3)
17040 delete arg3;
17041 }
17042 return resultobj;
17043 fail:
17044 {
17045 if (temp2)
17046 delete arg2;
17047 }
17048 {
17049 if (temp3)
17050 delete arg3;
17051 }
17052 return NULL;
17053 }
17054
17055
17056 SWIGINTERN PyObject *_wrap_FileType_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17057 PyObject *resultobj = 0;
17058 wxFileType *arg1 = (wxFileType *) 0 ;
17059 wxString *arg2 = 0 ;
17060 wxString const &arg3_defvalue = wxPyEmptyString ;
17061 wxString *arg3 = (wxString *) &arg3_defvalue ;
17062 PyObject *result = 0 ;
17063 void *argp1 = 0 ;
17064 int res1 = 0 ;
17065 bool temp2 = false ;
17066 bool temp3 = false ;
17067 PyObject * obj0 = 0 ;
17068 PyObject * obj1 = 0 ;
17069 PyObject * obj2 = 0 ;
17070 char * kwnames[] = {
17071 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
17072 };
17073
17074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17076 if (!SWIG_IsOK(res1)) {
17077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
17078 }
17079 arg1 = reinterpret_cast< wxFileType * >(argp1);
17080 {
17081 arg2 = wxString_in_helper(obj1);
17082 if (arg2 == NULL) SWIG_fail;
17083 temp2 = true;
17084 }
17085 if (obj2) {
17086 {
17087 arg3 = wxString_in_helper(obj2);
17088 if (arg3 == NULL) SWIG_fail;
17089 temp3 = true;
17090 }
17091 }
17092 {
17093 PyThreadState* __tstate = wxPyBeginAllowThreads();
17094 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
17095 wxPyEndAllowThreads(__tstate);
17096 if (PyErr_Occurred()) SWIG_fail;
17097 }
17098 resultobj = result;
17099 {
17100 if (temp2)
17101 delete arg2;
17102 }
17103 {
17104 if (temp3)
17105 delete arg3;
17106 }
17107 return resultobj;
17108 fail:
17109 {
17110 if (temp2)
17111 delete arg2;
17112 }
17113 {
17114 if (temp3)
17115 delete arg3;
17116 }
17117 return NULL;
17118 }
17119
17120
17121 SWIGINTERN PyObject *_wrap_FileType_GetAllCommands(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17122 PyObject *resultobj = 0;
17123 wxFileType *arg1 = (wxFileType *) 0 ;
17124 wxString *arg2 = 0 ;
17125 wxString const &arg3_defvalue = wxPyEmptyString ;
17126 wxString *arg3 = (wxString *) &arg3_defvalue ;
17127 PyObject *result = 0 ;
17128 void *argp1 = 0 ;
17129 int res1 = 0 ;
17130 bool temp2 = false ;
17131 bool temp3 = false ;
17132 PyObject * obj0 = 0 ;
17133 PyObject * obj1 = 0 ;
17134 PyObject * obj2 = 0 ;
17135 char * kwnames[] = {
17136 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
17137 };
17138
17139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17140 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17141 if (!SWIG_IsOK(res1)) {
17142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetAllCommands" "', expected argument " "1"" of type '" "wxFileType *""'");
17143 }
17144 arg1 = reinterpret_cast< wxFileType * >(argp1);
17145 {
17146 arg2 = wxString_in_helper(obj1);
17147 if (arg2 == NULL) SWIG_fail;
17148 temp2 = true;
17149 }
17150 if (obj2) {
17151 {
17152 arg3 = wxString_in_helper(obj2);
17153 if (arg3 == NULL) SWIG_fail;
17154 temp3 = true;
17155 }
17156 }
17157 {
17158 PyThreadState* __tstate = wxPyBeginAllowThreads();
17159 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
17160 wxPyEndAllowThreads(__tstate);
17161 if (PyErr_Occurred()) SWIG_fail;
17162 }
17163 resultobj = result;
17164 {
17165 if (temp2)
17166 delete arg2;
17167 }
17168 {
17169 if (temp3)
17170 delete arg3;
17171 }
17172 return resultobj;
17173 fail:
17174 {
17175 if (temp2)
17176 delete arg2;
17177 }
17178 {
17179 if (temp3)
17180 delete arg3;
17181 }
17182 return NULL;
17183 }
17184
17185
17186 SWIGINTERN PyObject *_wrap_FileType_SetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17187 PyObject *resultobj = 0;
17188 wxFileType *arg1 = (wxFileType *) 0 ;
17189 wxString *arg2 = 0 ;
17190 wxString *arg3 = 0 ;
17191 bool arg4 = (bool) true ;
17192 bool result;
17193 void *argp1 = 0 ;
17194 int res1 = 0 ;
17195 bool temp2 = false ;
17196 bool temp3 = false ;
17197 bool val4 ;
17198 int ecode4 = 0 ;
17199 PyObject * obj0 = 0 ;
17200 PyObject * obj1 = 0 ;
17201 PyObject * obj2 = 0 ;
17202 PyObject * obj3 = 0 ;
17203 char * kwnames[] = {
17204 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
17205 };
17206
17207 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17208 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17209 if (!SWIG_IsOK(res1)) {
17210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
17211 }
17212 arg1 = reinterpret_cast< wxFileType * >(argp1);
17213 {
17214 arg2 = wxString_in_helper(obj1);
17215 if (arg2 == NULL) SWIG_fail;
17216 temp2 = true;
17217 }
17218 {
17219 arg3 = wxString_in_helper(obj2);
17220 if (arg3 == NULL) SWIG_fail;
17221 temp3 = true;
17222 }
17223 if (obj3) {
17224 ecode4 = SWIG_AsVal_bool(obj3, &val4);
17225 if (!SWIG_IsOK(ecode4)) {
17226 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileType_SetCommand" "', expected argument " "4"" of type '" "bool""'");
17227 }
17228 arg4 = static_cast< bool >(val4);
17229 }
17230 {
17231 PyThreadState* __tstate = wxPyBeginAllowThreads();
17232 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
17233 wxPyEndAllowThreads(__tstate);
17234 if (PyErr_Occurred()) SWIG_fail;
17235 }
17236 {
17237 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17238 }
17239 {
17240 if (temp2)
17241 delete arg2;
17242 }
17243 {
17244 if (temp3)
17245 delete arg3;
17246 }
17247 return resultobj;
17248 fail:
17249 {
17250 if (temp2)
17251 delete arg2;
17252 }
17253 {
17254 if (temp3)
17255 delete arg3;
17256 }
17257 return NULL;
17258 }
17259
17260
17261 SWIGINTERN PyObject *_wrap_FileType_SetDefaultIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17262 PyObject *resultobj = 0;
17263 wxFileType *arg1 = (wxFileType *) 0 ;
17264 wxString const &arg2_defvalue = wxPyEmptyString ;
17265 wxString *arg2 = (wxString *) &arg2_defvalue ;
17266 int arg3 = (int) 0 ;
17267 bool result;
17268 void *argp1 = 0 ;
17269 int res1 = 0 ;
17270 bool temp2 = false ;
17271 int val3 ;
17272 int ecode3 = 0 ;
17273 PyObject * obj0 = 0 ;
17274 PyObject * obj1 = 0 ;
17275 PyObject * obj2 = 0 ;
17276 char * kwnames[] = {
17277 (char *) "self",(char *) "cmd",(char *) "index", NULL
17278 };
17279
17280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17281 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17282 if (!SWIG_IsOK(res1)) {
17283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetDefaultIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
17284 }
17285 arg1 = reinterpret_cast< wxFileType * >(argp1);
17286 if (obj1) {
17287 {
17288 arg2 = wxString_in_helper(obj1);
17289 if (arg2 == NULL) SWIG_fail;
17290 temp2 = true;
17291 }
17292 }
17293 if (obj2) {
17294 ecode3 = SWIG_AsVal_int(obj2, &val3);
17295 if (!SWIG_IsOK(ecode3)) {
17296 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileType_SetDefaultIcon" "', expected argument " "3"" of type '" "int""'");
17297 }
17298 arg3 = static_cast< int >(val3);
17299 }
17300 {
17301 PyThreadState* __tstate = wxPyBeginAllowThreads();
17302 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
17303 wxPyEndAllowThreads(__tstate);
17304 if (PyErr_Occurred()) SWIG_fail;
17305 }
17306 {
17307 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17308 }
17309 {
17310 if (temp2)
17311 delete arg2;
17312 }
17313 return resultobj;
17314 fail:
17315 {
17316 if (temp2)
17317 delete arg2;
17318 }
17319 return NULL;
17320 }
17321
17322
17323 SWIGINTERN PyObject *_wrap_FileType_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17324 PyObject *resultobj = 0;
17325 wxFileType *arg1 = (wxFileType *) 0 ;
17326 bool result;
17327 void *argp1 = 0 ;
17328 int res1 = 0 ;
17329 PyObject *swig_obj[1] ;
17330
17331 if (!args) SWIG_fail;
17332 swig_obj[0] = args;
17333 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17334 if (!SWIG_IsOK(res1)) {
17335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_Unassociate" "', expected argument " "1"" of type '" "wxFileType *""'");
17336 }
17337 arg1 = reinterpret_cast< wxFileType * >(argp1);
17338 {
17339 PyThreadState* __tstate = wxPyBeginAllowThreads();
17340 result = (bool)(arg1)->Unassociate();
17341 wxPyEndAllowThreads(__tstate);
17342 if (PyErr_Occurred()) SWIG_fail;
17343 }
17344 {
17345 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17346 }
17347 return resultobj;
17348 fail:
17349 return NULL;
17350 }
17351
17352
17353 SWIGINTERN PyObject *_wrap_FileType_ExpandCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17354 PyObject *resultobj = 0;
17355 wxString *arg1 = 0 ;
17356 wxString *arg2 = 0 ;
17357 wxString const &arg3_defvalue = wxPyEmptyString ;
17358 wxString *arg3 = (wxString *) &arg3_defvalue ;
17359 wxString result;
17360 bool temp1 = false ;
17361 bool temp2 = false ;
17362 bool temp3 = false ;
17363 PyObject * obj0 = 0 ;
17364 PyObject * obj1 = 0 ;
17365 PyObject * obj2 = 0 ;
17366 char * kwnames[] = {
17367 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
17368 };
17369
17370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17371 {
17372 arg1 = wxString_in_helper(obj0);
17373 if (arg1 == NULL) SWIG_fail;
17374 temp1 = true;
17375 }
17376 {
17377 arg2 = wxString_in_helper(obj1);
17378 if (arg2 == NULL) SWIG_fail;
17379 temp2 = true;
17380 }
17381 if (obj2) {
17382 {
17383 arg3 = wxString_in_helper(obj2);
17384 if (arg3 == NULL) SWIG_fail;
17385 temp3 = true;
17386 }
17387 }
17388 {
17389 PyThreadState* __tstate = wxPyBeginAllowThreads();
17390 result = wxFileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
17391 wxPyEndAllowThreads(__tstate);
17392 if (PyErr_Occurred()) SWIG_fail;
17393 }
17394 {
17395 #if wxUSE_UNICODE
17396 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17397 #else
17398 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17399 #endif
17400 }
17401 {
17402 if (temp1)
17403 delete arg1;
17404 }
17405 {
17406 if (temp2)
17407 delete arg2;
17408 }
17409 {
17410 if (temp3)
17411 delete arg3;
17412 }
17413 return resultobj;
17414 fail:
17415 {
17416 if (temp1)
17417 delete arg1;
17418 }
17419 {
17420 if (temp2)
17421 delete arg2;
17422 }
17423 {
17424 if (temp3)
17425 delete arg3;
17426 }
17427 return NULL;
17428 }
17429
17430
17431 SWIGINTERN PyObject *FileType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17432 PyObject *obj;
17433 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17434 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileType, SWIG_NewClientData(obj));
17435 return SWIG_Py_Void();
17436 }
17437
17438 SWIGINTERN PyObject *FileType_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17439 return SWIG_Python_InitShadowInstance(args);
17440 }
17441
17442 SWIGINTERN int TheMimeTypesManager_set(PyObject *) {
17443 SWIG_Error(SWIG_AttributeError,"Variable TheMimeTypesManager is read-only.");
17444 return 1;
17445 }
17446
17447
17448 SWIGINTERN PyObject *TheMimeTypesManager_get(void) {
17449 PyObject *pyobj = 0;
17450
17451 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0 );
17452 return pyobj;
17453 }
17454
17455
17456 SWIGINTERN PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17457 PyObject *resultobj = 0;
17458 wxString *arg1 = 0 ;
17459 wxString *arg2 = 0 ;
17460 bool result;
17461 bool temp1 = false ;
17462 bool temp2 = false ;
17463 PyObject * obj0 = 0 ;
17464 PyObject * obj1 = 0 ;
17465 char * kwnames[] = {
17466 (char *) "mimeType",(char *) "wildcard", NULL
17467 };
17468
17469 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) SWIG_fail;
17470 {
17471 arg1 = wxString_in_helper(obj0);
17472 if (arg1 == NULL) SWIG_fail;
17473 temp1 = true;
17474 }
17475 {
17476 arg2 = wxString_in_helper(obj1);
17477 if (arg2 == NULL) SWIG_fail;
17478 temp2 = true;
17479 }
17480 {
17481 PyThreadState* __tstate = wxPyBeginAllowThreads();
17482 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
17483 wxPyEndAllowThreads(__tstate);
17484 if (PyErr_Occurred()) SWIG_fail;
17485 }
17486 {
17487 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17488 }
17489 {
17490 if (temp1)
17491 delete arg1;
17492 }
17493 {
17494 if (temp2)
17495 delete arg2;
17496 }
17497 return resultobj;
17498 fail:
17499 {
17500 if (temp1)
17501 delete arg1;
17502 }
17503 {
17504 if (temp2)
17505 delete arg2;
17506 }
17507 return NULL;
17508 }
17509
17510
17511 SWIGINTERN PyObject *_wrap_new_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17512 PyObject *resultobj = 0;
17513 wxMimeTypesManager *result = 0 ;
17514
17515 if (!SWIG_Python_UnpackTuple(args,"new_MimeTypesManager",0,0,0)) SWIG_fail;
17516 {
17517 PyThreadState* __tstate = wxPyBeginAllowThreads();
17518 result = (wxMimeTypesManager *)new wxMimeTypesManager();
17519 wxPyEndAllowThreads(__tstate);
17520 if (PyErr_Occurred()) SWIG_fail;
17521 }
17522 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_NEW | 0 );
17523 return resultobj;
17524 fail:
17525 return NULL;
17526 }
17527
17528
17529 SWIGINTERN PyObject *_wrap_MimeTypesManager_Initialize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17530 PyObject *resultobj = 0;
17531 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17532 int arg2 = (int) wxMAILCAP_ALL ;
17533 wxString const &arg3_defvalue = wxPyEmptyString ;
17534 wxString *arg3 = (wxString *) &arg3_defvalue ;
17535 void *argp1 = 0 ;
17536 int res1 = 0 ;
17537 int val2 ;
17538 int ecode2 = 0 ;
17539 bool temp3 = false ;
17540 PyObject * obj0 = 0 ;
17541 PyObject * obj1 = 0 ;
17542 PyObject * obj2 = 0 ;
17543 char * kwnames[] = {
17544 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
17545 };
17546
17547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17549 if (!SWIG_IsOK(res1)) {
17550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Initialize" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17551 }
17552 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17553 if (obj1) {
17554 ecode2 = SWIG_AsVal_int(obj1, &val2);
17555 if (!SWIG_IsOK(ecode2)) {
17556 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MimeTypesManager_Initialize" "', expected argument " "2"" of type '" "int""'");
17557 }
17558 arg2 = static_cast< int >(val2);
17559 }
17560 if (obj2) {
17561 {
17562 arg3 = wxString_in_helper(obj2);
17563 if (arg3 == NULL) SWIG_fail;
17564 temp3 = true;
17565 }
17566 }
17567 {
17568 PyThreadState* __tstate = wxPyBeginAllowThreads();
17569 (arg1)->Initialize(arg2,(wxString const &)*arg3);
17570 wxPyEndAllowThreads(__tstate);
17571 if (PyErr_Occurred()) SWIG_fail;
17572 }
17573 resultobj = SWIG_Py_Void();
17574 {
17575 if (temp3)
17576 delete arg3;
17577 }
17578 return resultobj;
17579 fail:
17580 {
17581 if (temp3)
17582 delete arg3;
17583 }
17584 return NULL;
17585 }
17586
17587
17588 SWIGINTERN PyObject *_wrap_MimeTypesManager_ClearData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17589 PyObject *resultobj = 0;
17590 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17591 void *argp1 = 0 ;
17592 int res1 = 0 ;
17593 PyObject *swig_obj[1] ;
17594
17595 if (!args) SWIG_fail;
17596 swig_obj[0] = args;
17597 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17598 if (!SWIG_IsOK(res1)) {
17599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ClearData" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17600 }
17601 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17602 {
17603 PyThreadState* __tstate = wxPyBeginAllowThreads();
17604 (arg1)->ClearData();
17605 wxPyEndAllowThreads(__tstate);
17606 if (PyErr_Occurred()) SWIG_fail;
17607 }
17608 resultobj = SWIG_Py_Void();
17609 return resultobj;
17610 fail:
17611 return NULL;
17612 }
17613
17614
17615 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17616 PyObject *resultobj = 0;
17617 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17618 wxString *arg2 = 0 ;
17619 wxFileType *result = 0 ;
17620 void *argp1 = 0 ;
17621 int res1 = 0 ;
17622 bool temp2 = false ;
17623 PyObject * obj0 = 0 ;
17624 PyObject * obj1 = 0 ;
17625 char * kwnames[] = {
17626 (char *) "self",(char *) "ext", NULL
17627 };
17628
17629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) SWIG_fail;
17630 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17631 if (!SWIG_IsOK(res1)) {
17632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromExtension" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17633 }
17634 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17635 {
17636 arg2 = wxString_in_helper(obj1);
17637 if (arg2 == NULL) SWIG_fail;
17638 temp2 = true;
17639 }
17640 {
17641 PyThreadState* __tstate = wxPyBeginAllowThreads();
17642 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
17643 wxPyEndAllowThreads(__tstate);
17644 if (PyErr_Occurred()) SWIG_fail;
17645 }
17646 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
17647 {
17648 if (temp2)
17649 delete arg2;
17650 }
17651 return resultobj;
17652 fail:
17653 {
17654 if (temp2)
17655 delete arg2;
17656 }
17657 return NULL;
17658 }
17659
17660
17661 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17662 PyObject *resultobj = 0;
17663 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17664 wxString *arg2 = 0 ;
17665 wxFileType *result = 0 ;
17666 void *argp1 = 0 ;
17667 int res1 = 0 ;
17668 bool temp2 = false ;
17669 PyObject * obj0 = 0 ;
17670 PyObject * obj1 = 0 ;
17671 char * kwnames[] = {
17672 (char *) "self",(char *) "mimeType", NULL
17673 };
17674
17675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
17676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17677 if (!SWIG_IsOK(res1)) {
17678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromMimeType" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17679 }
17680 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17681 {
17682 arg2 = wxString_in_helper(obj1);
17683 if (arg2 == NULL) SWIG_fail;
17684 temp2 = true;
17685 }
17686 {
17687 PyThreadState* __tstate = wxPyBeginAllowThreads();
17688 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
17689 wxPyEndAllowThreads(__tstate);
17690 if (PyErr_Occurred()) SWIG_fail;
17691 }
17692 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
17693 {
17694 if (temp2)
17695 delete arg2;
17696 }
17697 return resultobj;
17698 fail:
17699 {
17700 if (temp2)
17701 delete arg2;
17702 }
17703 return NULL;
17704 }
17705
17706
17707 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17708 PyObject *resultobj = 0;
17709 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17710 wxString *arg2 = 0 ;
17711 bool arg3 = (bool) false ;
17712 bool result;
17713 void *argp1 = 0 ;
17714 int res1 = 0 ;
17715 bool temp2 = false ;
17716 bool val3 ;
17717 int ecode3 = 0 ;
17718 PyObject * obj0 = 0 ;
17719 PyObject * obj1 = 0 ;
17720 PyObject * obj2 = 0 ;
17721 char * kwnames[] = {
17722 (char *) "self",(char *) "filename",(char *) "fallback", NULL
17723 };
17724
17725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17726 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17727 if (!SWIG_IsOK(res1)) {
17728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17729 }
17730 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17731 {
17732 arg2 = wxString_in_helper(obj1);
17733 if (arg2 == NULL) SWIG_fail;
17734 temp2 = true;
17735 }
17736 if (obj2) {
17737 ecode3 = SWIG_AsVal_bool(obj2, &val3);
17738 if (!SWIG_IsOK(ecode3)) {
17739 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "3"" of type '" "bool""'");
17740 }
17741 arg3 = static_cast< bool >(val3);
17742 }
17743 {
17744 PyThreadState* __tstate = wxPyBeginAllowThreads();
17745 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
17746 wxPyEndAllowThreads(__tstate);
17747 if (PyErr_Occurred()) SWIG_fail;
17748 }
17749 {
17750 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17751 }
17752 {
17753 if (temp2)
17754 delete arg2;
17755 }
17756 return resultobj;
17757 fail:
17758 {
17759 if (temp2)
17760 delete arg2;
17761 }
17762 return NULL;
17763 }
17764
17765
17766 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17767 PyObject *resultobj = 0;
17768 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17769 wxString *arg2 = 0 ;
17770 bool result;
17771 void *argp1 = 0 ;
17772 int res1 = 0 ;
17773 bool temp2 = false ;
17774 PyObject * obj0 = 0 ;
17775 PyObject * obj1 = 0 ;
17776 char * kwnames[] = {
17777 (char *) "self",(char *) "filename", NULL
17778 };
17779
17780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) SWIG_fail;
17781 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17782 if (!SWIG_IsOK(res1)) {
17783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMimeTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17784 }
17785 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17786 {
17787 arg2 = wxString_in_helper(obj1);
17788 if (arg2 == NULL) SWIG_fail;
17789 temp2 = true;
17790 }
17791 {
17792 PyThreadState* __tstate = wxPyBeginAllowThreads();
17793 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
17794 wxPyEndAllowThreads(__tstate);
17795 if (PyErr_Occurred()) SWIG_fail;
17796 }
17797 {
17798 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17799 }
17800 {
17801 if (temp2)
17802 delete arg2;
17803 }
17804 return resultobj;
17805 fail:
17806 {
17807 if (temp2)
17808 delete arg2;
17809 }
17810 return NULL;
17811 }
17812
17813
17814 SWIGINTERN PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17815 PyObject *resultobj = 0;
17816 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17817 PyObject *result = 0 ;
17818 void *argp1 = 0 ;
17819 int res1 = 0 ;
17820 PyObject *swig_obj[1] ;
17821
17822 if (!args) SWIG_fail;
17823 swig_obj[0] = args;
17824 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17825 if (!SWIG_IsOK(res1)) {
17826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_EnumAllFileTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17827 }
17828 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17829 {
17830 PyThreadState* __tstate = wxPyBeginAllowThreads();
17831 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
17832 wxPyEndAllowThreads(__tstate);
17833 if (PyErr_Occurred()) SWIG_fail;
17834 }
17835 resultobj = result;
17836 return resultobj;
17837 fail:
17838 return NULL;
17839 }
17840
17841
17842 SWIGINTERN PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17843 PyObject *resultobj = 0;
17844 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17845 wxFileTypeInfo *arg2 = 0 ;
17846 void *argp1 = 0 ;
17847 int res1 = 0 ;
17848 void *argp2 = 0 ;
17849 int res2 = 0 ;
17850 PyObject * obj0 = 0 ;
17851 PyObject * obj1 = 0 ;
17852 char * kwnames[] = {
17853 (char *) "self",(char *) "ft", NULL
17854 };
17855
17856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) SWIG_fail;
17857 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17858 if (!SWIG_IsOK(res1)) {
17859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17860 }
17861 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17862 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
17863 if (!SWIG_IsOK(res2)) {
17864 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
17865 }
17866 if (!argp2) {
17867 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
17868 }
17869 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
17870 {
17871 PyThreadState* __tstate = wxPyBeginAllowThreads();
17872 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
17873 wxPyEndAllowThreads(__tstate);
17874 if (PyErr_Occurred()) SWIG_fail;
17875 }
17876 resultobj = SWIG_Py_Void();
17877 return resultobj;
17878 fail:
17879 return NULL;
17880 }
17881
17882
17883 SWIGINTERN PyObject *_wrap_MimeTypesManager_Associate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17884 PyObject *resultobj = 0;
17885 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17886 wxFileTypeInfo *arg2 = 0 ;
17887 wxFileType *result = 0 ;
17888 void *argp1 = 0 ;
17889 int res1 = 0 ;
17890 void *argp2 = 0 ;
17891 int res2 = 0 ;
17892 PyObject * obj0 = 0 ;
17893 PyObject * obj1 = 0 ;
17894 char * kwnames[] = {
17895 (char *) "self",(char *) "ftInfo", NULL
17896 };
17897
17898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) SWIG_fail;
17899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17900 if (!SWIG_IsOK(res1)) {
17901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Associate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17902 }
17903 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17904 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
17905 if (!SWIG_IsOK(res2)) {
17906 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
17907 }
17908 if (!argp2) {
17909 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
17910 }
17911 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
17912 {
17913 PyThreadState* __tstate = wxPyBeginAllowThreads();
17914 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
17915 wxPyEndAllowThreads(__tstate);
17916 if (PyErr_Occurred()) SWIG_fail;
17917 }
17918 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
17919 return resultobj;
17920 fail:
17921 return NULL;
17922 }
17923
17924
17925 SWIGINTERN PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17926 PyObject *resultobj = 0;
17927 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17928 wxFileType *arg2 = (wxFileType *) 0 ;
17929 bool result;
17930 void *argp1 = 0 ;
17931 int res1 = 0 ;
17932 void *argp2 = 0 ;
17933 int res2 = 0 ;
17934 PyObject * obj0 = 0 ;
17935 PyObject * obj1 = 0 ;
17936 char * kwnames[] = {
17937 (char *) "self",(char *) "ft", NULL
17938 };
17939
17940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) SWIG_fail;
17941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17942 if (!SWIG_IsOK(res1)) {
17943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17944 }
17945 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17946 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFileType, 0 | 0 );
17947 if (!SWIG_IsOK(res2)) {
17948 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "2"" of type '" "wxFileType *""'");
17949 }
17950 arg2 = reinterpret_cast< wxFileType * >(argp2);
17951 {
17952 PyThreadState* __tstate = wxPyBeginAllowThreads();
17953 result = (bool)(arg1)->Unassociate(arg2);
17954 wxPyEndAllowThreads(__tstate);
17955 if (PyErr_Occurred()) SWIG_fail;
17956 }
17957 {
17958 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17959 }
17960 return resultobj;
17961 fail:
17962 return NULL;
17963 }
17964
17965
17966 SWIGINTERN PyObject *_wrap_delete_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17967 PyObject *resultobj = 0;
17968 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17969 void *argp1 = 0 ;
17970 int res1 = 0 ;
17971 PyObject *swig_obj[1] ;
17972
17973 if (!args) SWIG_fail;
17974 swig_obj[0] = args;
17975 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_DISOWN | 0 );
17976 if (!SWIG_IsOK(res1)) {
17977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MimeTypesManager" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17978 }
17979 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17980 {
17981 PyThreadState* __tstate = wxPyBeginAllowThreads();
17982 delete arg1;
17983
17984 wxPyEndAllowThreads(__tstate);
17985 if (PyErr_Occurred()) SWIG_fail;
17986 }
17987 resultobj = SWIG_Py_Void();
17988 return resultobj;
17989 fail:
17990 return NULL;
17991 }
17992
17993
17994 SWIGINTERN PyObject *MimeTypesManager_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17995 PyObject *obj;
17996 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17997 SWIG_TypeNewClientData(SWIGTYPE_p_wxMimeTypesManager, SWIG_NewClientData(obj));
17998 return SWIG_Py_Void();
17999 }
18000
18001 SWIGINTERN PyObject *MimeTypesManager_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18002 return SWIG_Python_InitShadowInstance(args);
18003 }
18004
18005 SWIGINTERN int ART_TOOLBAR_set(PyObject *) {
18006 SWIG_Error(SWIG_AttributeError,"Variable ART_TOOLBAR is read-only.");
18007 return 1;
18008 }
18009
18010
18011 SWIGINTERN PyObject *ART_TOOLBAR_get(void) {
18012 PyObject *pyobj = 0;
18013
18014 {
18015 #if wxUSE_UNICODE
18016 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
18017 #else
18018 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
18019 #endif
18020 }
18021 return pyobj;
18022 }
18023
18024
18025 SWIGINTERN int ART_MENU_set(PyObject *) {
18026 SWIG_Error(SWIG_AttributeError,"Variable ART_MENU is read-only.");
18027 return 1;
18028 }
18029
18030
18031 SWIGINTERN PyObject *ART_MENU_get(void) {
18032 PyObject *pyobj = 0;
18033
18034 {
18035 #if wxUSE_UNICODE
18036 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
18037 #else
18038 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
18039 #endif
18040 }
18041 return pyobj;
18042 }
18043
18044
18045 SWIGINTERN int ART_FRAME_ICON_set(PyObject *) {
18046 SWIG_Error(SWIG_AttributeError,"Variable ART_FRAME_ICON is read-only.");
18047 return 1;
18048 }
18049
18050
18051 SWIGINTERN PyObject *ART_FRAME_ICON_get(void) {
18052 PyObject *pyobj = 0;
18053
18054 {
18055 #if wxUSE_UNICODE
18056 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
18057 #else
18058 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
18059 #endif
18060 }
18061 return pyobj;
18062 }
18063
18064
18065 SWIGINTERN int ART_CMN_DIALOG_set(PyObject *) {
18066 SWIG_Error(SWIG_AttributeError,"Variable ART_CMN_DIALOG is read-only.");
18067 return 1;
18068 }
18069
18070
18071 SWIGINTERN PyObject *ART_CMN_DIALOG_get(void) {
18072 PyObject *pyobj = 0;
18073
18074 {
18075 #if wxUSE_UNICODE
18076 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
18077 #else
18078 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
18079 #endif
18080 }
18081 return pyobj;
18082 }
18083
18084
18085 SWIGINTERN int ART_HELP_BROWSER_set(PyObject *) {
18086 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BROWSER is read-only.");
18087 return 1;
18088 }
18089
18090
18091 SWIGINTERN PyObject *ART_HELP_BROWSER_get(void) {
18092 PyObject *pyobj = 0;
18093
18094 {
18095 #if wxUSE_UNICODE
18096 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
18097 #else
18098 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
18099 #endif
18100 }
18101 return pyobj;
18102 }
18103
18104
18105 SWIGINTERN int ART_MESSAGE_BOX_set(PyObject *) {
18106 SWIG_Error(SWIG_AttributeError,"Variable ART_MESSAGE_BOX is read-only.");
18107 return 1;
18108 }
18109
18110
18111 SWIGINTERN PyObject *ART_MESSAGE_BOX_get(void) {
18112 PyObject *pyobj = 0;
18113
18114 {
18115 #if wxUSE_UNICODE
18116 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
18117 #else
18118 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
18119 #endif
18120 }
18121 return pyobj;
18122 }
18123
18124
18125 SWIGINTERN int ART_BUTTON_set(PyObject *) {
18126 SWIG_Error(SWIG_AttributeError,"Variable ART_BUTTON is read-only.");
18127 return 1;
18128 }
18129
18130
18131 SWIGINTERN PyObject *ART_BUTTON_get(void) {
18132 PyObject *pyobj = 0;
18133
18134 {
18135 #if wxUSE_UNICODE
18136 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
18137 #else
18138 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
18139 #endif
18140 }
18141 return pyobj;
18142 }
18143
18144
18145 SWIGINTERN int ART_OTHER_set(PyObject *) {
18146 SWIG_Error(SWIG_AttributeError,"Variable ART_OTHER is read-only.");
18147 return 1;
18148 }
18149
18150
18151 SWIGINTERN PyObject *ART_OTHER_get(void) {
18152 PyObject *pyobj = 0;
18153
18154 {
18155 #if wxUSE_UNICODE
18156 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
18157 #else
18158 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
18159 #endif
18160 }
18161 return pyobj;
18162 }
18163
18164
18165 SWIGINTERN int ART_ADD_BOOKMARK_set(PyObject *) {
18166 SWIG_Error(SWIG_AttributeError,"Variable ART_ADD_BOOKMARK is read-only.");
18167 return 1;
18168 }
18169
18170
18171 SWIGINTERN PyObject *ART_ADD_BOOKMARK_get(void) {
18172 PyObject *pyobj = 0;
18173
18174 {
18175 #if wxUSE_UNICODE
18176 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
18177 #else
18178 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
18179 #endif
18180 }
18181 return pyobj;
18182 }
18183
18184
18185 SWIGINTERN int ART_DEL_BOOKMARK_set(PyObject *) {
18186 SWIG_Error(SWIG_AttributeError,"Variable ART_DEL_BOOKMARK is read-only.");
18187 return 1;
18188 }
18189
18190
18191 SWIGINTERN PyObject *ART_DEL_BOOKMARK_get(void) {
18192 PyObject *pyobj = 0;
18193
18194 {
18195 #if wxUSE_UNICODE
18196 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
18197 #else
18198 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
18199 #endif
18200 }
18201 return pyobj;
18202 }
18203
18204
18205 SWIGINTERN int ART_HELP_SIDE_PANEL_set(PyObject *) {
18206 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
18207 return 1;
18208 }
18209
18210
18211 SWIGINTERN PyObject *ART_HELP_SIDE_PANEL_get(void) {
18212 PyObject *pyobj = 0;
18213
18214 {
18215 #if wxUSE_UNICODE
18216 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
18217 #else
18218 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
18219 #endif
18220 }
18221 return pyobj;
18222 }
18223
18224
18225 SWIGINTERN int ART_HELP_SETTINGS_set(PyObject *) {
18226 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SETTINGS is read-only.");
18227 return 1;
18228 }
18229
18230
18231 SWIGINTERN PyObject *ART_HELP_SETTINGS_get(void) {
18232 PyObject *pyobj = 0;
18233
18234 {
18235 #if wxUSE_UNICODE
18236 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
18237 #else
18238 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
18239 #endif
18240 }
18241 return pyobj;
18242 }
18243
18244
18245 SWIGINTERN int ART_HELP_BOOK_set(PyObject *) {
18246 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BOOK is read-only.");
18247 return 1;
18248 }
18249
18250
18251 SWIGINTERN PyObject *ART_HELP_BOOK_get(void) {
18252 PyObject *pyobj = 0;
18253
18254 {
18255 #if wxUSE_UNICODE
18256 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
18257 #else
18258 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
18259 #endif
18260 }
18261 return pyobj;
18262 }
18263
18264
18265 SWIGINTERN int ART_HELP_FOLDER_set(PyObject *) {
18266 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_FOLDER is read-only.");
18267 return 1;
18268 }
18269
18270
18271 SWIGINTERN PyObject *ART_HELP_FOLDER_get(void) {
18272 PyObject *pyobj = 0;
18273
18274 {
18275 #if wxUSE_UNICODE
18276 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
18277 #else
18278 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
18279 #endif
18280 }
18281 return pyobj;
18282 }
18283
18284
18285 SWIGINTERN int ART_HELP_PAGE_set(PyObject *) {
18286 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_PAGE is read-only.");
18287 return 1;
18288 }
18289
18290
18291 SWIGINTERN PyObject *ART_HELP_PAGE_get(void) {
18292 PyObject *pyobj = 0;
18293
18294 {
18295 #if wxUSE_UNICODE
18296 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
18297 #else
18298 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
18299 #endif
18300 }
18301 return pyobj;
18302 }
18303
18304
18305 SWIGINTERN int ART_GO_BACK_set(PyObject *) {
18306 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_BACK is read-only.");
18307 return 1;
18308 }
18309
18310
18311 SWIGINTERN PyObject *ART_GO_BACK_get(void) {
18312 PyObject *pyobj = 0;
18313
18314 {
18315 #if wxUSE_UNICODE
18316 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
18317 #else
18318 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
18319 #endif
18320 }
18321 return pyobj;
18322 }
18323
18324
18325 SWIGINTERN int ART_GO_FORWARD_set(PyObject *) {
18326 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_FORWARD is read-only.");
18327 return 1;
18328 }
18329
18330
18331 SWIGINTERN PyObject *ART_GO_FORWARD_get(void) {
18332 PyObject *pyobj = 0;
18333
18334 {
18335 #if wxUSE_UNICODE
18336 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
18337 #else
18338 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
18339 #endif
18340 }
18341 return pyobj;
18342 }
18343
18344
18345 SWIGINTERN int ART_GO_UP_set(PyObject *) {
18346 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_UP is read-only.");
18347 return 1;
18348 }
18349
18350
18351 SWIGINTERN PyObject *ART_GO_UP_get(void) {
18352 PyObject *pyobj = 0;
18353
18354 {
18355 #if wxUSE_UNICODE
18356 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
18357 #else
18358 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
18359 #endif
18360 }
18361 return pyobj;
18362 }
18363
18364
18365 SWIGINTERN int ART_GO_DOWN_set(PyObject *) {
18366 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DOWN is read-only.");
18367 return 1;
18368 }
18369
18370
18371 SWIGINTERN PyObject *ART_GO_DOWN_get(void) {
18372 PyObject *pyobj = 0;
18373
18374 {
18375 #if wxUSE_UNICODE
18376 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
18377 #else
18378 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
18379 #endif
18380 }
18381 return pyobj;
18382 }
18383
18384
18385 SWIGINTERN int ART_GO_TO_PARENT_set(PyObject *) {
18386 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_TO_PARENT is read-only.");
18387 return 1;
18388 }
18389
18390
18391 SWIGINTERN PyObject *ART_GO_TO_PARENT_get(void) {
18392 PyObject *pyobj = 0;
18393
18394 {
18395 #if wxUSE_UNICODE
18396 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
18397 #else
18398 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
18399 #endif
18400 }
18401 return pyobj;
18402 }
18403
18404
18405 SWIGINTERN int ART_GO_HOME_set(PyObject *) {
18406 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_HOME is read-only.");
18407 return 1;
18408 }
18409
18410
18411 SWIGINTERN PyObject *ART_GO_HOME_get(void) {
18412 PyObject *pyobj = 0;
18413
18414 {
18415 #if wxUSE_UNICODE
18416 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
18417 #else
18418 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
18419 #endif
18420 }
18421 return pyobj;
18422 }
18423
18424
18425 SWIGINTERN int ART_FILE_OPEN_set(PyObject *) {
18426 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_OPEN is read-only.");
18427 return 1;
18428 }
18429
18430
18431 SWIGINTERN PyObject *ART_FILE_OPEN_get(void) {
18432 PyObject *pyobj = 0;
18433
18434 {
18435 #if wxUSE_UNICODE
18436 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
18437 #else
18438 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
18439 #endif
18440 }
18441 return pyobj;
18442 }
18443
18444
18445 SWIGINTERN int ART_FILE_SAVE_set(PyObject *) {
18446 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE is read-only.");
18447 return 1;
18448 }
18449
18450
18451 SWIGINTERN PyObject *ART_FILE_SAVE_get(void) {
18452 PyObject *pyobj = 0;
18453
18454 {
18455 #if wxUSE_UNICODE
18456 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
18457 #else
18458 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
18459 #endif
18460 }
18461 return pyobj;
18462 }
18463
18464
18465 SWIGINTERN int ART_FILE_SAVE_AS_set(PyObject *) {
18466 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE_AS is read-only.");
18467 return 1;
18468 }
18469
18470
18471 SWIGINTERN PyObject *ART_FILE_SAVE_AS_get(void) {
18472 PyObject *pyobj = 0;
18473
18474 {
18475 #if wxUSE_UNICODE
18476 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
18477 #else
18478 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
18479 #endif
18480 }
18481 return pyobj;
18482 }
18483
18484
18485 SWIGINTERN int ART_PRINT_set(PyObject *) {
18486 SWIG_Error(SWIG_AttributeError,"Variable ART_PRINT is read-only.");
18487 return 1;
18488 }
18489
18490
18491 SWIGINTERN PyObject *ART_PRINT_get(void) {
18492 PyObject *pyobj = 0;
18493
18494 {
18495 #if wxUSE_UNICODE
18496 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
18497 #else
18498 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
18499 #endif
18500 }
18501 return pyobj;
18502 }
18503
18504
18505 SWIGINTERN int ART_HELP_set(PyObject *) {
18506 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP is read-only.");
18507 return 1;
18508 }
18509
18510
18511 SWIGINTERN PyObject *ART_HELP_get(void) {
18512 PyObject *pyobj = 0;
18513
18514 {
18515 #if wxUSE_UNICODE
18516 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
18517 #else
18518 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
18519 #endif
18520 }
18521 return pyobj;
18522 }
18523
18524
18525 SWIGINTERN int ART_TIP_set(PyObject *) {
18526 SWIG_Error(SWIG_AttributeError,"Variable ART_TIP is read-only.");
18527 return 1;
18528 }
18529
18530
18531 SWIGINTERN PyObject *ART_TIP_get(void) {
18532 PyObject *pyobj = 0;
18533
18534 {
18535 #if wxUSE_UNICODE
18536 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
18537 #else
18538 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
18539 #endif
18540 }
18541 return pyobj;
18542 }
18543
18544
18545 SWIGINTERN int ART_REPORT_VIEW_set(PyObject *) {
18546 SWIG_Error(SWIG_AttributeError,"Variable ART_REPORT_VIEW is read-only.");
18547 return 1;
18548 }
18549
18550
18551 SWIGINTERN PyObject *ART_REPORT_VIEW_get(void) {
18552 PyObject *pyobj = 0;
18553
18554 {
18555 #if wxUSE_UNICODE
18556 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
18557 #else
18558 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
18559 #endif
18560 }
18561 return pyobj;
18562 }
18563
18564
18565 SWIGINTERN int ART_LIST_VIEW_set(PyObject *) {
18566 SWIG_Error(SWIG_AttributeError,"Variable ART_LIST_VIEW is read-only.");
18567 return 1;
18568 }
18569
18570
18571 SWIGINTERN PyObject *ART_LIST_VIEW_get(void) {
18572 PyObject *pyobj = 0;
18573
18574 {
18575 #if wxUSE_UNICODE
18576 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
18577 #else
18578 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
18579 #endif
18580 }
18581 return pyobj;
18582 }
18583
18584
18585 SWIGINTERN int ART_NEW_DIR_set(PyObject *) {
18586 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW_DIR is read-only.");
18587 return 1;
18588 }
18589
18590
18591 SWIGINTERN PyObject *ART_NEW_DIR_get(void) {
18592 PyObject *pyobj = 0;
18593
18594 {
18595 #if wxUSE_UNICODE
18596 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
18597 #else
18598 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
18599 #endif
18600 }
18601 return pyobj;
18602 }
18603
18604
18605 SWIGINTERN int ART_HARDDISK_set(PyObject *) {
18606 SWIG_Error(SWIG_AttributeError,"Variable ART_HARDDISK is read-only.");
18607 return 1;
18608 }
18609
18610
18611 SWIGINTERN PyObject *ART_HARDDISK_get(void) {
18612 PyObject *pyobj = 0;
18613
18614 {
18615 #if wxUSE_UNICODE
18616 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
18617 #else
18618 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
18619 #endif
18620 }
18621 return pyobj;
18622 }
18623
18624
18625 SWIGINTERN int ART_FLOPPY_set(PyObject *) {
18626 SWIG_Error(SWIG_AttributeError,"Variable ART_FLOPPY is read-only.");
18627 return 1;
18628 }
18629
18630
18631 SWIGINTERN PyObject *ART_FLOPPY_get(void) {
18632 PyObject *pyobj = 0;
18633
18634 {
18635 #if wxUSE_UNICODE
18636 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
18637 #else
18638 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
18639 #endif
18640 }
18641 return pyobj;
18642 }
18643
18644
18645 SWIGINTERN int ART_CDROM_set(PyObject *) {
18646 SWIG_Error(SWIG_AttributeError,"Variable ART_CDROM is read-only.");
18647 return 1;
18648 }
18649
18650
18651 SWIGINTERN PyObject *ART_CDROM_get(void) {
18652 PyObject *pyobj = 0;
18653
18654 {
18655 #if wxUSE_UNICODE
18656 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
18657 #else
18658 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
18659 #endif
18660 }
18661 return pyobj;
18662 }
18663
18664
18665 SWIGINTERN int ART_REMOVABLE_set(PyObject *) {
18666 SWIG_Error(SWIG_AttributeError,"Variable ART_REMOVABLE is read-only.");
18667 return 1;
18668 }
18669
18670
18671 SWIGINTERN PyObject *ART_REMOVABLE_get(void) {
18672 PyObject *pyobj = 0;
18673
18674 {
18675 #if wxUSE_UNICODE
18676 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
18677 #else
18678 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
18679 #endif
18680 }
18681 return pyobj;
18682 }
18683
18684
18685 SWIGINTERN int ART_FOLDER_set(PyObject *) {
18686 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER is read-only.");
18687 return 1;
18688 }
18689
18690
18691 SWIGINTERN PyObject *ART_FOLDER_get(void) {
18692 PyObject *pyobj = 0;
18693
18694 {
18695 #if wxUSE_UNICODE
18696 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
18697 #else
18698 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
18699 #endif
18700 }
18701 return pyobj;
18702 }
18703
18704
18705 SWIGINTERN int ART_FOLDER_OPEN_set(PyObject *) {
18706 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER_OPEN is read-only.");
18707 return 1;
18708 }
18709
18710
18711 SWIGINTERN PyObject *ART_FOLDER_OPEN_get(void) {
18712 PyObject *pyobj = 0;
18713
18714 {
18715 #if wxUSE_UNICODE
18716 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
18717 #else
18718 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
18719 #endif
18720 }
18721 return pyobj;
18722 }
18723
18724
18725 SWIGINTERN int ART_GO_DIR_UP_set(PyObject *) {
18726 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DIR_UP is read-only.");
18727 return 1;
18728 }
18729
18730
18731 SWIGINTERN PyObject *ART_GO_DIR_UP_get(void) {
18732 PyObject *pyobj = 0;
18733
18734 {
18735 #if wxUSE_UNICODE
18736 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
18737 #else
18738 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
18739 #endif
18740 }
18741 return pyobj;
18742 }
18743
18744
18745 SWIGINTERN int ART_EXECUTABLE_FILE_set(PyObject *) {
18746 SWIG_Error(SWIG_AttributeError,"Variable ART_EXECUTABLE_FILE is read-only.");
18747 return 1;
18748 }
18749
18750
18751 SWIGINTERN PyObject *ART_EXECUTABLE_FILE_get(void) {
18752 PyObject *pyobj = 0;
18753
18754 {
18755 #if wxUSE_UNICODE
18756 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
18757 #else
18758 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
18759 #endif
18760 }
18761 return pyobj;
18762 }
18763
18764
18765 SWIGINTERN int ART_NORMAL_FILE_set(PyObject *) {
18766 SWIG_Error(SWIG_AttributeError,"Variable ART_NORMAL_FILE is read-only.");
18767 return 1;
18768 }
18769
18770
18771 SWIGINTERN PyObject *ART_NORMAL_FILE_get(void) {
18772 PyObject *pyobj = 0;
18773
18774 {
18775 #if wxUSE_UNICODE
18776 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
18777 #else
18778 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
18779 #endif
18780 }
18781 return pyobj;
18782 }
18783
18784
18785 SWIGINTERN int ART_TICK_MARK_set(PyObject *) {
18786 SWIG_Error(SWIG_AttributeError,"Variable ART_TICK_MARK is read-only.");
18787 return 1;
18788 }
18789
18790
18791 SWIGINTERN PyObject *ART_TICK_MARK_get(void) {
18792 PyObject *pyobj = 0;
18793
18794 {
18795 #if wxUSE_UNICODE
18796 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
18797 #else
18798 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
18799 #endif
18800 }
18801 return pyobj;
18802 }
18803
18804
18805 SWIGINTERN int ART_CROSS_MARK_set(PyObject *) {
18806 SWIG_Error(SWIG_AttributeError,"Variable ART_CROSS_MARK is read-only.");
18807 return 1;
18808 }
18809
18810
18811 SWIGINTERN PyObject *ART_CROSS_MARK_get(void) {
18812 PyObject *pyobj = 0;
18813
18814 {
18815 #if wxUSE_UNICODE
18816 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
18817 #else
18818 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
18819 #endif
18820 }
18821 return pyobj;
18822 }
18823
18824
18825 SWIGINTERN int ART_ERROR_set(PyObject *) {
18826 SWIG_Error(SWIG_AttributeError,"Variable ART_ERROR is read-only.");
18827 return 1;
18828 }
18829
18830
18831 SWIGINTERN PyObject *ART_ERROR_get(void) {
18832 PyObject *pyobj = 0;
18833
18834 {
18835 #if wxUSE_UNICODE
18836 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
18837 #else
18838 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
18839 #endif
18840 }
18841 return pyobj;
18842 }
18843
18844
18845 SWIGINTERN int ART_QUESTION_set(PyObject *) {
18846 SWIG_Error(SWIG_AttributeError,"Variable ART_QUESTION is read-only.");
18847 return 1;
18848 }
18849
18850
18851 SWIGINTERN PyObject *ART_QUESTION_get(void) {
18852 PyObject *pyobj = 0;
18853
18854 {
18855 #if wxUSE_UNICODE
18856 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
18857 #else
18858 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
18859 #endif
18860 }
18861 return pyobj;
18862 }
18863
18864
18865 SWIGINTERN int ART_WARNING_set(PyObject *) {
18866 SWIG_Error(SWIG_AttributeError,"Variable ART_WARNING is read-only.");
18867 return 1;
18868 }
18869
18870
18871 SWIGINTERN PyObject *ART_WARNING_get(void) {
18872 PyObject *pyobj = 0;
18873
18874 {
18875 #if wxUSE_UNICODE
18876 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
18877 #else
18878 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
18879 #endif
18880 }
18881 return pyobj;
18882 }
18883
18884
18885 SWIGINTERN int ART_INFORMATION_set(PyObject *) {
18886 SWIG_Error(SWIG_AttributeError,"Variable ART_INFORMATION is read-only.");
18887 return 1;
18888 }
18889
18890
18891 SWIGINTERN PyObject *ART_INFORMATION_get(void) {
18892 PyObject *pyobj = 0;
18893
18894 {
18895 #if wxUSE_UNICODE
18896 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
18897 #else
18898 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
18899 #endif
18900 }
18901 return pyobj;
18902 }
18903
18904
18905 SWIGINTERN int ART_MISSING_IMAGE_set(PyObject *) {
18906 SWIG_Error(SWIG_AttributeError,"Variable ART_MISSING_IMAGE is read-only.");
18907 return 1;
18908 }
18909
18910
18911 SWIGINTERN PyObject *ART_MISSING_IMAGE_get(void) {
18912 PyObject *pyobj = 0;
18913
18914 {
18915 #if wxUSE_UNICODE
18916 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
18917 #else
18918 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
18919 #endif
18920 }
18921 return pyobj;
18922 }
18923
18924
18925 SWIGINTERN int ART_COPY_set(PyObject *) {
18926 SWIG_Error(SWIG_AttributeError,"Variable ART_COPY is read-only.");
18927 return 1;
18928 }
18929
18930
18931 SWIGINTERN PyObject *ART_COPY_get(void) {
18932 PyObject *pyobj = 0;
18933
18934 {
18935 #if wxUSE_UNICODE
18936 pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
18937 #else
18938 pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
18939 #endif
18940 }
18941 return pyobj;
18942 }
18943
18944
18945 SWIGINTERN int ART_CUT_set(PyObject *) {
18946 SWIG_Error(SWIG_AttributeError,"Variable ART_CUT is read-only.");
18947 return 1;
18948 }
18949
18950
18951 SWIGINTERN PyObject *ART_CUT_get(void) {
18952 PyObject *pyobj = 0;
18953
18954 {
18955 #if wxUSE_UNICODE
18956 pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
18957 #else
18958 pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
18959 #endif
18960 }
18961 return pyobj;
18962 }
18963
18964
18965 SWIGINTERN int ART_PASTE_set(PyObject *) {
18966 SWIG_Error(SWIG_AttributeError,"Variable ART_PASTE is read-only.");
18967 return 1;
18968 }
18969
18970
18971 SWIGINTERN PyObject *ART_PASTE_get(void) {
18972 PyObject *pyobj = 0;
18973
18974 {
18975 #if wxUSE_UNICODE
18976 pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
18977 #else
18978 pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
18979 #endif
18980 }
18981 return pyobj;
18982 }
18983
18984
18985 SWIGINTERN int ART_DELETE_set(PyObject *) {
18986 SWIG_Error(SWIG_AttributeError,"Variable ART_DELETE is read-only.");
18987 return 1;
18988 }
18989
18990
18991 SWIGINTERN PyObject *ART_DELETE_get(void) {
18992 PyObject *pyobj = 0;
18993
18994 {
18995 #if wxUSE_UNICODE
18996 pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
18997 #else
18998 pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
18999 #endif
19000 }
19001 return pyobj;
19002 }
19003
19004
19005 SWIGINTERN int ART_NEW_set(PyObject *) {
19006 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW is read-only.");
19007 return 1;
19008 }
19009
19010
19011 SWIGINTERN PyObject *ART_NEW_get(void) {
19012 PyObject *pyobj = 0;
19013
19014 {
19015 #if wxUSE_UNICODE
19016 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
19017 #else
19018 pyobj = PyString_FromStringAndSize((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
19019 #endif
19020 }
19021 return pyobj;
19022 }
19023
19024
19025 SWIGINTERN int ART_UNDO_set(PyObject *) {
19026 SWIG_Error(SWIG_AttributeError,"Variable ART_UNDO is read-only.");
19027 return 1;
19028 }
19029
19030
19031 SWIGINTERN PyObject *ART_UNDO_get(void) {
19032 PyObject *pyobj = 0;
19033
19034 {
19035 #if wxUSE_UNICODE
19036 pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
19037 #else
19038 pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
19039 #endif
19040 }
19041 return pyobj;
19042 }
19043
19044
19045 SWIGINTERN int ART_REDO_set(PyObject *) {
19046 SWIG_Error(SWIG_AttributeError,"Variable ART_REDO is read-only.");
19047 return 1;
19048 }
19049
19050
19051 SWIGINTERN PyObject *ART_REDO_get(void) {
19052 PyObject *pyobj = 0;
19053
19054 {
19055 #if wxUSE_UNICODE
19056 pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
19057 #else
19058 pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
19059 #endif
19060 }
19061 return pyobj;
19062 }
19063
19064
19065 SWIGINTERN int ART_QUIT_set(PyObject *) {
19066 SWIG_Error(SWIG_AttributeError,"Variable ART_QUIT is read-only.");
19067 return 1;
19068 }
19069
19070
19071 SWIGINTERN PyObject *ART_QUIT_get(void) {
19072 PyObject *pyobj = 0;
19073
19074 {
19075 #if wxUSE_UNICODE
19076 pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
19077 #else
19078 pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
19079 #endif
19080 }
19081 return pyobj;
19082 }
19083
19084
19085 SWIGINTERN int ART_FIND_set(PyObject *) {
19086 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND is read-only.");
19087 return 1;
19088 }
19089
19090
19091 SWIGINTERN PyObject *ART_FIND_get(void) {
19092 PyObject *pyobj = 0;
19093
19094 {
19095 #if wxUSE_UNICODE
19096 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
19097 #else
19098 pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
19099 #endif
19100 }
19101 return pyobj;
19102 }
19103
19104
19105 SWIGINTERN int ART_FIND_AND_REPLACE_set(PyObject *) {
19106 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND_AND_REPLACE is read-only.");
19107 return 1;
19108 }
19109
19110
19111 SWIGINTERN PyObject *ART_FIND_AND_REPLACE_get(void) {
19112 PyObject *pyobj = 0;
19113
19114 {
19115 #if wxUSE_UNICODE
19116 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
19117 #else
19118 pyobj = PyString_FromStringAndSize((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
19119 #endif
19120 }
19121 return pyobj;
19122 }
19123
19124
19125 SWIGINTERN PyObject *_wrap_new_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19126 PyObject *resultobj = 0;
19127 wxPyArtProvider *result = 0 ;
19128
19129 if (!SWIG_Python_UnpackTuple(args,"new_ArtProvider",0,0,0)) SWIG_fail;
19130 {
19131 if (!wxPyCheckForApp()) SWIG_fail;
19132 PyThreadState* __tstate = wxPyBeginAllowThreads();
19133 result = (wxPyArtProvider *)new wxPyArtProvider();
19134 wxPyEndAllowThreads(__tstate);
19135 if (PyErr_Occurred()) SWIG_fail;
19136 }
19137 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_NEW | 0 );
19138 return resultobj;
19139 fail:
19140 return NULL;
19141 }
19142
19143
19144 SWIGINTERN PyObject *_wrap_delete_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19145 PyObject *resultobj = 0;
19146 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19147 void *argp1 = 0 ;
19148 int res1 = 0 ;
19149 PyObject *swig_obj[1] ;
19150
19151 if (!args) SWIG_fail;
19152 swig_obj[0] = args;
19153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
19154 if (!SWIG_IsOK(res1)) {
19155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArtProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19156 }
19157 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
19158 {
19159 PyThreadState* __tstate = wxPyBeginAllowThreads();
19160 delete arg1;
19161
19162 wxPyEndAllowThreads(__tstate);
19163 if (PyErr_Occurred()) SWIG_fail;
19164 }
19165 resultobj = SWIG_Py_Void();
19166 return resultobj;
19167 fail:
19168 return NULL;
19169 }
19170
19171
19172 SWIGINTERN PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19173 PyObject *resultobj = 0;
19174 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19175 PyObject *arg2 = (PyObject *) 0 ;
19176 PyObject *arg3 = (PyObject *) 0 ;
19177 void *argp1 = 0 ;
19178 int res1 = 0 ;
19179 PyObject * obj0 = 0 ;
19180 PyObject * obj1 = 0 ;
19181 PyObject * obj2 = 0 ;
19182 char * kwnames[] = {
19183 (char *) "self",(char *) "self",(char *) "_class", NULL
19184 };
19185
19186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19187 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
19188 if (!SWIG_IsOK(res1)) {
19189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19190 }
19191 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
19192 arg2 = obj1;
19193 arg3 = obj2;
19194 {
19195 PyThreadState* __tstate = wxPyBeginAllowThreads();
19196 (arg1)->_setCallbackInfo(arg2,arg3);
19197 wxPyEndAllowThreads(__tstate);
19198 if (PyErr_Occurred()) SWIG_fail;
19199 }
19200 resultobj = SWIG_Py_Void();
19201 return resultobj;
19202 fail:
19203 return NULL;
19204 }
19205
19206
19207 SWIGINTERN PyObject *_wrap_ArtProvider_PushProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19208 PyObject *resultobj = 0;
19209 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19210 int res1 = 0 ;
19211 PyObject * obj0 = 0 ;
19212 char * kwnames[] = {
19213 (char *) "provider", NULL
19214 };
19215
19216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_PushProvider",kwnames,&obj0)) SWIG_fail;
19217 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
19218 if (!SWIG_IsOK(res1)) {
19219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_PushProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19220 }
19221 {
19222 PyThreadState* __tstate = wxPyBeginAllowThreads();
19223 wxPyArtProvider::PushProvider(arg1);
19224 wxPyEndAllowThreads(__tstate);
19225 if (PyErr_Occurred()) SWIG_fail;
19226 }
19227 resultobj = SWIG_Py_Void();
19228 return resultobj;
19229 fail:
19230 return NULL;
19231 }
19232
19233
19234 SWIGINTERN PyObject *_wrap_ArtProvider_PopProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19235 PyObject *resultobj = 0;
19236 bool result;
19237
19238 if (!SWIG_Python_UnpackTuple(args,"ArtProvider_PopProvider",0,0,0)) SWIG_fail;
19239 {
19240 PyThreadState* __tstate = wxPyBeginAllowThreads();
19241 result = (bool)wxPyArtProvider::PopProvider();
19242 wxPyEndAllowThreads(__tstate);
19243 if (PyErr_Occurred()) SWIG_fail;
19244 }
19245 {
19246 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19247 }
19248 return resultobj;
19249 fail:
19250 return NULL;
19251 }
19252
19253
19254 SWIGINTERN PyObject *_wrap_ArtProvider_RemoveProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19255 PyObject *resultobj = 0;
19256 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19257 bool result;
19258 void *argp1 = 0 ;
19259 int res1 = 0 ;
19260 PyObject * obj0 = 0 ;
19261 char * kwnames[] = {
19262 (char *) "provider", NULL
19263 };
19264
19265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_RemoveProvider",kwnames,&obj0)) SWIG_fail;
19266 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
19267 if (!SWIG_IsOK(res1)) {
19268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_RemoveProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19269 }
19270 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
19271 {
19272 PyThreadState* __tstate = wxPyBeginAllowThreads();
19273 result = (bool)wxPyArtProvider::RemoveProvider(arg1);
19274 wxPyEndAllowThreads(__tstate);
19275 if (PyErr_Occurred()) SWIG_fail;
19276 }
19277 {
19278 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19279 }
19280 return resultobj;
19281 fail:
19282 return NULL;
19283 }
19284
19285
19286 SWIGINTERN PyObject *_wrap_ArtProvider_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19287 PyObject *resultobj = 0;
19288 wxString *arg1 = 0 ;
19289 wxString const &arg2_defvalue = wxPyART_OTHER ;
19290 wxString *arg2 = (wxString *) &arg2_defvalue ;
19291 wxSize const &arg3_defvalue = wxDefaultSize ;
19292 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
19293 wxBitmap result;
19294 bool temp1 = false ;
19295 bool temp2 = false ;
19296 wxSize temp3 ;
19297 PyObject * obj0 = 0 ;
19298 PyObject * obj1 = 0 ;
19299 PyObject * obj2 = 0 ;
19300 char * kwnames[] = {
19301 (char *) "id",(char *) "client",(char *) "size", NULL
19302 };
19303
19304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19305 {
19306 arg1 = wxString_in_helper(obj0);
19307 if (arg1 == NULL) SWIG_fail;
19308 temp1 = true;
19309 }
19310 if (obj1) {
19311 {
19312 arg2 = wxString_in_helper(obj1);
19313 if (arg2 == NULL) SWIG_fail;
19314 temp2 = true;
19315 }
19316 }
19317 if (obj2) {
19318 {
19319 arg3 = &temp3;
19320 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
19321 }
19322 }
19323 {
19324 if (!wxPyCheckForApp()) SWIG_fail;
19325 PyThreadState* __tstate = wxPyBeginAllowThreads();
19326 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
19327 wxPyEndAllowThreads(__tstate);
19328 if (PyErr_Occurred()) SWIG_fail;
19329 }
19330 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
19331 {
19332 if (temp1)
19333 delete arg1;
19334 }
19335 {
19336 if (temp2)
19337 delete arg2;
19338 }
19339 return resultobj;
19340 fail:
19341 {
19342 if (temp1)
19343 delete arg1;
19344 }
19345 {
19346 if (temp2)
19347 delete arg2;
19348 }
19349 return NULL;
19350 }
19351
19352
19353 SWIGINTERN PyObject *_wrap_ArtProvider_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19354 PyObject *resultobj = 0;
19355 wxString *arg1 = 0 ;
19356 wxString const &arg2_defvalue = wxPyART_OTHER ;
19357 wxString *arg2 = (wxString *) &arg2_defvalue ;
19358 wxSize const &arg3_defvalue = wxDefaultSize ;
19359 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
19360 wxIcon result;
19361 bool temp1 = false ;
19362 bool temp2 = false ;
19363 wxSize temp3 ;
19364 PyObject * obj0 = 0 ;
19365 PyObject * obj1 = 0 ;
19366 PyObject * obj2 = 0 ;
19367 char * kwnames[] = {
19368 (char *) "id",(char *) "client",(char *) "size", NULL
19369 };
19370
19371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19372 {
19373 arg1 = wxString_in_helper(obj0);
19374 if (arg1 == NULL) SWIG_fail;
19375 temp1 = true;
19376 }
19377 if (obj1) {
19378 {
19379 arg2 = wxString_in_helper(obj1);
19380 if (arg2 == NULL) SWIG_fail;
19381 temp2 = true;
19382 }
19383 }
19384 if (obj2) {
19385 {
19386 arg3 = &temp3;
19387 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
19388 }
19389 }
19390 {
19391 if (!wxPyCheckForApp()) SWIG_fail;
19392 PyThreadState* __tstate = wxPyBeginAllowThreads();
19393 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
19394 wxPyEndAllowThreads(__tstate);
19395 if (PyErr_Occurred()) SWIG_fail;
19396 }
19397 resultobj = SWIG_NewPointerObj((new wxIcon(static_cast< const wxIcon& >(result))), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
19398 {
19399 if (temp1)
19400 delete arg1;
19401 }
19402 {
19403 if (temp2)
19404 delete arg2;
19405 }
19406 return resultobj;
19407 fail:
19408 {
19409 if (temp1)
19410 delete arg1;
19411 }
19412 {
19413 if (temp2)
19414 delete arg2;
19415 }
19416 return NULL;
19417 }
19418
19419
19420 SWIGINTERN PyObject *_wrap_ArtProvider_GetSizeHint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19421 PyObject *resultobj = 0;
19422 wxString *arg1 = 0 ;
19423 bool arg2 = (bool) false ;
19424 wxSize result;
19425 bool temp1 = false ;
19426 bool val2 ;
19427 int ecode2 = 0 ;
19428 PyObject * obj0 = 0 ;
19429 PyObject * obj1 = 0 ;
19430 char * kwnames[] = {
19431 (char *) "client",(char *) "platform_dependent", NULL
19432 };
19433
19434 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ArtProvider_GetSizeHint",kwnames,&obj0,&obj1)) SWIG_fail;
19435 {
19436 arg1 = wxString_in_helper(obj0);
19437 if (arg1 == NULL) SWIG_fail;
19438 temp1 = true;
19439 }
19440 if (obj1) {
19441 ecode2 = SWIG_AsVal_bool(obj1, &val2);
19442 if (!SWIG_IsOK(ecode2)) {
19443 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ArtProvider_GetSizeHint" "', expected argument " "2"" of type '" "bool""'");
19444 }
19445 arg2 = static_cast< bool >(val2);
19446 }
19447 {
19448 PyThreadState* __tstate = wxPyBeginAllowThreads();
19449 result = wxPyArtProvider::GetSizeHint((wxString const &)*arg1,arg2);
19450 wxPyEndAllowThreads(__tstate);
19451 if (PyErr_Occurred()) SWIG_fail;
19452 }
19453 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
19454 {
19455 if (temp1)
19456 delete arg1;
19457 }
19458 return resultobj;
19459 fail:
19460 {
19461 if (temp1)
19462 delete arg1;
19463 }
19464 return NULL;
19465 }
19466
19467
19468 SWIGINTERN PyObject *_wrap_ArtProvider_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19469 PyObject *resultobj = 0;
19470 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19471 void *argp1 = 0 ;
19472 int res1 = 0 ;
19473 PyObject *swig_obj[1] ;
19474
19475 if (!args) SWIG_fail;
19476 swig_obj[0] = args;
19477 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
19478 if (!SWIG_IsOK(res1)) {
19479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Destroy" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19480 }
19481 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
19482 {
19483 PyThreadState* __tstate = wxPyBeginAllowThreads();
19484 wxPyArtProvider_Destroy(arg1);
19485 wxPyEndAllowThreads(__tstate);
19486 if (PyErr_Occurred()) SWIG_fail;
19487 }
19488 resultobj = SWIG_Py_Void();
19489 return resultobj;
19490 fail:
19491 return NULL;
19492 }
19493
19494
19495 SWIGINTERN PyObject *ArtProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19496 PyObject *obj;
19497 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19498 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyArtProvider, SWIG_NewClientData(obj));
19499 return SWIG_Py_Void();
19500 }
19501
19502 SWIGINTERN PyObject *ArtProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19503 return SWIG_Python_InitShadowInstance(args);
19504 }
19505
19506 SWIGINTERN PyObject *_wrap_delete_ConfigBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19507 PyObject *resultobj = 0;
19508 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19509 void *argp1 = 0 ;
19510 int res1 = 0 ;
19511 PyObject *swig_obj[1] ;
19512
19513 if (!args) SWIG_fail;
19514 swig_obj[0] = args;
19515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
19516 if (!SWIG_IsOK(res1)) {
19517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigBase" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19518 }
19519 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19520 {
19521 PyThreadState* __tstate = wxPyBeginAllowThreads();
19522 delete arg1;
19523
19524 wxPyEndAllowThreads(__tstate);
19525 if (PyErr_Occurred()) SWIG_fail;
19526 }
19527 resultobj = SWIG_Py_Void();
19528 return resultobj;
19529 fail:
19530 return NULL;
19531 }
19532
19533
19534 SWIGINTERN PyObject *_wrap_ConfigBase_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19535 PyObject *resultobj = 0;
19536 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19537 wxConfigBase *result = 0 ;
19538 int res1 = 0 ;
19539 PyObject * obj0 = 0 ;
19540 char * kwnames[] = {
19541 (char *) "config", NULL
19542 };
19543
19544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) SWIG_fail;
19545 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
19546 if (!SWIG_IsOK(res1)) {
19547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Set" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19548 }
19549 {
19550 PyThreadState* __tstate = wxPyBeginAllowThreads();
19551 result = (wxConfigBase *)wxConfigBase::Set(arg1);
19552 wxPyEndAllowThreads(__tstate);
19553 if (PyErr_Occurred()) SWIG_fail;
19554 }
19555 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
19556 return resultobj;
19557 fail:
19558 return NULL;
19559 }
19560
19561
19562 SWIGINTERN PyObject *_wrap_ConfigBase_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19563 PyObject *resultobj = 0;
19564 bool arg1 = (bool) true ;
19565 wxConfigBase *result = 0 ;
19566 bool val1 ;
19567 int ecode1 = 0 ;
19568 PyObject * obj0 = 0 ;
19569 char * kwnames[] = {
19570 (char *) "createOnDemand", NULL
19571 };
19572
19573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) SWIG_fail;
19574 if (obj0) {
19575 ecode1 = SWIG_AsVal_bool(obj0, &val1);
19576 if (!SWIG_IsOK(ecode1)) {
19577 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ConfigBase_Get" "', expected argument " "1"" of type '" "bool""'");
19578 }
19579 arg1 = static_cast< bool >(val1);
19580 }
19581 {
19582 PyThreadState* __tstate = wxPyBeginAllowThreads();
19583 result = (wxConfigBase *)wxConfigBase::Get(arg1);
19584 wxPyEndAllowThreads(__tstate);
19585 if (PyErr_Occurred()) SWIG_fail;
19586 }
19587 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
19588 return resultobj;
19589 fail:
19590 return NULL;
19591 }
19592
19593
19594 SWIGINTERN PyObject *_wrap_ConfigBase_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19595 PyObject *resultobj = 0;
19596 wxConfigBase *result = 0 ;
19597
19598 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_Create",0,0,0)) SWIG_fail;
19599 {
19600 PyThreadState* __tstate = wxPyBeginAllowThreads();
19601 result = (wxConfigBase *)wxConfigBase::Create();
19602 wxPyEndAllowThreads(__tstate);
19603 if (PyErr_Occurred()) SWIG_fail;
19604 }
19605 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
19606 return resultobj;
19607 fail:
19608 return NULL;
19609 }
19610
19611
19612 SWIGINTERN PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19613 PyObject *resultobj = 0;
19614
19615 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_DontCreateOnDemand",0,0,0)) SWIG_fail;
19616 {
19617 PyThreadState* __tstate = wxPyBeginAllowThreads();
19618 wxConfigBase::DontCreateOnDemand();
19619 wxPyEndAllowThreads(__tstate);
19620 if (PyErr_Occurred()) SWIG_fail;
19621 }
19622 resultobj = SWIG_Py_Void();
19623 return resultobj;
19624 fail:
19625 return NULL;
19626 }
19627
19628
19629 SWIGINTERN PyObject *_wrap_ConfigBase_SetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19630 PyObject *resultobj = 0;
19631 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19632 wxString *arg2 = 0 ;
19633 void *argp1 = 0 ;
19634 int res1 = 0 ;
19635 bool temp2 = false ;
19636 PyObject * obj0 = 0 ;
19637 PyObject * obj1 = 0 ;
19638 char * kwnames[] = {
19639 (char *) "self",(char *) "path", NULL
19640 };
19641
19642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) SWIG_fail;
19643 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19644 if (!SWIG_IsOK(res1)) {
19645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetPath" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19646 }
19647 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19648 {
19649 arg2 = wxString_in_helper(obj1);
19650 if (arg2 == NULL) SWIG_fail;
19651 temp2 = true;
19652 }
19653 {
19654 PyThreadState* __tstate = wxPyBeginAllowThreads();
19655 (arg1)->SetPath((wxString const &)*arg2);
19656 wxPyEndAllowThreads(__tstate);
19657 if (PyErr_Occurred()) SWIG_fail;
19658 }
19659 resultobj = SWIG_Py_Void();
19660 {
19661 if (temp2)
19662 delete arg2;
19663 }
19664 return resultobj;
19665 fail:
19666 {
19667 if (temp2)
19668 delete arg2;
19669 }
19670 return NULL;
19671 }
19672
19673
19674 SWIGINTERN PyObject *_wrap_ConfigBase_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19675 PyObject *resultobj = 0;
19676 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19677 wxString *result = 0 ;
19678 void *argp1 = 0 ;
19679 int res1 = 0 ;
19680 PyObject *swig_obj[1] ;
19681
19682 if (!args) SWIG_fail;
19683 swig_obj[0] = args;
19684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19685 if (!SWIG_IsOK(res1)) {
19686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetPath" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
19687 }
19688 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19689 {
19690 PyThreadState* __tstate = wxPyBeginAllowThreads();
19691 {
19692 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
19693 result = (wxString *) &_result_ref;
19694 }
19695 wxPyEndAllowThreads(__tstate);
19696 if (PyErr_Occurred()) SWIG_fail;
19697 }
19698 {
19699 #if wxUSE_UNICODE
19700 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
19701 #else
19702 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
19703 #endif
19704 }
19705 return resultobj;
19706 fail:
19707 return NULL;
19708 }
19709
19710
19711 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19712 PyObject *resultobj = 0;
19713 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19714 PyObject *result = 0 ;
19715 void *argp1 = 0 ;
19716 int res1 = 0 ;
19717 PyObject *swig_obj[1] ;
19718
19719 if (!args) SWIG_fail;
19720 swig_obj[0] = args;
19721 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19722 if (!SWIG_IsOK(res1)) {
19723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19724 }
19725 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19726 {
19727 PyThreadState* __tstate = wxPyBeginAllowThreads();
19728 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
19729 wxPyEndAllowThreads(__tstate);
19730 if (PyErr_Occurred()) SWIG_fail;
19731 }
19732 resultobj = result;
19733 return resultobj;
19734 fail:
19735 return NULL;
19736 }
19737
19738
19739 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19740 PyObject *resultobj = 0;
19741 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19742 long arg2 ;
19743 PyObject *result = 0 ;
19744 void *argp1 = 0 ;
19745 int res1 = 0 ;
19746 long val2 ;
19747 int ecode2 = 0 ;
19748 PyObject * obj0 = 0 ;
19749 PyObject * obj1 = 0 ;
19750 char * kwnames[] = {
19751 (char *) "self",(char *) "index", NULL
19752 };
19753
19754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) SWIG_fail;
19755 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19756 if (!SWIG_IsOK(res1)) {
19757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19758 }
19759 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19760 ecode2 = SWIG_AsVal_long(obj1, &val2);
19761 if (!SWIG_IsOK(ecode2)) {
19762 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "2"" of type '" "long""'");
19763 }
19764 arg2 = static_cast< long >(val2);
19765 {
19766 PyThreadState* __tstate = wxPyBeginAllowThreads();
19767 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
19768 wxPyEndAllowThreads(__tstate);
19769 if (PyErr_Occurred()) SWIG_fail;
19770 }
19771 resultobj = result;
19772 return resultobj;
19773 fail:
19774 return NULL;
19775 }
19776
19777
19778 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19779 PyObject *resultobj = 0;
19780 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19781 PyObject *result = 0 ;
19782 void *argp1 = 0 ;
19783 int res1 = 0 ;
19784 PyObject *swig_obj[1] ;
19785
19786 if (!args) SWIG_fail;
19787 swig_obj[0] = args;
19788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19789 if (!SWIG_IsOK(res1)) {
19790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19791 }
19792 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19793 {
19794 PyThreadState* __tstate = wxPyBeginAllowThreads();
19795 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
19796 wxPyEndAllowThreads(__tstate);
19797 if (PyErr_Occurred()) SWIG_fail;
19798 }
19799 resultobj = result;
19800 return resultobj;
19801 fail:
19802 return NULL;
19803 }
19804
19805
19806 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19807 PyObject *resultobj = 0;
19808 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19809 long arg2 ;
19810 PyObject *result = 0 ;
19811 void *argp1 = 0 ;
19812 int res1 = 0 ;
19813 long val2 ;
19814 int ecode2 = 0 ;
19815 PyObject * obj0 = 0 ;
19816 PyObject * obj1 = 0 ;
19817 char * kwnames[] = {
19818 (char *) "self",(char *) "index", NULL
19819 };
19820
19821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) SWIG_fail;
19822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19823 if (!SWIG_IsOK(res1)) {
19824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19825 }
19826 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19827 ecode2 = SWIG_AsVal_long(obj1, &val2);
19828 if (!SWIG_IsOK(ecode2)) {
19829 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "2"" of type '" "long""'");
19830 }
19831 arg2 = static_cast< long >(val2);
19832 {
19833 PyThreadState* __tstate = wxPyBeginAllowThreads();
19834 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
19835 wxPyEndAllowThreads(__tstate);
19836 if (PyErr_Occurred()) SWIG_fail;
19837 }
19838 resultobj = result;
19839 return resultobj;
19840 fail:
19841 return NULL;
19842 }
19843
19844
19845 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19846 PyObject *resultobj = 0;
19847 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19848 bool arg2 = (bool) false ;
19849 size_t result;
19850 void *argp1 = 0 ;
19851 int res1 = 0 ;
19852 bool val2 ;
19853 int ecode2 = 0 ;
19854 PyObject * obj0 = 0 ;
19855 PyObject * obj1 = 0 ;
19856 char * kwnames[] = {
19857 (char *) "self",(char *) "recursive", NULL
19858 };
19859
19860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) SWIG_fail;
19861 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19862 if (!SWIG_IsOK(res1)) {
19863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
19864 }
19865 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19866 if (obj1) {
19867 ecode2 = SWIG_AsVal_bool(obj1, &val2);
19868 if (!SWIG_IsOK(ecode2)) {
19869 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "2"" of type '" "bool""'");
19870 }
19871 arg2 = static_cast< bool >(val2);
19872 }
19873 {
19874 PyThreadState* __tstate = wxPyBeginAllowThreads();
19875 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
19876 wxPyEndAllowThreads(__tstate);
19877 if (PyErr_Occurred()) SWIG_fail;
19878 }
19879 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
19880 return resultobj;
19881 fail:
19882 return NULL;
19883 }
19884
19885
19886 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19887 PyObject *resultobj = 0;
19888 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19889 bool arg2 = (bool) false ;
19890 size_t result;
19891 void *argp1 = 0 ;
19892 int res1 = 0 ;
19893 bool val2 ;
19894 int ecode2 = 0 ;
19895 PyObject * obj0 = 0 ;
19896 PyObject * obj1 = 0 ;
19897 char * kwnames[] = {
19898 (char *) "self",(char *) "recursive", NULL
19899 };
19900
19901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) SWIG_fail;
19902 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19903 if (!SWIG_IsOK(res1)) {
19904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
19905 }
19906 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19907 if (obj1) {
19908 ecode2 = SWIG_AsVal_bool(obj1, &val2);
19909 if (!SWIG_IsOK(ecode2)) {
19910 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "2"" of type '" "bool""'");
19911 }
19912 arg2 = static_cast< bool >(val2);
19913 }
19914 {
19915 PyThreadState* __tstate = wxPyBeginAllowThreads();
19916 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
19917 wxPyEndAllowThreads(__tstate);
19918 if (PyErr_Occurred()) SWIG_fail;
19919 }
19920 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
19921 return resultobj;
19922 fail:
19923 return NULL;
19924 }
19925
19926
19927 SWIGINTERN PyObject *_wrap_ConfigBase_HasGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19928 PyObject *resultobj = 0;
19929 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19930 wxString *arg2 = 0 ;
19931 bool result;
19932 void *argp1 = 0 ;
19933 int res1 = 0 ;
19934 bool temp2 = false ;
19935 PyObject * obj0 = 0 ;
19936 PyObject * obj1 = 0 ;
19937 char * kwnames[] = {
19938 (char *) "self",(char *) "name", NULL
19939 };
19940
19941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) SWIG_fail;
19942 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19943 if (!SWIG_IsOK(res1)) {
19944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasGroup" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
19945 }
19946 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19947 {
19948 arg2 = wxString_in_helper(obj1);
19949 if (arg2 == NULL) SWIG_fail;
19950 temp2 = true;
19951 }
19952 {
19953 PyThreadState* __tstate = wxPyBeginAllowThreads();
19954 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
19955 wxPyEndAllowThreads(__tstate);
19956 if (PyErr_Occurred()) SWIG_fail;
19957 }
19958 {
19959 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19960 }
19961 {
19962 if (temp2)
19963 delete arg2;
19964 }
19965 return resultobj;
19966 fail:
19967 {
19968 if (temp2)
19969 delete arg2;
19970 }
19971 return NULL;
19972 }
19973
19974
19975 SWIGINTERN PyObject *_wrap_ConfigBase_HasEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19976 PyObject *resultobj = 0;
19977 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19978 wxString *arg2 = 0 ;
19979 bool result;
19980 void *argp1 = 0 ;
19981 int res1 = 0 ;
19982 bool temp2 = false ;
19983 PyObject * obj0 = 0 ;
19984 PyObject * obj1 = 0 ;
19985 char * kwnames[] = {
19986 (char *) "self",(char *) "name", NULL
19987 };
19988
19989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) SWIG_fail;
19990 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19991 if (!SWIG_IsOK(res1)) {
19992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasEntry" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
19993 }
19994 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19995 {
19996 arg2 = wxString_in_helper(obj1);
19997 if (arg2 == NULL) SWIG_fail;
19998 temp2 = true;
19999 }
20000 {
20001 PyThreadState* __tstate = wxPyBeginAllowThreads();
20002 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
20003 wxPyEndAllowThreads(__tstate);
20004 if (PyErr_Occurred()) SWIG_fail;
20005 }
20006 {
20007 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20008 }
20009 {
20010 if (temp2)
20011 delete arg2;
20012 }
20013 return resultobj;
20014 fail:
20015 {
20016 if (temp2)
20017 delete arg2;
20018 }
20019 return NULL;
20020 }
20021
20022
20023 SWIGINTERN PyObject *_wrap_ConfigBase_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20024 PyObject *resultobj = 0;
20025 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20026 wxString *arg2 = 0 ;
20027 bool result;
20028 void *argp1 = 0 ;
20029 int res1 = 0 ;
20030 bool temp2 = false ;
20031 PyObject * obj0 = 0 ;
20032 PyObject * obj1 = 0 ;
20033 char * kwnames[] = {
20034 (char *) "self",(char *) "name", NULL
20035 };
20036
20037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) SWIG_fail;
20038 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20039 if (!SWIG_IsOK(res1)) {
20040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Exists" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20041 }
20042 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20043 {
20044 arg2 = wxString_in_helper(obj1);
20045 if (arg2 == NULL) SWIG_fail;
20046 temp2 = true;
20047 }
20048 {
20049 PyThreadState* __tstate = wxPyBeginAllowThreads();
20050 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
20051 wxPyEndAllowThreads(__tstate);
20052 if (PyErr_Occurred()) SWIG_fail;
20053 }
20054 {
20055 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20056 }
20057 {
20058 if (temp2)
20059 delete arg2;
20060 }
20061 return resultobj;
20062 fail:
20063 {
20064 if (temp2)
20065 delete arg2;
20066 }
20067 return NULL;
20068 }
20069
20070
20071 SWIGINTERN PyObject *_wrap_ConfigBase_GetEntryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20072 PyObject *resultobj = 0;
20073 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20074 wxString *arg2 = 0 ;
20075 wxConfigBase::EntryType result;
20076 void *argp1 = 0 ;
20077 int res1 = 0 ;
20078 bool temp2 = false ;
20079 PyObject * obj0 = 0 ;
20080 PyObject * obj1 = 0 ;
20081 char * kwnames[] = {
20082 (char *) "self",(char *) "name", NULL
20083 };
20084
20085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) SWIG_fail;
20086 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20087 if (!SWIG_IsOK(res1)) {
20088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetEntryType" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20089 }
20090 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20091 {
20092 arg2 = wxString_in_helper(obj1);
20093 if (arg2 == NULL) SWIG_fail;
20094 temp2 = true;
20095 }
20096 {
20097 PyThreadState* __tstate = wxPyBeginAllowThreads();
20098 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
20099 wxPyEndAllowThreads(__tstate);
20100 if (PyErr_Occurred()) SWIG_fail;
20101 }
20102 resultobj = SWIG_From_int(static_cast< int >(result));
20103 {
20104 if (temp2)
20105 delete arg2;
20106 }
20107 return resultobj;
20108 fail:
20109 {
20110 if (temp2)
20111 delete arg2;
20112 }
20113 return NULL;
20114 }
20115
20116
20117 SWIGINTERN PyObject *_wrap_ConfigBase_Read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20118 PyObject *resultobj = 0;
20119 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20120 wxString *arg2 = 0 ;
20121 wxString const &arg3_defvalue = wxPyEmptyString ;
20122 wxString *arg3 = (wxString *) &arg3_defvalue ;
20123 wxString result;
20124 void *argp1 = 0 ;
20125 int res1 = 0 ;
20126 bool temp2 = false ;
20127 bool temp3 = false ;
20128 PyObject * obj0 = 0 ;
20129 PyObject * obj1 = 0 ;
20130 PyObject * obj2 = 0 ;
20131 char * kwnames[] = {
20132 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
20133 };
20134
20135 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20136 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20137 if (!SWIG_IsOK(res1)) {
20138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Read" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20139 }
20140 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20141 {
20142 arg2 = wxString_in_helper(obj1);
20143 if (arg2 == NULL) SWIG_fail;
20144 temp2 = true;
20145 }
20146 if (obj2) {
20147 {
20148 arg3 = wxString_in_helper(obj2);
20149 if (arg3 == NULL) SWIG_fail;
20150 temp3 = true;
20151 }
20152 }
20153 {
20154 PyThreadState* __tstate = wxPyBeginAllowThreads();
20155 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
20156 wxPyEndAllowThreads(__tstate);
20157 if (PyErr_Occurred()) SWIG_fail;
20158 }
20159 {
20160 #if wxUSE_UNICODE
20161 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20162 #else
20163 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20164 #endif
20165 }
20166 {
20167 if (temp2)
20168 delete arg2;
20169 }
20170 {
20171 if (temp3)
20172 delete arg3;
20173 }
20174 return resultobj;
20175 fail:
20176 {
20177 if (temp2)
20178 delete arg2;
20179 }
20180 {
20181 if (temp3)
20182 delete arg3;
20183 }
20184 return NULL;
20185 }
20186
20187
20188 SWIGINTERN PyObject *_wrap_ConfigBase_ReadInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20189 PyObject *resultobj = 0;
20190 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20191 wxString *arg2 = 0 ;
20192 long arg3 = (long) 0 ;
20193 long result;
20194 void *argp1 = 0 ;
20195 int res1 = 0 ;
20196 bool temp2 = false ;
20197 long val3 ;
20198 int ecode3 = 0 ;
20199 PyObject * obj0 = 0 ;
20200 PyObject * obj1 = 0 ;
20201 PyObject * obj2 = 0 ;
20202 char * kwnames[] = {
20203 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
20204 };
20205
20206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20207 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20208 if (!SWIG_IsOK(res1)) {
20209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20210 }
20211 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20212 {
20213 arg2 = wxString_in_helper(obj1);
20214 if (arg2 == NULL) SWIG_fail;
20215 temp2 = true;
20216 }
20217 if (obj2) {
20218 ecode3 = SWIG_AsVal_long(obj2, &val3);
20219 if (!SWIG_IsOK(ecode3)) {
20220 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadInt" "', expected argument " "3"" of type '" "long""'");
20221 }
20222 arg3 = static_cast< long >(val3);
20223 }
20224 {
20225 PyThreadState* __tstate = wxPyBeginAllowThreads();
20226 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
20227 wxPyEndAllowThreads(__tstate);
20228 if (PyErr_Occurred()) SWIG_fail;
20229 }
20230 resultobj = SWIG_From_long(static_cast< long >(result));
20231 {
20232 if (temp2)
20233 delete arg2;
20234 }
20235 return resultobj;
20236 fail:
20237 {
20238 if (temp2)
20239 delete arg2;
20240 }
20241 return NULL;
20242 }
20243
20244
20245 SWIGINTERN PyObject *_wrap_ConfigBase_ReadFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20246 PyObject *resultobj = 0;
20247 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20248 wxString *arg2 = 0 ;
20249 double arg3 = (double) 0.0 ;
20250 double result;
20251 void *argp1 = 0 ;
20252 int res1 = 0 ;
20253 bool temp2 = false ;
20254 double val3 ;
20255 int ecode3 = 0 ;
20256 PyObject * obj0 = 0 ;
20257 PyObject * obj1 = 0 ;
20258 PyObject * obj2 = 0 ;
20259 char * kwnames[] = {
20260 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
20261 };
20262
20263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20264 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20265 if (!SWIG_IsOK(res1)) {
20266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20267 }
20268 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20269 {
20270 arg2 = wxString_in_helper(obj1);
20271 if (arg2 == NULL) SWIG_fail;
20272 temp2 = true;
20273 }
20274 if (obj2) {
20275 ecode3 = SWIG_AsVal_double(obj2, &val3);
20276 if (!SWIG_IsOK(ecode3)) {
20277 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadFloat" "', expected argument " "3"" of type '" "double""'");
20278 }
20279 arg3 = static_cast< double >(val3);
20280 }
20281 {
20282 PyThreadState* __tstate = wxPyBeginAllowThreads();
20283 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
20284 wxPyEndAllowThreads(__tstate);
20285 if (PyErr_Occurred()) SWIG_fail;
20286 }
20287 resultobj = SWIG_From_double(static_cast< double >(result));
20288 {
20289 if (temp2)
20290 delete arg2;
20291 }
20292 return resultobj;
20293 fail:
20294 {
20295 if (temp2)
20296 delete arg2;
20297 }
20298 return NULL;
20299 }
20300
20301
20302 SWIGINTERN PyObject *_wrap_ConfigBase_ReadBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20303 PyObject *resultobj = 0;
20304 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20305 wxString *arg2 = 0 ;
20306 bool arg3 = (bool) false ;
20307 bool result;
20308 void *argp1 = 0 ;
20309 int res1 = 0 ;
20310 bool temp2 = false ;
20311 bool val3 ;
20312 int ecode3 = 0 ;
20313 PyObject * obj0 = 0 ;
20314 PyObject * obj1 = 0 ;
20315 PyObject * obj2 = 0 ;
20316 char * kwnames[] = {
20317 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
20318 };
20319
20320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20321 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20322 if (!SWIG_IsOK(res1)) {
20323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20324 }
20325 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20326 {
20327 arg2 = wxString_in_helper(obj1);
20328 if (arg2 == NULL) SWIG_fail;
20329 temp2 = true;
20330 }
20331 if (obj2) {
20332 ecode3 = SWIG_AsVal_bool(obj2, &val3);
20333 if (!SWIG_IsOK(ecode3)) {
20334 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadBool" "', expected argument " "3"" of type '" "bool""'");
20335 }
20336 arg3 = static_cast< bool >(val3);
20337 }
20338 {
20339 PyThreadState* __tstate = wxPyBeginAllowThreads();
20340 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
20341 wxPyEndAllowThreads(__tstate);
20342 if (PyErr_Occurred()) SWIG_fail;
20343 }
20344 {
20345 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20346 }
20347 {
20348 if (temp2)
20349 delete arg2;
20350 }
20351 return resultobj;
20352 fail:
20353 {
20354 if (temp2)
20355 delete arg2;
20356 }
20357 return NULL;
20358 }
20359
20360
20361 SWIGINTERN PyObject *_wrap_ConfigBase_Write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20362 PyObject *resultobj = 0;
20363 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20364 wxString *arg2 = 0 ;
20365 wxString *arg3 = 0 ;
20366 bool result;
20367 void *argp1 = 0 ;
20368 int res1 = 0 ;
20369 bool temp2 = false ;
20370 bool temp3 = false ;
20371 PyObject * obj0 = 0 ;
20372 PyObject * obj1 = 0 ;
20373 PyObject * obj2 = 0 ;
20374 char * kwnames[] = {
20375 (char *) "self",(char *) "key",(char *) "value", NULL
20376 };
20377
20378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20379 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20380 if (!SWIG_IsOK(res1)) {
20381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Write" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20382 }
20383 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20384 {
20385 arg2 = wxString_in_helper(obj1);
20386 if (arg2 == NULL) SWIG_fail;
20387 temp2 = true;
20388 }
20389 {
20390 arg3 = wxString_in_helper(obj2);
20391 if (arg3 == NULL) SWIG_fail;
20392 temp3 = true;
20393 }
20394 {
20395 PyThreadState* __tstate = wxPyBeginAllowThreads();
20396 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
20397 wxPyEndAllowThreads(__tstate);
20398 if (PyErr_Occurred()) SWIG_fail;
20399 }
20400 {
20401 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20402 }
20403 {
20404 if (temp2)
20405 delete arg2;
20406 }
20407 {
20408 if (temp3)
20409 delete arg3;
20410 }
20411 return resultobj;
20412 fail:
20413 {
20414 if (temp2)
20415 delete arg2;
20416 }
20417 {
20418 if (temp3)
20419 delete arg3;
20420 }
20421 return NULL;
20422 }
20423
20424
20425 SWIGINTERN PyObject *_wrap_ConfigBase_WriteInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20426 PyObject *resultobj = 0;
20427 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20428 wxString *arg2 = 0 ;
20429 long arg3 ;
20430 bool result;
20431 void *argp1 = 0 ;
20432 int res1 = 0 ;
20433 bool temp2 = false ;
20434 long val3 ;
20435 int ecode3 = 0 ;
20436 PyObject * obj0 = 0 ;
20437 PyObject * obj1 = 0 ;
20438 PyObject * obj2 = 0 ;
20439 char * kwnames[] = {
20440 (char *) "self",(char *) "key",(char *) "value", NULL
20441 };
20442
20443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20444 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20445 if (!SWIG_IsOK(res1)) {
20446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20447 }
20448 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20449 {
20450 arg2 = wxString_in_helper(obj1);
20451 if (arg2 == NULL) SWIG_fail;
20452 temp2 = true;
20453 }
20454 ecode3 = SWIG_AsVal_long(obj2, &val3);
20455 if (!SWIG_IsOK(ecode3)) {
20456 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteInt" "', expected argument " "3"" of type '" "long""'");
20457 }
20458 arg3 = static_cast< long >(val3);
20459 {
20460 PyThreadState* __tstate = wxPyBeginAllowThreads();
20461 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
20462 wxPyEndAllowThreads(__tstate);
20463 if (PyErr_Occurred()) SWIG_fail;
20464 }
20465 {
20466 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20467 }
20468 {
20469 if (temp2)
20470 delete arg2;
20471 }
20472 return resultobj;
20473 fail:
20474 {
20475 if (temp2)
20476 delete arg2;
20477 }
20478 return NULL;
20479 }
20480
20481
20482 SWIGINTERN PyObject *_wrap_ConfigBase_WriteFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20483 PyObject *resultobj = 0;
20484 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20485 wxString *arg2 = 0 ;
20486 double arg3 ;
20487 bool result;
20488 void *argp1 = 0 ;
20489 int res1 = 0 ;
20490 bool temp2 = false ;
20491 double val3 ;
20492 int ecode3 = 0 ;
20493 PyObject * obj0 = 0 ;
20494 PyObject * obj1 = 0 ;
20495 PyObject * obj2 = 0 ;
20496 char * kwnames[] = {
20497 (char *) "self",(char *) "key",(char *) "value", NULL
20498 };
20499
20500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20501 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20502 if (!SWIG_IsOK(res1)) {
20503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20504 }
20505 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20506 {
20507 arg2 = wxString_in_helper(obj1);
20508 if (arg2 == NULL) SWIG_fail;
20509 temp2 = true;
20510 }
20511 ecode3 = SWIG_AsVal_double(obj2, &val3);
20512 if (!SWIG_IsOK(ecode3)) {
20513 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteFloat" "', expected argument " "3"" of type '" "double""'");
20514 }
20515 arg3 = static_cast< double >(val3);
20516 {
20517 PyThreadState* __tstate = wxPyBeginAllowThreads();
20518 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
20519 wxPyEndAllowThreads(__tstate);
20520 if (PyErr_Occurred()) SWIG_fail;
20521 }
20522 {
20523 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20524 }
20525 {
20526 if (temp2)
20527 delete arg2;
20528 }
20529 return resultobj;
20530 fail:
20531 {
20532 if (temp2)
20533 delete arg2;
20534 }
20535 return NULL;
20536 }
20537
20538
20539 SWIGINTERN PyObject *_wrap_ConfigBase_WriteBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20540 PyObject *resultobj = 0;
20541 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20542 wxString *arg2 = 0 ;
20543 bool arg3 ;
20544 bool result;
20545 void *argp1 = 0 ;
20546 int res1 = 0 ;
20547 bool temp2 = false ;
20548 bool val3 ;
20549 int ecode3 = 0 ;
20550 PyObject * obj0 = 0 ;
20551 PyObject * obj1 = 0 ;
20552 PyObject * obj2 = 0 ;
20553 char * kwnames[] = {
20554 (char *) "self",(char *) "key",(char *) "value", NULL
20555 };
20556
20557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20558 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20559 if (!SWIG_IsOK(res1)) {
20560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20561 }
20562 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20563 {
20564 arg2 = wxString_in_helper(obj1);
20565 if (arg2 == NULL) SWIG_fail;
20566 temp2 = true;
20567 }
20568 ecode3 = SWIG_AsVal_bool(obj2, &val3);
20569 if (!SWIG_IsOK(ecode3)) {
20570 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteBool" "', expected argument " "3"" of type '" "bool""'");
20571 }
20572 arg3 = static_cast< bool >(val3);
20573 {
20574 PyThreadState* __tstate = wxPyBeginAllowThreads();
20575 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
20576 wxPyEndAllowThreads(__tstate);
20577 if (PyErr_Occurred()) SWIG_fail;
20578 }
20579 {
20580 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20581 }
20582 {
20583 if (temp2)
20584 delete arg2;
20585 }
20586 return resultobj;
20587 fail:
20588 {
20589 if (temp2)
20590 delete arg2;
20591 }
20592 return NULL;
20593 }
20594
20595
20596 SWIGINTERN PyObject *_wrap_ConfigBase_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20597 PyObject *resultobj = 0;
20598 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20599 bool arg2 = (bool) false ;
20600 bool result;
20601 void *argp1 = 0 ;
20602 int res1 = 0 ;
20603 bool val2 ;
20604 int ecode2 = 0 ;
20605 PyObject * obj0 = 0 ;
20606 PyObject * obj1 = 0 ;
20607 char * kwnames[] = {
20608 (char *) "self",(char *) "currentOnly", NULL
20609 };
20610
20611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) SWIG_fail;
20612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20613 if (!SWIG_IsOK(res1)) {
20614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Flush" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20615 }
20616 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20617 if (obj1) {
20618 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20619 if (!SWIG_IsOK(ecode2)) {
20620 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_Flush" "', expected argument " "2"" of type '" "bool""'");
20621 }
20622 arg2 = static_cast< bool >(val2);
20623 }
20624 {
20625 PyThreadState* __tstate = wxPyBeginAllowThreads();
20626 result = (bool)(arg1)->Flush(arg2);
20627 wxPyEndAllowThreads(__tstate);
20628 if (PyErr_Occurred()) SWIG_fail;
20629 }
20630 {
20631 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20632 }
20633 return resultobj;
20634 fail:
20635 return NULL;
20636 }
20637
20638
20639 SWIGINTERN PyObject *_wrap_ConfigBase_RenameEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20640 PyObject *resultobj = 0;
20641 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20642 wxString *arg2 = 0 ;
20643 wxString *arg3 = 0 ;
20644 bool result;
20645 void *argp1 = 0 ;
20646 int res1 = 0 ;
20647 bool temp2 = false ;
20648 bool temp3 = false ;
20649 PyObject * obj0 = 0 ;
20650 PyObject * obj1 = 0 ;
20651 PyObject * obj2 = 0 ;
20652 char * kwnames[] = {
20653 (char *) "self",(char *) "oldName",(char *) "newName", NULL
20654 };
20655
20656 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20657 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20658 if (!SWIG_IsOK(res1)) {
20659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20660 }
20661 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20662 {
20663 arg2 = wxString_in_helper(obj1);
20664 if (arg2 == NULL) SWIG_fail;
20665 temp2 = true;
20666 }
20667 {
20668 arg3 = wxString_in_helper(obj2);
20669 if (arg3 == NULL) SWIG_fail;
20670 temp3 = true;
20671 }
20672 {
20673 PyThreadState* __tstate = wxPyBeginAllowThreads();
20674 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
20675 wxPyEndAllowThreads(__tstate);
20676 if (PyErr_Occurred()) SWIG_fail;
20677 }
20678 {
20679 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20680 }
20681 {
20682 if (temp2)
20683 delete arg2;
20684 }
20685 {
20686 if (temp3)
20687 delete arg3;
20688 }
20689 return resultobj;
20690 fail:
20691 {
20692 if (temp2)
20693 delete arg2;
20694 }
20695 {
20696 if (temp3)
20697 delete arg3;
20698 }
20699 return NULL;
20700 }
20701
20702
20703 SWIGINTERN PyObject *_wrap_ConfigBase_RenameGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20704 PyObject *resultobj = 0;
20705 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20706 wxString *arg2 = 0 ;
20707 wxString *arg3 = 0 ;
20708 bool result;
20709 void *argp1 = 0 ;
20710 int res1 = 0 ;
20711 bool temp2 = false ;
20712 bool temp3 = false ;
20713 PyObject * obj0 = 0 ;
20714 PyObject * obj1 = 0 ;
20715 PyObject * obj2 = 0 ;
20716 char * kwnames[] = {
20717 (char *) "self",(char *) "oldName",(char *) "newName", NULL
20718 };
20719
20720 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20721 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20722 if (!SWIG_IsOK(res1)) {
20723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20724 }
20725 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20726 {
20727 arg2 = wxString_in_helper(obj1);
20728 if (arg2 == NULL) SWIG_fail;
20729 temp2 = true;
20730 }
20731 {
20732 arg3 = wxString_in_helper(obj2);
20733 if (arg3 == NULL) SWIG_fail;
20734 temp3 = true;
20735 }
20736 {
20737 PyThreadState* __tstate = wxPyBeginAllowThreads();
20738 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
20739 wxPyEndAllowThreads(__tstate);
20740 if (PyErr_Occurred()) SWIG_fail;
20741 }
20742 {
20743 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20744 }
20745 {
20746 if (temp2)
20747 delete arg2;
20748 }
20749 {
20750 if (temp3)
20751 delete arg3;
20752 }
20753 return resultobj;
20754 fail:
20755 {
20756 if (temp2)
20757 delete arg2;
20758 }
20759 {
20760 if (temp3)
20761 delete arg3;
20762 }
20763 return NULL;
20764 }
20765
20766
20767 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20768 PyObject *resultobj = 0;
20769 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20770 wxString *arg2 = 0 ;
20771 bool arg3 = (bool) true ;
20772 bool result;
20773 void *argp1 = 0 ;
20774 int res1 = 0 ;
20775 bool temp2 = false ;
20776 bool val3 ;
20777 int ecode3 = 0 ;
20778 PyObject * obj0 = 0 ;
20779 PyObject * obj1 = 0 ;
20780 PyObject * obj2 = 0 ;
20781 char * kwnames[] = {
20782 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
20783 };
20784
20785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20787 if (!SWIG_IsOK(res1)) {
20788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20789 }
20790 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20791 {
20792 arg2 = wxString_in_helper(obj1);
20793 if (arg2 == NULL) SWIG_fail;
20794 temp2 = true;
20795 }
20796 if (obj2) {
20797 ecode3 = SWIG_AsVal_bool(obj2, &val3);
20798 if (!SWIG_IsOK(ecode3)) {
20799 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "3"" of type '" "bool""'");
20800 }
20801 arg3 = static_cast< bool >(val3);
20802 }
20803 {
20804 PyThreadState* __tstate = wxPyBeginAllowThreads();
20805 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
20806 wxPyEndAllowThreads(__tstate);
20807 if (PyErr_Occurred()) SWIG_fail;
20808 }
20809 {
20810 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20811 }
20812 {
20813 if (temp2)
20814 delete arg2;
20815 }
20816 return resultobj;
20817 fail:
20818 {
20819 if (temp2)
20820 delete arg2;
20821 }
20822 return NULL;
20823 }
20824
20825
20826 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20827 PyObject *resultobj = 0;
20828 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20829 wxString *arg2 = 0 ;
20830 bool result;
20831 void *argp1 = 0 ;
20832 int res1 = 0 ;
20833 bool temp2 = false ;
20834 PyObject * obj0 = 0 ;
20835 PyObject * obj1 = 0 ;
20836 char * kwnames[] = {
20837 (char *) "self",(char *) "key", NULL
20838 };
20839
20840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) SWIG_fail;
20841 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20842 if (!SWIG_IsOK(res1)) {
20843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20844 }
20845 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20846 {
20847 arg2 = wxString_in_helper(obj1);
20848 if (arg2 == NULL) SWIG_fail;
20849 temp2 = true;
20850 }
20851 {
20852 PyThreadState* __tstate = wxPyBeginAllowThreads();
20853 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
20854 wxPyEndAllowThreads(__tstate);
20855 if (PyErr_Occurred()) SWIG_fail;
20856 }
20857 {
20858 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20859 }
20860 {
20861 if (temp2)
20862 delete arg2;
20863 }
20864 return resultobj;
20865 fail:
20866 {
20867 if (temp2)
20868 delete arg2;
20869 }
20870 return NULL;
20871 }
20872
20873
20874 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20875 PyObject *resultobj = 0;
20876 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20877 bool result;
20878 void *argp1 = 0 ;
20879 int res1 = 0 ;
20880 PyObject *swig_obj[1] ;
20881
20882 if (!args) SWIG_fail;
20883 swig_obj[0] = args;
20884 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20885 if (!SWIG_IsOK(res1)) {
20886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteAll" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20887 }
20888 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20889 {
20890 PyThreadState* __tstate = wxPyBeginAllowThreads();
20891 result = (bool)(arg1)->DeleteAll();
20892 wxPyEndAllowThreads(__tstate);
20893 if (PyErr_Occurred()) SWIG_fail;
20894 }
20895 {
20896 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20897 }
20898 return resultobj;
20899 fail:
20900 return NULL;
20901 }
20902
20903
20904 SWIGINTERN PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20905 PyObject *resultobj = 0;
20906 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20907 bool arg2 = (bool) true ;
20908 void *argp1 = 0 ;
20909 int res1 = 0 ;
20910 bool val2 ;
20911 int ecode2 = 0 ;
20912 PyObject * obj0 = 0 ;
20913 PyObject * obj1 = 0 ;
20914 char * kwnames[] = {
20915 (char *) "self",(char *) "doIt", NULL
20916 };
20917
20918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
20919 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20920 if (!SWIG_IsOK(res1)) {
20921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20922 }
20923 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20924 if (obj1) {
20925 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20926 if (!SWIG_IsOK(ecode2)) {
20927 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "2"" of type '" "bool""'");
20928 }
20929 arg2 = static_cast< bool >(val2);
20930 }
20931 {
20932 PyThreadState* __tstate = wxPyBeginAllowThreads();
20933 (arg1)->SetExpandEnvVars(arg2);
20934 wxPyEndAllowThreads(__tstate);
20935 if (PyErr_Occurred()) SWIG_fail;
20936 }
20937 resultobj = SWIG_Py_Void();
20938 return resultobj;
20939 fail:
20940 return NULL;
20941 }
20942
20943
20944 SWIGINTERN PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20945 PyObject *resultobj = 0;
20946 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20947 bool result;
20948 void *argp1 = 0 ;
20949 int res1 = 0 ;
20950 PyObject *swig_obj[1] ;
20951
20952 if (!args) SWIG_fail;
20953 swig_obj[0] = args;
20954 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20955 if (!SWIG_IsOK(res1)) {
20956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsExpandingEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20957 }
20958 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20959 {
20960 PyThreadState* __tstate = wxPyBeginAllowThreads();
20961 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
20962 wxPyEndAllowThreads(__tstate);
20963 if (PyErr_Occurred()) SWIG_fail;
20964 }
20965 {
20966 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20967 }
20968 return resultobj;
20969 fail:
20970 return NULL;
20971 }
20972
20973
20974 SWIGINTERN PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20975 PyObject *resultobj = 0;
20976 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20977 bool arg2 = (bool) true ;
20978 void *argp1 = 0 ;
20979 int res1 = 0 ;
20980 bool val2 ;
20981 int ecode2 = 0 ;
20982 PyObject * obj0 = 0 ;
20983 PyObject * obj1 = 0 ;
20984 char * kwnames[] = {
20985 (char *) "self",(char *) "doIt", NULL
20986 };
20987
20988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
20989 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20990 if (!SWIG_IsOK(res1)) {
20991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20992 }
20993 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20994 if (obj1) {
20995 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20996 if (!SWIG_IsOK(ecode2)) {
20997 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "2"" of type '" "bool""'");
20998 }
20999 arg2 = static_cast< bool >(val2);
21000 }
21001 {
21002 PyThreadState* __tstate = wxPyBeginAllowThreads();
21003 (arg1)->SetRecordDefaults(arg2);
21004 wxPyEndAllowThreads(__tstate);
21005 if (PyErr_Occurred()) SWIG_fail;
21006 }
21007 resultobj = SWIG_Py_Void();
21008 return resultobj;
21009 fail:
21010 return NULL;
21011 }
21012
21013
21014 SWIGINTERN PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21015 PyObject *resultobj = 0;
21016 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21017 bool result;
21018 void *argp1 = 0 ;
21019 int res1 = 0 ;
21020 PyObject *swig_obj[1] ;
21021
21022 if (!args) SWIG_fail;
21023 swig_obj[0] = args;
21024 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21025 if (!SWIG_IsOK(res1)) {
21026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsRecordingDefaults" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21027 }
21028 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21029 {
21030 PyThreadState* __tstate = wxPyBeginAllowThreads();
21031 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
21032 wxPyEndAllowThreads(__tstate);
21033 if (PyErr_Occurred()) SWIG_fail;
21034 }
21035 {
21036 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21037 }
21038 return resultobj;
21039 fail:
21040 return NULL;
21041 }
21042
21043
21044 SWIGINTERN PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21045 PyObject *resultobj = 0;
21046 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21047 wxString *arg2 = 0 ;
21048 wxString result;
21049 void *argp1 = 0 ;
21050 int res1 = 0 ;
21051 bool temp2 = false ;
21052 PyObject * obj0 = 0 ;
21053 PyObject * obj1 = 0 ;
21054 char * kwnames[] = {
21055 (char *) "self",(char *) "str", NULL
21056 };
21057
21058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
21059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21060 if (!SWIG_IsOK(res1)) {
21061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21062 }
21063 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21064 {
21065 arg2 = wxString_in_helper(obj1);
21066 if (arg2 == NULL) SWIG_fail;
21067 temp2 = true;
21068 }
21069 {
21070 PyThreadState* __tstate = wxPyBeginAllowThreads();
21071 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
21072 wxPyEndAllowThreads(__tstate);
21073 if (PyErr_Occurred()) SWIG_fail;
21074 }
21075 {
21076 #if wxUSE_UNICODE
21077 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21078 #else
21079 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21080 #endif
21081 }
21082 {
21083 if (temp2)
21084 delete arg2;
21085 }
21086 return resultobj;
21087 fail:
21088 {
21089 if (temp2)
21090 delete arg2;
21091 }
21092 return NULL;
21093 }
21094
21095
21096 SWIGINTERN PyObject *_wrap_ConfigBase_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21097 PyObject *resultobj = 0;
21098 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21099 wxString result;
21100 void *argp1 = 0 ;
21101 int res1 = 0 ;
21102 PyObject *swig_obj[1] ;
21103
21104 if (!args) SWIG_fail;
21105 swig_obj[0] = args;
21106 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21107 if (!SWIG_IsOK(res1)) {
21108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetAppName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21109 }
21110 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21111 {
21112 PyThreadState* __tstate = wxPyBeginAllowThreads();
21113 result = ((wxConfigBase const *)arg1)->GetAppName();
21114 wxPyEndAllowThreads(__tstate);
21115 if (PyErr_Occurred()) SWIG_fail;
21116 }
21117 {
21118 #if wxUSE_UNICODE
21119 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21120 #else
21121 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21122 #endif
21123 }
21124 return resultobj;
21125 fail:
21126 return NULL;
21127 }
21128
21129
21130 SWIGINTERN PyObject *_wrap_ConfigBase_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21131 PyObject *resultobj = 0;
21132 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21133 wxString result;
21134 void *argp1 = 0 ;
21135 int res1 = 0 ;
21136 PyObject *swig_obj[1] ;
21137
21138 if (!args) SWIG_fail;
21139 swig_obj[0] = args;
21140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21141 if (!SWIG_IsOK(res1)) {
21142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetVendorName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21143 }
21144 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21145 {
21146 PyThreadState* __tstate = wxPyBeginAllowThreads();
21147 result = ((wxConfigBase const *)arg1)->GetVendorName();
21148 wxPyEndAllowThreads(__tstate);
21149 if (PyErr_Occurred()) SWIG_fail;
21150 }
21151 {
21152 #if wxUSE_UNICODE
21153 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21154 #else
21155 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21156 #endif
21157 }
21158 return resultobj;
21159 fail:
21160 return NULL;
21161 }
21162
21163
21164 SWIGINTERN PyObject *_wrap_ConfigBase_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21165 PyObject *resultobj = 0;
21166 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21167 wxString *arg2 = 0 ;
21168 void *argp1 = 0 ;
21169 int res1 = 0 ;
21170 bool temp2 = false ;
21171 PyObject * obj0 = 0 ;
21172 PyObject * obj1 = 0 ;
21173 char * kwnames[] = {
21174 (char *) "self",(char *) "appName", NULL
21175 };
21176
21177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
21178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21179 if (!SWIG_IsOK(res1)) {
21180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetAppName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21181 }
21182 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21183 {
21184 arg2 = wxString_in_helper(obj1);
21185 if (arg2 == NULL) SWIG_fail;
21186 temp2 = true;
21187 }
21188 {
21189 PyThreadState* __tstate = wxPyBeginAllowThreads();
21190 (arg1)->SetAppName((wxString const &)*arg2);
21191 wxPyEndAllowThreads(__tstate);
21192 if (PyErr_Occurred()) SWIG_fail;
21193 }
21194 resultobj = SWIG_Py_Void();
21195 {
21196 if (temp2)
21197 delete arg2;
21198 }
21199 return resultobj;
21200 fail:
21201 {
21202 if (temp2)
21203 delete arg2;
21204 }
21205 return NULL;
21206 }
21207
21208
21209 SWIGINTERN PyObject *_wrap_ConfigBase_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21210 PyObject *resultobj = 0;
21211 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21212 wxString *arg2 = 0 ;
21213 void *argp1 = 0 ;
21214 int res1 = 0 ;
21215 bool temp2 = false ;
21216 PyObject * obj0 = 0 ;
21217 PyObject * obj1 = 0 ;
21218 char * kwnames[] = {
21219 (char *) "self",(char *) "vendorName", NULL
21220 };
21221
21222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
21223 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21224 if (!SWIG_IsOK(res1)) {
21225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetVendorName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21226 }
21227 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21228 {
21229 arg2 = wxString_in_helper(obj1);
21230 if (arg2 == NULL) SWIG_fail;
21231 temp2 = true;
21232 }
21233 {
21234 PyThreadState* __tstate = wxPyBeginAllowThreads();
21235 (arg1)->SetVendorName((wxString const &)*arg2);
21236 wxPyEndAllowThreads(__tstate);
21237 if (PyErr_Occurred()) SWIG_fail;
21238 }
21239 resultobj = SWIG_Py_Void();
21240 {
21241 if (temp2)
21242 delete arg2;
21243 }
21244 return resultobj;
21245 fail:
21246 {
21247 if (temp2)
21248 delete arg2;
21249 }
21250 return NULL;
21251 }
21252
21253
21254 SWIGINTERN PyObject *_wrap_ConfigBase_SetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21255 PyObject *resultobj = 0;
21256 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21257 long arg2 ;
21258 void *argp1 = 0 ;
21259 int res1 = 0 ;
21260 long val2 ;
21261 int ecode2 = 0 ;
21262 PyObject * obj0 = 0 ;
21263 PyObject * obj1 = 0 ;
21264 char * kwnames[] = {
21265 (char *) "self",(char *) "style", NULL
21266 };
21267
21268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) SWIG_fail;
21269 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21270 if (!SWIG_IsOK(res1)) {
21271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetStyle" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21272 }
21273 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21274 ecode2 = SWIG_AsVal_long(obj1, &val2);
21275 if (!SWIG_IsOK(ecode2)) {
21276 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetStyle" "', expected argument " "2"" of type '" "long""'");
21277 }
21278 arg2 = static_cast< long >(val2);
21279 {
21280 PyThreadState* __tstate = wxPyBeginAllowThreads();
21281 (arg1)->SetStyle(arg2);
21282 wxPyEndAllowThreads(__tstate);
21283 if (PyErr_Occurred()) SWIG_fail;
21284 }
21285 resultobj = SWIG_Py_Void();
21286 return resultobj;
21287 fail:
21288 return NULL;
21289 }
21290
21291
21292 SWIGINTERN PyObject *_wrap_ConfigBase_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21293 PyObject *resultobj = 0;
21294 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21295 long result;
21296 void *argp1 = 0 ;
21297 int res1 = 0 ;
21298 PyObject *swig_obj[1] ;
21299
21300 if (!args) SWIG_fail;
21301 swig_obj[0] = args;
21302 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21303 if (!SWIG_IsOK(res1)) {
21304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetStyle" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21305 }
21306 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21307 {
21308 PyThreadState* __tstate = wxPyBeginAllowThreads();
21309 result = (long)((wxConfigBase const *)arg1)->GetStyle();
21310 wxPyEndAllowThreads(__tstate);
21311 if (PyErr_Occurred()) SWIG_fail;
21312 }
21313 resultobj = SWIG_From_long(static_cast< long >(result));
21314 return resultobj;
21315 fail:
21316 return NULL;
21317 }
21318
21319
21320 SWIGINTERN PyObject *ConfigBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21321 PyObject *obj;
21322 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21323 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigBase, SWIG_NewClientData(obj));
21324 return SWIG_Py_Void();
21325 }
21326
21327 SWIGINTERN PyObject *_wrap_new_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21328 PyObject *resultobj = 0;
21329 wxString const &arg1_defvalue = wxPyEmptyString ;
21330 wxString *arg1 = (wxString *) &arg1_defvalue ;
21331 wxString const &arg2_defvalue = wxPyEmptyString ;
21332 wxString *arg2 = (wxString *) &arg2_defvalue ;
21333 wxString const &arg3_defvalue = wxPyEmptyString ;
21334 wxString *arg3 = (wxString *) &arg3_defvalue ;
21335 wxString const &arg4_defvalue = wxPyEmptyString ;
21336 wxString *arg4 = (wxString *) &arg4_defvalue ;
21337 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
21338 wxConfig *result = 0 ;
21339 bool temp1 = false ;
21340 bool temp2 = false ;
21341 bool temp3 = false ;
21342 bool temp4 = false ;
21343 long val5 ;
21344 int ecode5 = 0 ;
21345 PyObject * obj0 = 0 ;
21346 PyObject * obj1 = 0 ;
21347 PyObject * obj2 = 0 ;
21348 PyObject * obj3 = 0 ;
21349 PyObject * obj4 = 0 ;
21350 char * kwnames[] = {
21351 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
21352 };
21353
21354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
21355 if (obj0) {
21356 {
21357 arg1 = wxString_in_helper(obj0);
21358 if (arg1 == NULL) SWIG_fail;
21359 temp1 = true;
21360 }
21361 }
21362 if (obj1) {
21363 {
21364 arg2 = wxString_in_helper(obj1);
21365 if (arg2 == NULL) SWIG_fail;
21366 temp2 = true;
21367 }
21368 }
21369 if (obj2) {
21370 {
21371 arg3 = wxString_in_helper(obj2);
21372 if (arg3 == NULL) SWIG_fail;
21373 temp3 = true;
21374 }
21375 }
21376 if (obj3) {
21377 {
21378 arg4 = wxString_in_helper(obj3);
21379 if (arg4 == NULL) SWIG_fail;
21380 temp4 = true;
21381 }
21382 }
21383 if (obj4) {
21384 ecode5 = SWIG_AsVal_long(obj4, &val5);
21385 if (!SWIG_IsOK(ecode5)) {
21386 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Config" "', expected argument " "5"" of type '" "long""'");
21387 }
21388 arg5 = static_cast< long >(val5);
21389 }
21390 {
21391 PyThreadState* __tstate = wxPyBeginAllowThreads();
21392 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
21393 wxPyEndAllowThreads(__tstate);
21394 if (PyErr_Occurred()) SWIG_fail;
21395 }
21396 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfig, SWIG_POINTER_NEW | 0 );
21397 {
21398 if (temp1)
21399 delete arg1;
21400 }
21401 {
21402 if (temp2)
21403 delete arg2;
21404 }
21405 {
21406 if (temp3)
21407 delete arg3;
21408 }
21409 {
21410 if (temp4)
21411 delete arg4;
21412 }
21413 return resultobj;
21414 fail:
21415 {
21416 if (temp1)
21417 delete arg1;
21418 }
21419 {
21420 if (temp2)
21421 delete arg2;
21422 }
21423 {
21424 if (temp3)
21425 delete arg3;
21426 }
21427 {
21428 if (temp4)
21429 delete arg4;
21430 }
21431 return NULL;
21432 }
21433
21434
21435 SWIGINTERN PyObject *_wrap_delete_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21436 PyObject *resultobj = 0;
21437 wxConfig *arg1 = (wxConfig *) 0 ;
21438 void *argp1 = 0 ;
21439 int res1 = 0 ;
21440 PyObject *swig_obj[1] ;
21441
21442 if (!args) SWIG_fail;
21443 swig_obj[0] = args;
21444 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfig, SWIG_POINTER_DISOWN | 0 );
21445 if (!SWIG_IsOK(res1)) {
21446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Config" "', expected argument " "1"" of type '" "wxConfig *""'");
21447 }
21448 arg1 = reinterpret_cast< wxConfig * >(argp1);
21449 {
21450 PyThreadState* __tstate = wxPyBeginAllowThreads();
21451 delete arg1;
21452
21453 wxPyEndAllowThreads(__tstate);
21454 if (PyErr_Occurred()) SWIG_fail;
21455 }
21456 resultobj = SWIG_Py_Void();
21457 return resultobj;
21458 fail:
21459 return NULL;
21460 }
21461
21462
21463 SWIGINTERN PyObject *Config_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21464 PyObject *obj;
21465 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21466 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfig, SWIG_NewClientData(obj));
21467 return SWIG_Py_Void();
21468 }
21469
21470 SWIGINTERN PyObject *Config_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21471 return SWIG_Python_InitShadowInstance(args);
21472 }
21473
21474 SWIGINTERN PyObject *_wrap_new_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21475 PyObject *resultobj = 0;
21476 wxString const &arg1_defvalue = wxPyEmptyString ;
21477 wxString *arg1 = (wxString *) &arg1_defvalue ;
21478 wxString const &arg2_defvalue = wxPyEmptyString ;
21479 wxString *arg2 = (wxString *) &arg2_defvalue ;
21480 wxString const &arg3_defvalue = wxPyEmptyString ;
21481 wxString *arg3 = (wxString *) &arg3_defvalue ;
21482 wxString const &arg4_defvalue = wxPyEmptyString ;
21483 wxString *arg4 = (wxString *) &arg4_defvalue ;
21484 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
21485 wxFileConfig *result = 0 ;
21486 bool temp1 = false ;
21487 bool temp2 = false ;
21488 bool temp3 = false ;
21489 bool temp4 = false ;
21490 long val5 ;
21491 int ecode5 = 0 ;
21492 PyObject * obj0 = 0 ;
21493 PyObject * obj1 = 0 ;
21494 PyObject * obj2 = 0 ;
21495 PyObject * obj3 = 0 ;
21496 PyObject * obj4 = 0 ;
21497 char * kwnames[] = {
21498 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
21499 };
21500
21501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
21502 if (obj0) {
21503 {
21504 arg1 = wxString_in_helper(obj0);
21505 if (arg1 == NULL) SWIG_fail;
21506 temp1 = true;
21507 }
21508 }
21509 if (obj1) {
21510 {
21511 arg2 = wxString_in_helper(obj1);
21512 if (arg2 == NULL) SWIG_fail;
21513 temp2 = true;
21514 }
21515 }
21516 if (obj2) {
21517 {
21518 arg3 = wxString_in_helper(obj2);
21519 if (arg3 == NULL) SWIG_fail;
21520 temp3 = true;
21521 }
21522 }
21523 if (obj3) {
21524 {
21525 arg4 = wxString_in_helper(obj3);
21526 if (arg4 == NULL) SWIG_fail;
21527 temp4 = true;
21528 }
21529 }
21530 if (obj4) {
21531 ecode5 = SWIG_AsVal_long(obj4, &val5);
21532 if (!SWIG_IsOK(ecode5)) {
21533 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FileConfig" "', expected argument " "5"" of type '" "long""'");
21534 }
21535 arg5 = static_cast< long >(val5);
21536 }
21537 {
21538 PyThreadState* __tstate = wxPyBeginAllowThreads();
21539 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
21540 wxPyEndAllowThreads(__tstate);
21541 if (PyErr_Occurred()) SWIG_fail;
21542 }
21543 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileConfig, SWIG_POINTER_NEW | 0 );
21544 {
21545 if (temp1)
21546 delete arg1;
21547 }
21548 {
21549 if (temp2)
21550 delete arg2;
21551 }
21552 {
21553 if (temp3)
21554 delete arg3;
21555 }
21556 {
21557 if (temp4)
21558 delete arg4;
21559 }
21560 return resultobj;
21561 fail:
21562 {
21563 if (temp1)
21564 delete arg1;
21565 }
21566 {
21567 if (temp2)
21568 delete arg2;
21569 }
21570 {
21571 if (temp3)
21572 delete arg3;
21573 }
21574 {
21575 if (temp4)
21576 delete arg4;
21577 }
21578 return NULL;
21579 }
21580
21581
21582 SWIGINTERN PyObject *_wrap_delete_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21583 PyObject *resultobj = 0;
21584 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
21585 void *argp1 = 0 ;
21586 int res1 = 0 ;
21587 PyObject *swig_obj[1] ;
21588
21589 if (!args) SWIG_fail;
21590 swig_obj[0] = args;
21591 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileConfig, SWIG_POINTER_DISOWN | 0 );
21592 if (!SWIG_IsOK(res1)) {
21593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileConfig" "', expected argument " "1"" of type '" "wxFileConfig *""'");
21594 }
21595 arg1 = reinterpret_cast< wxFileConfig * >(argp1);
21596 {
21597 PyThreadState* __tstate = wxPyBeginAllowThreads();
21598 delete arg1;
21599
21600 wxPyEndAllowThreads(__tstate);
21601 if (PyErr_Occurred()) SWIG_fail;
21602 }
21603 resultobj = SWIG_Py_Void();
21604 return resultobj;
21605 fail:
21606 return NULL;
21607 }
21608
21609
21610 SWIGINTERN PyObject *FileConfig_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21611 PyObject *obj;
21612 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21613 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileConfig, SWIG_NewClientData(obj));
21614 return SWIG_Py_Void();
21615 }
21616
21617 SWIGINTERN PyObject *FileConfig_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21618 return SWIG_Python_InitShadowInstance(args);
21619 }
21620
21621 SWIGINTERN PyObject *_wrap_new_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21622 PyObject *resultobj = 0;
21623 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21624 wxString *arg2 = 0 ;
21625 wxConfigPathChanger *result = 0 ;
21626 void *argp1 = 0 ;
21627 int res1 = 0 ;
21628 bool temp2 = false ;
21629 PyObject * obj0 = 0 ;
21630 PyObject * obj1 = 0 ;
21631 char * kwnames[] = {
21632 (char *) "config",(char *) "entry", NULL
21633 };
21634
21635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) SWIG_fail;
21636 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21637 if (!SWIG_IsOK(res1)) {
21638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21639 }
21640 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21641 {
21642 arg2 = wxString_in_helper(obj1);
21643 if (arg2 == NULL) SWIG_fail;
21644 temp2 = true;
21645 }
21646 {
21647 PyThreadState* __tstate = wxPyBeginAllowThreads();
21648 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
21649 wxPyEndAllowThreads(__tstate);
21650 if (PyErr_Occurred()) SWIG_fail;
21651 }
21652 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_NEW | 0 );
21653 {
21654 if (temp2)
21655 delete arg2;
21656 }
21657 return resultobj;
21658 fail:
21659 {
21660 if (temp2)
21661 delete arg2;
21662 }
21663 return NULL;
21664 }
21665
21666
21667 SWIGINTERN PyObject *_wrap_delete_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21668 PyObject *resultobj = 0;
21669 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
21670 void *argp1 = 0 ;
21671 int res1 = 0 ;
21672 PyObject *swig_obj[1] ;
21673
21674 if (!args) SWIG_fail;
21675 swig_obj[0] = args;
21676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_DISOWN | 0 );
21677 if (!SWIG_IsOK(res1)) {
21678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigPathChanger *""'");
21679 }
21680 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
21681 {
21682 PyThreadState* __tstate = wxPyBeginAllowThreads();
21683 delete arg1;
21684
21685 wxPyEndAllowThreads(__tstate);
21686 if (PyErr_Occurred()) SWIG_fail;
21687 }
21688 resultobj = SWIG_Py_Void();
21689 return resultobj;
21690 fail:
21691 return NULL;
21692 }
21693
21694
21695 SWIGINTERN PyObject *_wrap_ConfigPathChanger_Name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21696 PyObject *resultobj = 0;
21697 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
21698 wxString *result = 0 ;
21699 void *argp1 = 0 ;
21700 int res1 = 0 ;
21701 PyObject *swig_obj[1] ;
21702
21703 if (!args) SWIG_fail;
21704 swig_obj[0] = args;
21705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, 0 | 0 );
21706 if (!SWIG_IsOK(res1)) {
21707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigPathChanger_Name" "', expected argument " "1"" of type '" "wxConfigPathChanger const *""'");
21708 }
21709 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
21710 {
21711 PyThreadState* __tstate = wxPyBeginAllowThreads();
21712 {
21713 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
21714 result = (wxString *) &_result_ref;
21715 }
21716 wxPyEndAllowThreads(__tstate);
21717 if (PyErr_Occurred()) SWIG_fail;
21718 }
21719 {
21720 #if wxUSE_UNICODE
21721 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
21722 #else
21723 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
21724 #endif
21725 }
21726 return resultobj;
21727 fail:
21728 return NULL;
21729 }
21730
21731
21732 SWIGINTERN PyObject *ConfigPathChanger_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21733 PyObject *obj;
21734 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21735 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigPathChanger, SWIG_NewClientData(obj));
21736 return SWIG_Py_Void();
21737 }
21738
21739 SWIGINTERN PyObject *ConfigPathChanger_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21740 return SWIG_Python_InitShadowInstance(args);
21741 }
21742
21743 SWIGINTERN PyObject *_wrap_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21744 PyObject *resultobj = 0;
21745 wxString *arg1 = 0 ;
21746 wxString result;
21747 bool temp1 = false ;
21748 PyObject * obj0 = 0 ;
21749 char * kwnames[] = {
21750 (char *) "sz", NULL
21751 };
21752
21753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) SWIG_fail;
21754 {
21755 arg1 = wxString_in_helper(obj0);
21756 if (arg1 == NULL) SWIG_fail;
21757 temp1 = true;
21758 }
21759 {
21760 PyThreadState* __tstate = wxPyBeginAllowThreads();
21761 result = wxExpandEnvVars((wxString const &)*arg1);
21762 wxPyEndAllowThreads(__tstate);
21763 if (PyErr_Occurred()) SWIG_fail;
21764 }
21765 {
21766 #if wxUSE_UNICODE
21767 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21768 #else
21769 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21770 #endif
21771 }
21772 {
21773 if (temp1)
21774 delete arg1;
21775 }
21776 return resultobj;
21777 fail:
21778 {
21779 if (temp1)
21780 delete arg1;
21781 }
21782 return NULL;
21783 }
21784
21785
21786 SWIGINTERN int DefaultDateTimeFormat_set(PyObject *) {
21787 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTimeFormat is read-only.");
21788 return 1;
21789 }
21790
21791
21792 SWIGINTERN PyObject *DefaultDateTimeFormat_get(void) {
21793 PyObject *pyobj = 0;
21794
21795 {
21796 #if wxUSE_UNICODE
21797 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
21798 #else
21799 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
21800 #endif
21801 }
21802 return pyobj;
21803 }
21804
21805
21806 SWIGINTERN int DefaultTimeSpanFormat_set(PyObject *) {
21807 SWIG_Error(SWIG_AttributeError,"Variable DefaultTimeSpanFormat is read-only.");
21808 return 1;
21809 }
21810
21811
21812 SWIGINTERN PyObject *DefaultTimeSpanFormat_get(void) {
21813 PyObject *pyobj = 0;
21814
21815 {
21816 #if wxUSE_UNICODE
21817 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
21818 #else
21819 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
21820 #endif
21821 }
21822 return pyobj;
21823 }
21824
21825
21826 SWIGINTERN PyObject *_wrap_DateTime_SetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21827 PyObject *resultobj = 0;
21828 wxDateTime::Country arg1 ;
21829 int val1 ;
21830 int ecode1 = 0 ;
21831 PyObject * obj0 = 0 ;
21832 char * kwnames[] = {
21833 (char *) "country", NULL
21834 };
21835
21836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) SWIG_fail;
21837 ecode1 = SWIG_AsVal_int(obj0, &val1);
21838 if (!SWIG_IsOK(ecode1)) {
21839 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
21840 }
21841 arg1 = static_cast< wxDateTime::Country >(val1);
21842 {
21843 PyThreadState* __tstate = wxPyBeginAllowThreads();
21844 wxDateTime::SetCountry(arg1);
21845 wxPyEndAllowThreads(__tstate);
21846 if (PyErr_Occurred()) SWIG_fail;
21847 }
21848 resultobj = SWIG_Py_Void();
21849 return resultobj;
21850 fail:
21851 return NULL;
21852 }
21853
21854
21855 SWIGINTERN PyObject *_wrap_DateTime_GetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21856 PyObject *resultobj = 0;
21857 wxDateTime::Country result;
21858
21859 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetCountry",0,0,0)) SWIG_fail;
21860 {
21861 PyThreadState* __tstate = wxPyBeginAllowThreads();
21862 result = (wxDateTime::Country)wxDateTime::GetCountry();
21863 wxPyEndAllowThreads(__tstate);
21864 if (PyErr_Occurred()) SWIG_fail;
21865 }
21866 resultobj = SWIG_From_int(static_cast< int >(result));
21867 return resultobj;
21868 fail:
21869 return NULL;
21870 }
21871
21872
21873 SWIGINTERN PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21874 PyObject *resultobj = 0;
21875 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
21876 bool result;
21877 int val1 ;
21878 int ecode1 = 0 ;
21879 PyObject * obj0 = 0 ;
21880 char * kwnames[] = {
21881 (char *) "country", NULL
21882 };
21883
21884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) SWIG_fail;
21885 if (obj0) {
21886 ecode1 = SWIG_AsVal_int(obj0, &val1);
21887 if (!SWIG_IsOK(ecode1)) {
21888 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsWestEuropeanCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
21889 }
21890 arg1 = static_cast< wxDateTime::Country >(val1);
21891 }
21892 {
21893 PyThreadState* __tstate = wxPyBeginAllowThreads();
21894 result = (bool)wxDateTime::IsWestEuropeanCountry(arg1);
21895 wxPyEndAllowThreads(__tstate);
21896 if (PyErr_Occurred()) SWIG_fail;
21897 }
21898 {
21899 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21900 }
21901 return resultobj;
21902 fail:
21903 return NULL;
21904 }
21905
21906
21907 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21908 PyObject *resultobj = 0;
21909 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
21910 int result;
21911 int val1 ;
21912 int ecode1 = 0 ;
21913 PyObject * obj0 = 0 ;
21914 char * kwnames[] = {
21915 (char *) "cal", NULL
21916 };
21917
21918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) SWIG_fail;
21919 if (obj0) {
21920 ecode1 = SWIG_AsVal_int(obj0, &val1);
21921 if (!SWIG_IsOK(ecode1)) {
21922 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentYear" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
21923 }
21924 arg1 = static_cast< wxDateTime::Calendar >(val1);
21925 }
21926 {
21927 PyThreadState* __tstate = wxPyBeginAllowThreads();
21928 result = (int)wxDateTime::GetCurrentYear(arg1);
21929 wxPyEndAllowThreads(__tstate);
21930 if (PyErr_Occurred()) SWIG_fail;
21931 }
21932 resultobj = SWIG_From_int(static_cast< int >(result));
21933 return resultobj;
21934 fail:
21935 return NULL;
21936 }
21937
21938
21939 SWIGINTERN PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21940 PyObject *resultobj = 0;
21941 int arg1 ;
21942 int result;
21943 int val1 ;
21944 int ecode1 = 0 ;
21945 PyObject * obj0 = 0 ;
21946 char * kwnames[] = {
21947 (char *) "year", NULL
21948 };
21949
21950 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) SWIG_fail;
21951 ecode1 = SWIG_AsVal_int(obj0, &val1);
21952 if (!SWIG_IsOK(ecode1)) {
21953 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_ConvertYearToBC" "', expected argument " "1"" of type '" "int""'");
21954 }
21955 arg1 = static_cast< int >(val1);
21956 {
21957 PyThreadState* __tstate = wxPyBeginAllowThreads();
21958 result = (int)wxDateTime::ConvertYearToBC(arg1);
21959 wxPyEndAllowThreads(__tstate);
21960 if (PyErr_Occurred()) SWIG_fail;
21961 }
21962 resultobj = SWIG_From_int(static_cast< int >(result));
21963 return resultobj;
21964 fail:
21965 return NULL;
21966 }
21967
21968
21969 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21970 PyObject *resultobj = 0;
21971 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
21972 wxDateTime::Month result;
21973 int val1 ;
21974 int ecode1 = 0 ;
21975 PyObject * obj0 = 0 ;
21976 char * kwnames[] = {
21977 (char *) "cal", NULL
21978 };
21979
21980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) SWIG_fail;
21981 if (obj0) {
21982 ecode1 = SWIG_AsVal_int(obj0, &val1);
21983 if (!SWIG_IsOK(ecode1)) {
21984 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentMonth" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
21985 }
21986 arg1 = static_cast< wxDateTime::Calendar >(val1);
21987 }
21988 {
21989 PyThreadState* __tstate = wxPyBeginAllowThreads();
21990 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth(arg1);
21991 wxPyEndAllowThreads(__tstate);
21992 if (PyErr_Occurred()) SWIG_fail;
21993 }
21994 resultobj = SWIG_From_int(static_cast< int >(result));
21995 return resultobj;
21996 fail:
21997 return NULL;
21998 }
21999
22000
22001 SWIGINTERN PyObject *_wrap_DateTime_IsLeapYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22002 PyObject *resultobj = 0;
22003 int arg1 = (int) wxDateTime::Inv_Year ;
22004 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
22005 bool result;
22006 int val1 ;
22007 int ecode1 = 0 ;
22008 int val2 ;
22009 int ecode2 = 0 ;
22010 PyObject * obj0 = 0 ;
22011 PyObject * obj1 = 0 ;
22012 char * kwnames[] = {
22013 (char *) "year",(char *) "cal", NULL
22014 };
22015
22016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) SWIG_fail;
22017 if (obj0) {
22018 ecode1 = SWIG_AsVal_int(obj0, &val1);
22019 if (!SWIG_IsOK(ecode1)) {
22020 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsLeapYear" "', expected argument " "1"" of type '" "int""'");
22021 }
22022 arg1 = static_cast< int >(val1);
22023 }
22024 if (obj1) {
22025 ecode2 = SWIG_AsVal_int(obj1, &val2);
22026 if (!SWIG_IsOK(ecode2)) {
22027 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsLeapYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
22028 }
22029 arg2 = static_cast< wxDateTime::Calendar >(val2);
22030 }
22031 {
22032 PyThreadState* __tstate = wxPyBeginAllowThreads();
22033 result = (bool)wxDateTime::IsLeapYear(arg1,arg2);
22034 wxPyEndAllowThreads(__tstate);
22035 if (PyErr_Occurred()) SWIG_fail;
22036 }
22037 {
22038 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22039 }
22040 return resultobj;
22041 fail:
22042 return NULL;
22043 }
22044
22045
22046 SWIGINTERN PyObject *_wrap_DateTime_GetCentury(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22047 PyObject *resultobj = 0;
22048 int arg1 = (int) wxDateTime::Inv_Year ;
22049 int result;
22050 int val1 ;
22051 int ecode1 = 0 ;
22052 PyObject * obj0 = 0 ;
22053 char * kwnames[] = {
22054 (char *) "year", NULL
22055 };
22056
22057 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) SWIG_fail;
22058 if (obj0) {
22059 ecode1 = SWIG_AsVal_int(obj0, &val1);
22060 if (!SWIG_IsOK(ecode1)) {
22061 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCentury" "', expected argument " "1"" of type '" "int""'");
22062 }
22063 arg1 = static_cast< int >(val1);
22064 }
22065 {
22066 PyThreadState* __tstate = wxPyBeginAllowThreads();
22067 result = (int)wxDateTime::GetCentury(arg1);
22068 wxPyEndAllowThreads(__tstate);
22069 if (PyErr_Occurred()) SWIG_fail;
22070 }
22071 resultobj = SWIG_From_int(static_cast< int >(result));
22072 return resultobj;
22073 fail:
22074 return NULL;
22075 }
22076
22077
22078 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22079 PyObject *resultobj = 0;
22080 int arg1 ;
22081 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
22082 int result;
22083 int val1 ;
22084 int ecode1 = 0 ;
22085 int val2 ;
22086 int ecode2 = 0 ;
22087 PyObject * obj0 = 0 ;
22088 PyObject * obj1 = 0 ;
22089 char * kwnames[] = {
22090 (char *) "year",(char *) "cal", NULL
22091 };
22092
22093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) SWIG_fail;
22094 ecode1 = SWIG_AsVal_int(obj0, &val1);
22095 if (!SWIG_IsOK(ecode1)) {
22096 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "1"" of type '" "int""'");
22097 }
22098 arg1 = static_cast< int >(val1);
22099 if (obj1) {
22100 ecode2 = SWIG_AsVal_int(obj1, &val2);
22101 if (!SWIG_IsOK(ecode2)) {
22102 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
22103 }
22104 arg2 = static_cast< wxDateTime::Calendar >(val2);
22105 }
22106 {
22107 PyThreadState* __tstate = wxPyBeginAllowThreads();
22108 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2);
22109 wxPyEndAllowThreads(__tstate);
22110 if (PyErr_Occurred()) SWIG_fail;
22111 }
22112 resultobj = SWIG_From_int(static_cast< int >(result));
22113 return resultobj;
22114 fail:
22115 return NULL;
22116 }
22117
22118
22119 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22120 PyObject *resultobj = 0;
22121 wxDateTime::Month arg1 ;
22122 int arg2 = (int) wxDateTime::Inv_Year ;
22123 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
22124 int result;
22125 int val1 ;
22126 int ecode1 = 0 ;
22127 int val2 ;
22128 int ecode2 = 0 ;
22129 int val3 ;
22130 int ecode3 = 0 ;
22131 PyObject * obj0 = 0 ;
22132 PyObject * obj1 = 0 ;
22133 PyObject * obj2 = 0 ;
22134 char * kwnames[] = {
22135 (char *) "month",(char *) "year",(char *) "cal", NULL
22136 };
22137
22138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22139 ecode1 = SWIG_AsVal_int(obj0, &val1);
22140 if (!SWIG_IsOK(ecode1)) {
22141 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
22142 }
22143 arg1 = static_cast< wxDateTime::Month >(val1);
22144 if (obj1) {
22145 ecode2 = SWIG_AsVal_int(obj1, &val2);
22146 if (!SWIG_IsOK(ecode2)) {
22147 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "2"" of type '" "int""'");
22148 }
22149 arg2 = static_cast< int >(val2);
22150 }
22151 if (obj2) {
22152 ecode3 = SWIG_AsVal_int(obj2, &val3);
22153 if (!SWIG_IsOK(ecode3)) {
22154 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "3"" of type '" "wxDateTime::Calendar""'");
22155 }
22156 arg3 = static_cast< wxDateTime::Calendar >(val3);
22157 }
22158 {
22159 PyThreadState* __tstate = wxPyBeginAllowThreads();
22160 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2,arg3);
22161 wxPyEndAllowThreads(__tstate);
22162 if (PyErr_Occurred()) SWIG_fail;
22163 }
22164 resultobj = SWIG_From_int(static_cast< int >(result));
22165 return resultobj;
22166 fail:
22167 return NULL;
22168 }
22169
22170
22171 SWIGINTERN PyObject *_wrap_DateTime_GetMonthName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22172 PyObject *resultobj = 0;
22173 wxDateTime::Month arg1 ;
22174 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
22175 wxString result;
22176 int val1 ;
22177 int ecode1 = 0 ;
22178 int val2 ;
22179 int ecode2 = 0 ;
22180 PyObject * obj0 = 0 ;
22181 PyObject * obj1 = 0 ;
22182 char * kwnames[] = {
22183 (char *) "month",(char *) "flags", NULL
22184 };
22185
22186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) SWIG_fail;
22187 ecode1 = SWIG_AsVal_int(obj0, &val1);
22188 if (!SWIG_IsOK(ecode1)) {
22189 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetMonthName" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
22190 }
22191 arg1 = static_cast< wxDateTime::Month >(val1);
22192 if (obj1) {
22193 ecode2 = SWIG_AsVal_int(obj1, &val2);
22194 if (!SWIG_IsOK(ecode2)) {
22195 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetMonthName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
22196 }
22197 arg2 = static_cast< wxDateTime::NameFlags >(val2);
22198 }
22199 {
22200 PyThreadState* __tstate = wxPyBeginAllowThreads();
22201 result = wxDateTime::GetMonthName(arg1,arg2);
22202 wxPyEndAllowThreads(__tstate);
22203 if (PyErr_Occurred()) SWIG_fail;
22204 }
22205 {
22206 #if wxUSE_UNICODE
22207 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22208 #else
22209 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22210 #endif
22211 }
22212 return resultobj;
22213 fail:
22214 return NULL;
22215 }
22216
22217
22218 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22219 PyObject *resultobj = 0;
22220 wxDateTime::WeekDay arg1 ;
22221 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
22222 wxString result;
22223 int val1 ;
22224 int ecode1 = 0 ;
22225 int val2 ;
22226 int ecode2 = 0 ;
22227 PyObject * obj0 = 0 ;
22228 PyObject * obj1 = 0 ;
22229 char * kwnames[] = {
22230 (char *) "weekday",(char *) "flags", NULL
22231 };
22232
22233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) SWIG_fail;
22234 ecode1 = SWIG_AsVal_int(obj0, &val1);
22235 if (!SWIG_IsOK(ecode1)) {
22236 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetWeekDayName" "', expected argument " "1"" of type '" "wxDateTime::WeekDay""'");
22237 }
22238 arg1 = static_cast< wxDateTime::WeekDay >(val1);
22239 if (obj1) {
22240 ecode2 = SWIG_AsVal_int(obj1, &val2);
22241 if (!SWIG_IsOK(ecode2)) {
22242 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
22243 }
22244 arg2 = static_cast< wxDateTime::NameFlags >(val2);
22245 }
22246 {
22247 PyThreadState* __tstate = wxPyBeginAllowThreads();
22248 result = wxDateTime::GetWeekDayName(arg1,arg2);
22249 wxPyEndAllowThreads(__tstate);
22250 if (PyErr_Occurred()) SWIG_fail;
22251 }
22252 {
22253 #if wxUSE_UNICODE
22254 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22255 #else
22256 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22257 #endif
22258 }
22259 return resultobj;
22260 fail:
22261 return NULL;
22262 }
22263
22264
22265 SWIGINTERN PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22266 PyObject *resultobj = 0;
22267 PyObject *result = 0 ;
22268
22269 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetAmPmStrings",0,0,0)) SWIG_fail;
22270 {
22271 PyThreadState* __tstate = wxPyBeginAllowThreads();
22272 result = (PyObject *)wxDateTime_GetAmPmStrings();
22273 wxPyEndAllowThreads(__tstate);
22274 if (PyErr_Occurred()) SWIG_fail;
22275 }
22276 resultobj = result;
22277 return resultobj;
22278 fail:
22279 return NULL;
22280 }
22281
22282
22283 SWIGINTERN PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22284 PyObject *resultobj = 0;
22285 int arg1 = (int) wxDateTime::Inv_Year ;
22286 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
22287 bool result;
22288 int val1 ;
22289 int ecode1 = 0 ;
22290 int val2 ;
22291 int ecode2 = 0 ;
22292 PyObject * obj0 = 0 ;
22293 PyObject * obj1 = 0 ;
22294 char * kwnames[] = {
22295 (char *) "year",(char *) "country", NULL
22296 };
22297
22298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) SWIG_fail;
22299 if (obj0) {
22300 ecode1 = SWIG_AsVal_int(obj0, &val1);
22301 if (!SWIG_IsOK(ecode1)) {
22302 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "1"" of type '" "int""'");
22303 }
22304 arg1 = static_cast< int >(val1);
22305 }
22306 if (obj1) {
22307 ecode2 = SWIG_AsVal_int(obj1, &val2);
22308 if (!SWIG_IsOK(ecode2)) {
22309 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
22310 }
22311 arg2 = static_cast< wxDateTime::Country >(val2);
22312 }
22313 {
22314 PyThreadState* __tstate = wxPyBeginAllowThreads();
22315 result = (bool)wxDateTime::IsDSTApplicable(arg1,arg2);
22316 wxPyEndAllowThreads(__tstate);
22317 if (PyErr_Occurred()) SWIG_fail;
22318 }
22319 {
22320 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22321 }
22322 return resultobj;
22323 fail:
22324 return NULL;
22325 }
22326
22327
22328 SWIGINTERN PyObject *_wrap_DateTime_GetBeginDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22329 PyObject *resultobj = 0;
22330 int arg1 = (int) wxDateTime::Inv_Year ;
22331 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
22332 wxDateTime result;
22333 int val1 ;
22334 int ecode1 = 0 ;
22335 int val2 ;
22336 int ecode2 = 0 ;
22337 PyObject * obj0 = 0 ;
22338 PyObject * obj1 = 0 ;
22339 char * kwnames[] = {
22340 (char *) "year",(char *) "country", NULL
22341 };
22342
22343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) SWIG_fail;
22344 if (obj0) {
22345 ecode1 = SWIG_AsVal_int(obj0, &val1);
22346 if (!SWIG_IsOK(ecode1)) {
22347 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetBeginDST" "', expected argument " "1"" of type '" "int""'");
22348 }
22349 arg1 = static_cast< int >(val1);
22350 }
22351 if (obj1) {
22352 ecode2 = SWIG_AsVal_int(obj1, &val2);
22353 if (!SWIG_IsOK(ecode2)) {
22354 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetBeginDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
22355 }
22356 arg2 = static_cast< wxDateTime::Country >(val2);
22357 }
22358 {
22359 PyThreadState* __tstate = wxPyBeginAllowThreads();
22360 result = wxDateTime::GetBeginDST(arg1,arg2);
22361 wxPyEndAllowThreads(__tstate);
22362 if (PyErr_Occurred()) SWIG_fail;
22363 }
22364 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22365 return resultobj;
22366 fail:
22367 return NULL;
22368 }
22369
22370
22371 SWIGINTERN PyObject *_wrap_DateTime_GetEndDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22372 PyObject *resultobj = 0;
22373 int arg1 = (int) wxDateTime::Inv_Year ;
22374 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
22375 wxDateTime result;
22376 int val1 ;
22377 int ecode1 = 0 ;
22378 int val2 ;
22379 int ecode2 = 0 ;
22380 PyObject * obj0 = 0 ;
22381 PyObject * obj1 = 0 ;
22382 char * kwnames[] = {
22383 (char *) "year",(char *) "country", NULL
22384 };
22385
22386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) SWIG_fail;
22387 if (obj0) {
22388 ecode1 = SWIG_AsVal_int(obj0, &val1);
22389 if (!SWIG_IsOK(ecode1)) {
22390 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetEndDST" "', expected argument " "1"" of type '" "int""'");
22391 }
22392 arg1 = static_cast< int >(val1);
22393 }
22394 if (obj1) {
22395 ecode2 = SWIG_AsVal_int(obj1, &val2);
22396 if (!SWIG_IsOK(ecode2)) {
22397 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetEndDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
22398 }
22399 arg2 = static_cast< wxDateTime::Country >(val2);
22400 }
22401 {
22402 PyThreadState* __tstate = wxPyBeginAllowThreads();
22403 result = wxDateTime::GetEndDST(arg1,arg2);
22404 wxPyEndAllowThreads(__tstate);
22405 if (PyErr_Occurred()) SWIG_fail;
22406 }
22407 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22408 return resultobj;
22409 fail:
22410 return NULL;
22411 }
22412
22413
22414 SWIGINTERN PyObject *_wrap_DateTime_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22415 PyObject *resultobj = 0;
22416 wxDateTime result;
22417
22418 if (!SWIG_Python_UnpackTuple(args,"DateTime_Now",0,0,0)) SWIG_fail;
22419 {
22420 PyThreadState* __tstate = wxPyBeginAllowThreads();
22421 result = wxDateTime::Now();
22422 wxPyEndAllowThreads(__tstate);
22423 if (PyErr_Occurred()) SWIG_fail;
22424 }
22425 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22426 return resultobj;
22427 fail:
22428 return NULL;
22429 }
22430
22431
22432 SWIGINTERN PyObject *_wrap_DateTime_UNow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22433 PyObject *resultobj = 0;
22434 wxDateTime result;
22435
22436 if (!SWIG_Python_UnpackTuple(args,"DateTime_UNow",0,0,0)) SWIG_fail;
22437 {
22438 PyThreadState* __tstate = wxPyBeginAllowThreads();
22439 result = wxDateTime::UNow();
22440 wxPyEndAllowThreads(__tstate);
22441 if (PyErr_Occurred()) SWIG_fail;
22442 }
22443 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22444 return resultobj;
22445 fail:
22446 return NULL;
22447 }
22448
22449
22450 SWIGINTERN PyObject *_wrap_DateTime_Today(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22451 PyObject *resultobj = 0;
22452 wxDateTime result;
22453
22454 if (!SWIG_Python_UnpackTuple(args,"DateTime_Today",0,0,0)) SWIG_fail;
22455 {
22456 PyThreadState* __tstate = wxPyBeginAllowThreads();
22457 result = wxDateTime::Today();
22458 wxPyEndAllowThreads(__tstate);
22459 if (PyErr_Occurred()) SWIG_fail;
22460 }
22461 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22462 return resultobj;
22463 fail:
22464 return NULL;
22465 }
22466
22467
22468 SWIGINTERN PyObject *_wrap_new_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22469 PyObject *resultobj = 0;
22470 wxDateTime *result = 0 ;
22471
22472 if (!SWIG_Python_UnpackTuple(args,"new_DateTime",0,0,0)) SWIG_fail;
22473 {
22474 PyThreadState* __tstate = wxPyBeginAllowThreads();
22475 result = (wxDateTime *)new wxDateTime();
22476 wxPyEndAllowThreads(__tstate);
22477 if (PyErr_Occurred()) SWIG_fail;
22478 }
22479 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_NEW | 0 );
22480 return resultobj;
22481 fail:
22482 return NULL;
22483 }
22484
22485
22486 SWIGINTERN PyObject *_wrap_new_DateTimeFromTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22487 PyObject *resultobj = 0;
22488 time_t arg1 ;
22489 wxDateTime *result = 0 ;
22490 unsigned int val1 ;
22491 int ecode1 = 0 ;
22492 PyObject * obj0 = 0 ;
22493 char * kwnames[] = {
22494 (char *) "timet", NULL
22495 };
22496
22497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) SWIG_fail;
22498 ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
22499 if (!SWIG_IsOK(ecode1)) {
22500 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromTimeT" "', expected argument " "1"" of type '" "time_t""'");
22501 }
22502 arg1 = static_cast< time_t >(val1);
22503 {
22504 PyThreadState* __tstate = wxPyBeginAllowThreads();
22505 result = (wxDateTime *)new wxDateTime(arg1);
22506 wxPyEndAllowThreads(__tstate);
22507 if (PyErr_Occurred()) SWIG_fail;
22508 }
22509 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22510 return resultobj;
22511 fail:
22512 return NULL;
22513 }
22514
22515
22516 SWIGINTERN PyObject *_wrap_new_DateTimeFromJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22517 PyObject *resultobj = 0;
22518 double arg1 ;
22519 wxDateTime *result = 0 ;
22520 double val1 ;
22521 int ecode1 = 0 ;
22522 PyObject * obj0 = 0 ;
22523 char * kwnames[] = {
22524 (char *) "jdn", NULL
22525 };
22526
22527 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) SWIG_fail;
22528 ecode1 = SWIG_AsVal_double(obj0, &val1);
22529 if (!SWIG_IsOK(ecode1)) {
22530 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromJDN" "', expected argument " "1"" of type '" "double""'");
22531 }
22532 arg1 = static_cast< double >(val1);
22533 {
22534 PyThreadState* __tstate = wxPyBeginAllowThreads();
22535 result = (wxDateTime *)new wxDateTime(arg1);
22536 wxPyEndAllowThreads(__tstate);
22537 if (PyErr_Occurred()) SWIG_fail;
22538 }
22539 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22540 return resultobj;
22541 fail:
22542 return NULL;
22543 }
22544
22545
22546 SWIGINTERN PyObject *_wrap_new_DateTimeFromHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22547 PyObject *resultobj = 0;
22548 int arg1 ;
22549 int arg2 = (int) 0 ;
22550 int arg3 = (int) 0 ;
22551 int arg4 = (int) 0 ;
22552 wxDateTime *result = 0 ;
22553 int val1 ;
22554 int ecode1 = 0 ;
22555 int val2 ;
22556 int ecode2 = 0 ;
22557 int val3 ;
22558 int ecode3 = 0 ;
22559 int val4 ;
22560 int ecode4 = 0 ;
22561 PyObject * obj0 = 0 ;
22562 PyObject * obj1 = 0 ;
22563 PyObject * obj2 = 0 ;
22564 PyObject * obj3 = 0 ;
22565 char * kwnames[] = {
22566 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
22567 };
22568
22569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
22570 ecode1 = SWIG_AsVal_int(obj0, &val1);
22571 if (!SWIG_IsOK(ecode1)) {
22572 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromHMS" "', expected argument " "1"" of type '" "int""'");
22573 }
22574 arg1 = static_cast< int >(val1);
22575 if (obj1) {
22576 ecode2 = SWIG_AsVal_int(obj1, &val2);
22577 if (!SWIG_IsOK(ecode2)) {
22578 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromHMS" "', expected argument " "2"" of type '" "int""'");
22579 }
22580 arg2 = static_cast< int >(val2);
22581 }
22582 if (obj2) {
22583 ecode3 = SWIG_AsVal_int(obj2, &val3);
22584 if (!SWIG_IsOK(ecode3)) {
22585 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromHMS" "', expected argument " "3"" of type '" "int""'");
22586 }
22587 arg3 = static_cast< int >(val3);
22588 }
22589 if (obj3) {
22590 ecode4 = SWIG_AsVal_int(obj3, &val4);
22591 if (!SWIG_IsOK(ecode4)) {
22592 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromHMS" "', expected argument " "4"" of type '" "int""'");
22593 }
22594 arg4 = static_cast< int >(val4);
22595 }
22596 {
22597 PyThreadState* __tstate = wxPyBeginAllowThreads();
22598 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
22599 wxPyEndAllowThreads(__tstate);
22600 if (PyErr_Occurred()) SWIG_fail;
22601 }
22602 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22603 return resultobj;
22604 fail:
22605 return NULL;
22606 }
22607
22608
22609 SWIGINTERN PyObject *_wrap_new_DateTimeFromDMY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22610 PyObject *resultobj = 0;
22611 int arg1 ;
22612 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
22613 int arg3 = (int) wxDateTime::Inv_Year ;
22614 int arg4 = (int) 0 ;
22615 int arg5 = (int) 0 ;
22616 int arg6 = (int) 0 ;
22617 int arg7 = (int) 0 ;
22618 wxDateTime *result = 0 ;
22619 int val1 ;
22620 int ecode1 = 0 ;
22621 int val2 ;
22622 int ecode2 = 0 ;
22623 int val3 ;
22624 int ecode3 = 0 ;
22625 int val4 ;
22626 int ecode4 = 0 ;
22627 int val5 ;
22628 int ecode5 = 0 ;
22629 int val6 ;
22630 int ecode6 = 0 ;
22631 int val7 ;
22632 int ecode7 = 0 ;
22633 PyObject * obj0 = 0 ;
22634 PyObject * obj1 = 0 ;
22635 PyObject * obj2 = 0 ;
22636 PyObject * obj3 = 0 ;
22637 PyObject * obj4 = 0 ;
22638 PyObject * obj5 = 0 ;
22639 PyObject * obj6 = 0 ;
22640 char * kwnames[] = {
22641 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
22642 };
22643
22644 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
22645 ecode1 = SWIG_AsVal_int(obj0, &val1);
22646 if (!SWIG_IsOK(ecode1)) {
22647 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromDMY" "', expected argument " "1"" of type '" "int""'");
22648 }
22649 arg1 = static_cast< int >(val1);
22650 if (obj1) {
22651 ecode2 = SWIG_AsVal_int(obj1, &val2);
22652 if (!SWIG_IsOK(ecode2)) {
22653 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromDMY" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
22654 }
22655 arg2 = static_cast< wxDateTime::Month >(val2);
22656 }
22657 if (obj2) {
22658 ecode3 = SWIG_AsVal_int(obj2, &val3);
22659 if (!SWIG_IsOK(ecode3)) {
22660 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromDMY" "', expected argument " "3"" of type '" "int""'");
22661 }
22662 arg3 = static_cast< int >(val3);
22663 }
22664 if (obj3) {
22665 ecode4 = SWIG_AsVal_int(obj3, &val4);
22666 if (!SWIG_IsOK(ecode4)) {
22667 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromDMY" "', expected argument " "4"" of type '" "int""'");
22668 }
22669 arg4 = static_cast< int >(val4);
22670 }
22671 if (obj4) {
22672 ecode5 = SWIG_AsVal_int(obj4, &val5);
22673 if (!SWIG_IsOK(ecode5)) {
22674 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DateTimeFromDMY" "', expected argument " "5"" of type '" "int""'");
22675 }
22676 arg5 = static_cast< int >(val5);
22677 }
22678 if (obj5) {
22679 ecode6 = SWIG_AsVal_int(obj5, &val6);
22680 if (!SWIG_IsOK(ecode6)) {
22681 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DateTimeFromDMY" "', expected argument " "6"" of type '" "int""'");
22682 }
22683 arg6 = static_cast< int >(val6);
22684 }
22685 if (obj6) {
22686 ecode7 = SWIG_AsVal_int(obj6, &val7);
22687 if (!SWIG_IsOK(ecode7)) {
22688 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_DateTimeFromDMY" "', expected argument " "7"" of type '" "int""'");
22689 }
22690 arg7 = static_cast< int >(val7);
22691 }
22692 {
22693 PyThreadState* __tstate = wxPyBeginAllowThreads();
22694 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
22695 wxPyEndAllowThreads(__tstate);
22696 if (PyErr_Occurred()) SWIG_fail;
22697 }
22698 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22699 return resultobj;
22700 fail:
22701 return NULL;
22702 }
22703
22704
22705 SWIGINTERN PyObject *_wrap_new_DateTimeFromDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22706 PyObject *resultobj = 0;
22707 wxDateTime *arg1 = 0 ;
22708 wxDateTime *result = 0 ;
22709 void *argp1 = 0 ;
22710 int res1 = 0 ;
22711 PyObject * obj0 = 0 ;
22712 char * kwnames[] = {
22713 (char *) "date", NULL
22714 };
22715
22716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromDateTime",kwnames,&obj0)) SWIG_fail;
22717 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDateTime, 0 | 0);
22718 if (!SWIG_IsOK(res1)) {
22719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
22720 }
22721 if (!argp1) {
22722 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
22723 }
22724 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22725 {
22726 PyThreadState* __tstate = wxPyBeginAllowThreads();
22727 result = (wxDateTime *)new wxDateTime((wxDateTime const &)*arg1);
22728 wxPyEndAllowThreads(__tstate);
22729 if (PyErr_Occurred()) SWIG_fail;
22730 }
22731 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22732 return resultobj;
22733 fail:
22734 return NULL;
22735 }
22736
22737
22738 SWIGINTERN PyObject *_wrap_delete_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22739 PyObject *resultobj = 0;
22740 wxDateTime *arg1 = (wxDateTime *) 0 ;
22741 void *argp1 = 0 ;
22742 int res1 = 0 ;
22743 PyObject *swig_obj[1] ;
22744
22745 if (!args) SWIG_fail;
22746 swig_obj[0] = args;
22747 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
22748 if (!SWIG_IsOK(res1)) {
22749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
22750 }
22751 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22752 {
22753 PyThreadState* __tstate = wxPyBeginAllowThreads();
22754 delete arg1;
22755
22756 wxPyEndAllowThreads(__tstate);
22757 if (PyErr_Occurred()) SWIG_fail;
22758 }
22759 resultobj = SWIG_Py_Void();
22760 return resultobj;
22761 fail:
22762 return NULL;
22763 }
22764
22765
22766 SWIGINTERN PyObject *_wrap_DateTime_SetToCurrent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22767 PyObject *resultobj = 0;
22768 wxDateTime *arg1 = (wxDateTime *) 0 ;
22769 wxDateTime *result = 0 ;
22770 void *argp1 = 0 ;
22771 int res1 = 0 ;
22772 PyObject *swig_obj[1] ;
22773
22774 if (!args) SWIG_fail;
22775 swig_obj[0] = args;
22776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
22777 if (!SWIG_IsOK(res1)) {
22778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToCurrent" "', expected argument " "1"" of type '" "wxDateTime *""'");
22779 }
22780 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22781 {
22782 PyThreadState* __tstate = wxPyBeginAllowThreads();
22783 {
22784 wxDateTime &_result_ref = (arg1)->SetToCurrent();
22785 result = (wxDateTime *) &_result_ref;
22786 }
22787 wxPyEndAllowThreads(__tstate);
22788 if (PyErr_Occurred()) SWIG_fail;
22789 }
22790 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
22791 return resultobj;
22792 fail:
22793 return NULL;
22794 }
22795
22796
22797 SWIGINTERN PyObject *_wrap_DateTime_SetTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22798 PyObject *resultobj = 0;
22799 wxDateTime *arg1 = (wxDateTime *) 0 ;
22800 time_t arg2 ;
22801 wxDateTime *result = 0 ;
22802 void *argp1 = 0 ;
22803 int res1 = 0 ;
22804 unsigned int val2 ;
22805 int ecode2 = 0 ;
22806 PyObject * obj0 = 0 ;
22807 PyObject * obj1 = 0 ;
22808 char * kwnames[] = {
22809 (char *) "self",(char *) "timet", NULL
22810 };
22811
22812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) SWIG_fail;
22813 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
22814 if (!SWIG_IsOK(res1)) {
22815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetTimeT" "', expected argument " "1"" of type '" "wxDateTime *""'");
22816 }
22817 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22818 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
22819 if (!SWIG_IsOK(ecode2)) {
22820 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetTimeT" "', expected argument " "2"" of type '" "time_t""'");
22821 }
22822 arg2 = static_cast< time_t >(val2);
22823 {
22824 PyThreadState* __tstate = wxPyBeginAllowThreads();
22825 {
22826 wxDateTime &_result_ref = (arg1)->Set(arg2);
22827 result = (wxDateTime *) &_result_ref;
22828 }
22829 wxPyEndAllowThreads(__tstate);
22830 if (PyErr_Occurred()) SWIG_fail;
22831 }
22832 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
22833 return resultobj;
22834 fail:
22835 return NULL;
22836 }
22837
22838
22839 SWIGINTERN PyObject *_wrap_DateTime_SetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22840 PyObject *resultobj = 0;
22841 wxDateTime *arg1 = (wxDateTime *) 0 ;
22842 double arg2 ;
22843 wxDateTime *result = 0 ;
22844 void *argp1 = 0 ;
22845 int res1 = 0 ;
22846 double val2 ;
22847 int ecode2 = 0 ;
22848 PyObject * obj0 = 0 ;
22849 PyObject * obj1 = 0 ;
22850 char * kwnames[] = {
22851 (char *) "self",(char *) "jdn", NULL
22852 };
22853
22854 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) SWIG_fail;
22855 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
22856 if (!SWIG_IsOK(res1)) {
22857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
22858 }
22859 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22860 ecode2 = SWIG_AsVal_double(obj1, &val2);
22861 if (!SWIG_IsOK(ecode2)) {
22862 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetJDN" "', expected argument " "2"" of type '" "double""'");
22863 }
22864 arg2 = static_cast< double >(val2);
22865 {
22866 PyThreadState* __tstate = wxPyBeginAllowThreads();
22867 {
22868 wxDateTime &_result_ref = (arg1)->Set(arg2);
22869 result = (wxDateTime *) &_result_ref;
22870 }
22871 wxPyEndAllowThreads(__tstate);
22872 if (PyErr_Occurred()) SWIG_fail;
22873 }
22874 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
22875 return resultobj;
22876 fail:
22877 return NULL;
22878 }
22879
22880
22881 SWIGINTERN PyObject *_wrap_DateTime_SetHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22882 PyObject *resultobj = 0;
22883 wxDateTime *arg1 = (wxDateTime *) 0 ;
22884 int arg2 ;
22885 int arg3 = (int) 0 ;
22886 int arg4 = (int) 0 ;
22887 int arg5 = (int) 0 ;
22888 wxDateTime *result = 0 ;
22889 void *argp1 = 0 ;
22890 int res1 = 0 ;
22891 int val2 ;
22892 int ecode2 = 0 ;
22893 int val3 ;
22894 int ecode3 = 0 ;
22895 int val4 ;
22896 int ecode4 = 0 ;
22897 int val5 ;
22898 int ecode5 = 0 ;
22899 PyObject * obj0 = 0 ;
22900 PyObject * obj1 = 0 ;
22901 PyObject * obj2 = 0 ;
22902 PyObject * obj3 = 0 ;
22903 PyObject * obj4 = 0 ;
22904 char * kwnames[] = {
22905 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
22906 };
22907
22908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
22909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
22910 if (!SWIG_IsOK(res1)) {
22911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHMS" "', expected argument " "1"" of type '" "wxDateTime *""'");
22912 }
22913 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22914 ecode2 = SWIG_AsVal_int(obj1, &val2);
22915 if (!SWIG_IsOK(ecode2)) {
22916 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHMS" "', expected argument " "2"" of type '" "int""'");
22917 }
22918 arg2 = static_cast< int >(val2);
22919 if (obj2) {
22920 ecode3 = SWIG_AsVal_int(obj2, &val3);
22921 if (!SWIG_IsOK(ecode3)) {
22922 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetHMS" "', expected argument " "3"" of type '" "int""'");
22923 }
22924 arg3 = static_cast< int >(val3);
22925 }
22926 if (obj3) {
22927 ecode4 = SWIG_AsVal_int(obj3, &val4);
22928 if (!SWIG_IsOK(ecode4)) {
22929 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetHMS" "', expected argument " "4"" of type '" "int""'");
22930 }
22931 arg4 = static_cast< int >(val4);
22932 }
22933 if (obj4) {
22934 ecode5 = SWIG_AsVal_int(obj4, &val5);
22935 if (!SWIG_IsOK(ecode5)) {
22936 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetHMS" "', expected argument " "5"" of type '" "int""'");
22937 }
22938 arg5 = static_cast< int >(val5);
22939 }
22940 {
22941 PyThreadState* __tstate = wxPyBeginAllowThreads();
22942 {
22943 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
22944 result = (wxDateTime *) &_result_ref;
22945 }
22946 wxPyEndAllowThreads(__tstate);
22947 if (PyErr_Occurred()) SWIG_fail;
22948 }
22949 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
22950 return resultobj;
22951 fail:
22952 return NULL;
22953 }
22954
22955
22956 SWIGINTERN PyObject *_wrap_DateTime_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22957 PyObject *resultobj = 0;
22958 wxDateTime *arg1 = (wxDateTime *) 0 ;
22959 int arg2 ;
22960 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
22961 int arg4 = (int) wxDateTime::Inv_Year ;
22962 int arg5 = (int) 0 ;
22963 int arg6 = (int) 0 ;
22964 int arg7 = (int) 0 ;
22965 int arg8 = (int) 0 ;
22966 wxDateTime *result = 0 ;
22967 void *argp1 = 0 ;
22968 int res1 = 0 ;
22969 int val2 ;
22970 int ecode2 = 0 ;
22971 int val3 ;
22972 int ecode3 = 0 ;
22973 int val4 ;
22974 int ecode4 = 0 ;
22975 int val5 ;
22976 int ecode5 = 0 ;
22977 int val6 ;
22978 int ecode6 = 0 ;
22979 int val7 ;
22980 int ecode7 = 0 ;
22981 int val8 ;
22982 int ecode8 = 0 ;
22983 PyObject * obj0 = 0 ;
22984 PyObject * obj1 = 0 ;
22985 PyObject * obj2 = 0 ;
22986 PyObject * obj3 = 0 ;
22987 PyObject * obj4 = 0 ;
22988 PyObject * obj5 = 0 ;
22989 PyObject * obj6 = 0 ;
22990 PyObject * obj7 = 0 ;
22991 char * kwnames[] = {
22992 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
22993 };
22994
22995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
22996 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
22997 if (!SWIG_IsOK(res1)) {
22998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Set" "', expected argument " "1"" of type '" "wxDateTime *""'");
22999 }
23000 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23001 ecode2 = SWIG_AsVal_int(obj1, &val2);
23002 if (!SWIG_IsOK(ecode2)) {
23003 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_Set" "', expected argument " "2"" of type '" "int""'");
23004 }
23005 arg2 = static_cast< int >(val2);
23006 if (obj2) {
23007 ecode3 = SWIG_AsVal_int(obj2, &val3);
23008 if (!SWIG_IsOK(ecode3)) {
23009 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_Set" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
23010 }
23011 arg3 = static_cast< wxDateTime::Month >(val3);
23012 }
23013 if (obj3) {
23014 ecode4 = SWIG_AsVal_int(obj3, &val4);
23015 if (!SWIG_IsOK(ecode4)) {
23016 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_Set" "', expected argument " "4"" of type '" "int""'");
23017 }
23018 arg4 = static_cast< int >(val4);
23019 }
23020 if (obj4) {
23021 ecode5 = SWIG_AsVal_int(obj4, &val5);
23022 if (!SWIG_IsOK(ecode5)) {
23023 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_Set" "', expected argument " "5"" of type '" "int""'");
23024 }
23025 arg5 = static_cast< int >(val5);
23026 }
23027 if (obj5) {
23028 ecode6 = SWIG_AsVal_int(obj5, &val6);
23029 if (!SWIG_IsOK(ecode6)) {
23030 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DateTime_Set" "', expected argument " "6"" of type '" "int""'");
23031 }
23032 arg6 = static_cast< int >(val6);
23033 }
23034 if (obj6) {
23035 ecode7 = SWIG_AsVal_int(obj6, &val7);
23036 if (!SWIG_IsOK(ecode7)) {
23037 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "DateTime_Set" "', expected argument " "7"" of type '" "int""'");
23038 }
23039 arg7 = static_cast< int >(val7);
23040 }
23041 if (obj7) {
23042 ecode8 = SWIG_AsVal_int(obj7, &val8);
23043 if (!SWIG_IsOK(ecode8)) {
23044 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "DateTime_Set" "', expected argument " "8"" of type '" "int""'");
23045 }
23046 arg8 = static_cast< int >(val8);
23047 }
23048 {
23049 PyThreadState* __tstate = wxPyBeginAllowThreads();
23050 {
23051 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
23052 result = (wxDateTime *) &_result_ref;
23053 }
23054 wxPyEndAllowThreads(__tstate);
23055 if (PyErr_Occurred()) SWIG_fail;
23056 }
23057 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23058 return resultobj;
23059 fail:
23060 return NULL;
23061 }
23062
23063
23064 SWIGINTERN PyObject *_wrap_DateTime_ResetTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23065 PyObject *resultobj = 0;
23066 wxDateTime *arg1 = (wxDateTime *) 0 ;
23067 wxDateTime *result = 0 ;
23068 void *argp1 = 0 ;
23069 int res1 = 0 ;
23070 PyObject *swig_obj[1] ;
23071
23072 if (!args) SWIG_fail;
23073 swig_obj[0] = args;
23074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23075 if (!SWIG_IsOK(res1)) {
23076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ResetTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
23077 }
23078 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23079 {
23080 PyThreadState* __tstate = wxPyBeginAllowThreads();
23081 {
23082 wxDateTime &_result_ref = (arg1)->ResetTime();
23083 result = (wxDateTime *) &_result_ref;
23084 }
23085 wxPyEndAllowThreads(__tstate);
23086 if (PyErr_Occurred()) SWIG_fail;
23087 }
23088 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23089 return resultobj;
23090 fail:
23091 return NULL;
23092 }
23093
23094
23095 SWIGINTERN PyObject *_wrap_DateTime_SetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23096 PyObject *resultobj = 0;
23097 wxDateTime *arg1 = (wxDateTime *) 0 ;
23098 int arg2 ;
23099 wxDateTime *result = 0 ;
23100 void *argp1 = 0 ;
23101 int res1 = 0 ;
23102 int val2 ;
23103 int ecode2 = 0 ;
23104 PyObject * obj0 = 0 ;
23105 PyObject * obj1 = 0 ;
23106 char * kwnames[] = {
23107 (char *) "self",(char *) "year", NULL
23108 };
23109
23110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) SWIG_fail;
23111 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23112 if (!SWIG_IsOK(res1)) {
23113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetYear" "', expected argument " "1"" of type '" "wxDateTime *""'");
23114 }
23115 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23116 ecode2 = SWIG_AsVal_int(obj1, &val2);
23117 if (!SWIG_IsOK(ecode2)) {
23118 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetYear" "', expected argument " "2"" of type '" "int""'");
23119 }
23120 arg2 = static_cast< int >(val2);
23121 {
23122 PyThreadState* __tstate = wxPyBeginAllowThreads();
23123 {
23124 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
23125 result = (wxDateTime *) &_result_ref;
23126 }
23127 wxPyEndAllowThreads(__tstate);
23128 if (PyErr_Occurred()) SWIG_fail;
23129 }
23130 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23131 return resultobj;
23132 fail:
23133 return NULL;
23134 }
23135
23136
23137 SWIGINTERN PyObject *_wrap_DateTime_SetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23138 PyObject *resultobj = 0;
23139 wxDateTime *arg1 = (wxDateTime *) 0 ;
23140 wxDateTime::Month arg2 ;
23141 wxDateTime *result = 0 ;
23142 void *argp1 = 0 ;
23143 int res1 = 0 ;
23144 int val2 ;
23145 int ecode2 = 0 ;
23146 PyObject * obj0 = 0 ;
23147 PyObject * obj1 = 0 ;
23148 char * kwnames[] = {
23149 (char *) "self",(char *) "month", NULL
23150 };
23151
23152 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
23153 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23154 if (!SWIG_IsOK(res1)) {
23155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMonth" "', expected argument " "1"" of type '" "wxDateTime *""'");
23156 }
23157 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23158 ecode2 = SWIG_AsVal_int(obj1, &val2);
23159 if (!SWIG_IsOK(ecode2)) {
23160 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMonth" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
23161 }
23162 arg2 = static_cast< wxDateTime::Month >(val2);
23163 {
23164 PyThreadState* __tstate = wxPyBeginAllowThreads();
23165 {
23166 wxDateTime &_result_ref = (arg1)->SetMonth(arg2);
23167 result = (wxDateTime *) &_result_ref;
23168 }
23169 wxPyEndAllowThreads(__tstate);
23170 if (PyErr_Occurred()) SWIG_fail;
23171 }
23172 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23173 return resultobj;
23174 fail:
23175 return NULL;
23176 }
23177
23178
23179 SWIGINTERN PyObject *_wrap_DateTime_SetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23180 PyObject *resultobj = 0;
23181 wxDateTime *arg1 = (wxDateTime *) 0 ;
23182 int arg2 ;
23183 wxDateTime *result = 0 ;
23184 void *argp1 = 0 ;
23185 int res1 = 0 ;
23186 int val2 ;
23187 int ecode2 = 0 ;
23188 PyObject * obj0 = 0 ;
23189 PyObject * obj1 = 0 ;
23190 char * kwnames[] = {
23191 (char *) "self",(char *) "day", NULL
23192 };
23193
23194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) SWIG_fail;
23195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23196 if (!SWIG_IsOK(res1)) {
23197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23198 }
23199 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23200 ecode2 = SWIG_AsVal_int(obj1, &val2);
23201 if (!SWIG_IsOK(ecode2)) {
23202 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetDay" "', expected argument " "2"" of type '" "int""'");
23203 }
23204 arg2 = static_cast< int >(val2);
23205 {
23206 PyThreadState* __tstate = wxPyBeginAllowThreads();
23207 {
23208 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
23209 result = (wxDateTime *) &_result_ref;
23210 }
23211 wxPyEndAllowThreads(__tstate);
23212 if (PyErr_Occurred()) SWIG_fail;
23213 }
23214 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23215 return resultobj;
23216 fail:
23217 return NULL;
23218 }
23219
23220
23221 SWIGINTERN PyObject *_wrap_DateTime_SetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23222 PyObject *resultobj = 0;
23223 wxDateTime *arg1 = (wxDateTime *) 0 ;
23224 int arg2 ;
23225 wxDateTime *result = 0 ;
23226 void *argp1 = 0 ;
23227 int res1 = 0 ;
23228 int val2 ;
23229 int ecode2 = 0 ;
23230 PyObject * obj0 = 0 ;
23231 PyObject * obj1 = 0 ;
23232 char * kwnames[] = {
23233 (char *) "self",(char *) "hour", NULL
23234 };
23235
23236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) SWIG_fail;
23237 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23238 if (!SWIG_IsOK(res1)) {
23239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHour" "', expected argument " "1"" of type '" "wxDateTime *""'");
23240 }
23241 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23242 ecode2 = SWIG_AsVal_int(obj1, &val2);
23243 if (!SWIG_IsOK(ecode2)) {
23244 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHour" "', expected argument " "2"" of type '" "int""'");
23245 }
23246 arg2 = static_cast< int >(val2);
23247 {
23248 PyThreadState* __tstate = wxPyBeginAllowThreads();
23249 {
23250 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
23251 result = (wxDateTime *) &_result_ref;
23252 }
23253 wxPyEndAllowThreads(__tstate);
23254 if (PyErr_Occurred()) SWIG_fail;
23255 }
23256 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23257 return resultobj;
23258 fail:
23259 return NULL;
23260 }
23261
23262
23263 SWIGINTERN PyObject *_wrap_DateTime_SetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23264 PyObject *resultobj = 0;
23265 wxDateTime *arg1 = (wxDateTime *) 0 ;
23266 int arg2 ;
23267 wxDateTime *result = 0 ;
23268 void *argp1 = 0 ;
23269 int res1 = 0 ;
23270 int val2 ;
23271 int ecode2 = 0 ;
23272 PyObject * obj0 = 0 ;
23273 PyObject * obj1 = 0 ;
23274 char * kwnames[] = {
23275 (char *) "self",(char *) "minute", NULL
23276 };
23277
23278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
23279 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23280 if (!SWIG_IsOK(res1)) {
23281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMinute" "', expected argument " "1"" of type '" "wxDateTime *""'");
23282 }
23283 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23284 ecode2 = SWIG_AsVal_int(obj1, &val2);
23285 if (!SWIG_IsOK(ecode2)) {
23286 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMinute" "', expected argument " "2"" of type '" "int""'");
23287 }
23288 arg2 = static_cast< int >(val2);
23289 {
23290 PyThreadState* __tstate = wxPyBeginAllowThreads();
23291 {
23292 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
23293 result = (wxDateTime *) &_result_ref;
23294 }
23295 wxPyEndAllowThreads(__tstate);
23296 if (PyErr_Occurred()) SWIG_fail;
23297 }
23298 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23299 return resultobj;
23300 fail:
23301 return NULL;
23302 }
23303
23304
23305 SWIGINTERN PyObject *_wrap_DateTime_SetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23306 PyObject *resultobj = 0;
23307 wxDateTime *arg1 = (wxDateTime *) 0 ;
23308 int arg2 ;
23309 wxDateTime *result = 0 ;
23310 void *argp1 = 0 ;
23311 int res1 = 0 ;
23312 int val2 ;
23313 int ecode2 = 0 ;
23314 PyObject * obj0 = 0 ;
23315 PyObject * obj1 = 0 ;
23316 char * kwnames[] = {
23317 (char *) "self",(char *) "second", NULL
23318 };
23319
23320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
23321 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23322 if (!SWIG_IsOK(res1)) {
23323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetSecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
23324 }
23325 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23326 ecode2 = SWIG_AsVal_int(obj1, &val2);
23327 if (!SWIG_IsOK(ecode2)) {
23328 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetSecond" "', expected argument " "2"" of type '" "int""'");
23329 }
23330 arg2 = static_cast< int >(val2);
23331 {
23332 PyThreadState* __tstate = wxPyBeginAllowThreads();
23333 {
23334 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
23335 result = (wxDateTime *) &_result_ref;
23336 }
23337 wxPyEndAllowThreads(__tstate);
23338 if (PyErr_Occurred()) SWIG_fail;
23339 }
23340 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23341 return resultobj;
23342 fail:
23343 return NULL;
23344 }
23345
23346
23347 SWIGINTERN PyObject *_wrap_DateTime_SetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23348 PyObject *resultobj = 0;
23349 wxDateTime *arg1 = (wxDateTime *) 0 ;
23350 int arg2 ;
23351 wxDateTime *result = 0 ;
23352 void *argp1 = 0 ;
23353 int res1 = 0 ;
23354 int val2 ;
23355 int ecode2 = 0 ;
23356 PyObject * obj0 = 0 ;
23357 PyObject * obj1 = 0 ;
23358 char * kwnames[] = {
23359 (char *) "self",(char *) "millisecond", NULL
23360 };
23361
23362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
23363 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23364 if (!SWIG_IsOK(res1)) {
23365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMillisecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
23366 }
23367 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23368 ecode2 = SWIG_AsVal_int(obj1, &val2);
23369 if (!SWIG_IsOK(ecode2)) {
23370 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMillisecond" "', expected argument " "2"" of type '" "int""'");
23371 }
23372 arg2 = static_cast< int >(val2);
23373 {
23374 PyThreadState* __tstate = wxPyBeginAllowThreads();
23375 {
23376 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
23377 result = (wxDateTime *) &_result_ref;
23378 }
23379 wxPyEndAllowThreads(__tstate);
23380 if (PyErr_Occurred()) SWIG_fail;
23381 }
23382 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23383 return resultobj;
23384 fail:
23385 return NULL;
23386 }
23387
23388
23389 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23390 PyObject *resultobj = 0;
23391 wxDateTime *arg1 = (wxDateTime *) 0 ;
23392 wxDateTime::WeekDay arg2 ;
23393 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
23394 wxDateTime *result = 0 ;
23395 void *argp1 = 0 ;
23396 int res1 = 0 ;
23397 int val2 ;
23398 int ecode2 = 0 ;
23399 int val3 ;
23400 int ecode3 = 0 ;
23401 PyObject * obj0 = 0 ;
23402 PyObject * obj1 = 0 ;
23403 PyObject * obj2 = 0 ;
23404 char * kwnames[] = {
23405 (char *) "self",(char *) "weekday",(char *) "flags", NULL
23406 };
23407
23408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23409 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23410 if (!SWIG_IsOK(res1)) {
23411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
23412 }
23413 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23414 ecode2 = SWIG_AsVal_int(obj1, &val2);
23415 if (!SWIG_IsOK(ecode2)) {
23416 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23417 }
23418 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23419 if (obj2) {
23420 ecode3 = SWIG_AsVal_int(obj2, &val3);
23421 if (!SWIG_IsOK(ecode3)) {
23422 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
23423 }
23424 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
23425 }
23426 {
23427 PyThreadState* __tstate = wxPyBeginAllowThreads();
23428 {
23429 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek(arg2,arg3);
23430 result = (wxDateTime *) &_result_ref;
23431 }
23432 wxPyEndAllowThreads(__tstate);
23433 if (PyErr_Occurred()) SWIG_fail;
23434 }
23435 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23436 return resultobj;
23437 fail:
23438 return NULL;
23439 }
23440
23441
23442 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23443 PyObject *resultobj = 0;
23444 wxDateTime *arg1 = (wxDateTime *) 0 ;
23445 wxDateTime::WeekDay arg2 ;
23446 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
23447 wxDateTime result;
23448 void *argp1 = 0 ;
23449 int res1 = 0 ;
23450 int val2 ;
23451 int ecode2 = 0 ;
23452 int val3 ;
23453 int ecode3 = 0 ;
23454 PyObject * obj0 = 0 ;
23455 PyObject * obj1 = 0 ;
23456 PyObject * obj2 = 0 ;
23457 char * kwnames[] = {
23458 (char *) "self",(char *) "weekday",(char *) "flags", NULL
23459 };
23460
23461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23462 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23463 if (!SWIG_IsOK(res1)) {
23464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
23465 }
23466 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23467 ecode2 = SWIG_AsVal_int(obj1, &val2);
23468 if (!SWIG_IsOK(ecode2)) {
23469 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23470 }
23471 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23472 if (obj2) {
23473 ecode3 = SWIG_AsVal_int(obj2, &val3);
23474 if (!SWIG_IsOK(ecode3)) {
23475 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
23476 }
23477 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
23478 }
23479 {
23480 PyThreadState* __tstate = wxPyBeginAllowThreads();
23481 result = (arg1)->GetWeekDayInSameWeek(arg2,arg3);
23482 wxPyEndAllowThreads(__tstate);
23483 if (PyErr_Occurred()) SWIG_fail;
23484 }
23485 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23486 return resultobj;
23487 fail:
23488 return NULL;
23489 }
23490
23491
23492 SWIGINTERN PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23493 PyObject *resultobj = 0;
23494 wxDateTime *arg1 = (wxDateTime *) 0 ;
23495 wxDateTime::WeekDay arg2 ;
23496 wxDateTime *result = 0 ;
23497 void *argp1 = 0 ;
23498 int res1 = 0 ;
23499 int val2 ;
23500 int ecode2 = 0 ;
23501 PyObject * obj0 = 0 ;
23502 PyObject * obj1 = 0 ;
23503 char * kwnames[] = {
23504 (char *) "self",(char *) "weekday", NULL
23505 };
23506
23507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
23508 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23509 if (!SWIG_IsOK(res1)) {
23510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23511 }
23512 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23513 ecode2 = SWIG_AsVal_int(obj1, &val2);
23514 if (!SWIG_IsOK(ecode2)) {
23515 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23516 }
23517 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23518 {
23519 PyThreadState* __tstate = wxPyBeginAllowThreads();
23520 {
23521 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay(arg2);
23522 result = (wxDateTime *) &_result_ref;
23523 }
23524 wxPyEndAllowThreads(__tstate);
23525 if (PyErr_Occurred()) SWIG_fail;
23526 }
23527 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23528 return resultobj;
23529 fail:
23530 return NULL;
23531 }
23532
23533
23534 SWIGINTERN PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23535 PyObject *resultobj = 0;
23536 wxDateTime *arg1 = (wxDateTime *) 0 ;
23537 wxDateTime::WeekDay arg2 ;
23538 wxDateTime result;
23539 void *argp1 = 0 ;
23540 int res1 = 0 ;
23541 int val2 ;
23542 int ecode2 = 0 ;
23543 PyObject * obj0 = 0 ;
23544 PyObject * obj1 = 0 ;
23545 char * kwnames[] = {
23546 (char *) "self",(char *) "weekday", NULL
23547 };
23548
23549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
23550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23551 if (!SWIG_IsOK(res1)) {
23552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23553 }
23554 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23555 ecode2 = SWIG_AsVal_int(obj1, &val2);
23556 if (!SWIG_IsOK(ecode2)) {
23557 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23558 }
23559 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23560 {
23561 PyThreadState* __tstate = wxPyBeginAllowThreads();
23562 result = (arg1)->GetNextWeekDay(arg2);
23563 wxPyEndAllowThreads(__tstate);
23564 if (PyErr_Occurred()) SWIG_fail;
23565 }
23566 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23567 return resultobj;
23568 fail:
23569 return NULL;
23570 }
23571
23572
23573 SWIGINTERN PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23574 PyObject *resultobj = 0;
23575 wxDateTime *arg1 = (wxDateTime *) 0 ;
23576 wxDateTime::WeekDay arg2 ;
23577 wxDateTime *result = 0 ;
23578 void *argp1 = 0 ;
23579 int res1 = 0 ;
23580 int val2 ;
23581 int ecode2 = 0 ;
23582 PyObject * obj0 = 0 ;
23583 PyObject * obj1 = 0 ;
23584 char * kwnames[] = {
23585 (char *) "self",(char *) "weekday", NULL
23586 };
23587
23588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
23589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23590 if (!SWIG_IsOK(res1)) {
23591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23592 }
23593 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23594 ecode2 = SWIG_AsVal_int(obj1, &val2);
23595 if (!SWIG_IsOK(ecode2)) {
23596 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23597 }
23598 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23599 {
23600 PyThreadState* __tstate = wxPyBeginAllowThreads();
23601 {
23602 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay(arg2);
23603 result = (wxDateTime *) &_result_ref;
23604 }
23605 wxPyEndAllowThreads(__tstate);
23606 if (PyErr_Occurred()) SWIG_fail;
23607 }
23608 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23609 return resultobj;
23610 fail:
23611 return NULL;
23612 }
23613
23614
23615 SWIGINTERN PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23616 PyObject *resultobj = 0;
23617 wxDateTime *arg1 = (wxDateTime *) 0 ;
23618 wxDateTime::WeekDay arg2 ;
23619 wxDateTime result;
23620 void *argp1 = 0 ;
23621 int res1 = 0 ;
23622 int val2 ;
23623 int ecode2 = 0 ;
23624 PyObject * obj0 = 0 ;
23625 PyObject * obj1 = 0 ;
23626 char * kwnames[] = {
23627 (char *) "self",(char *) "weekday", NULL
23628 };
23629
23630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
23631 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23632 if (!SWIG_IsOK(res1)) {
23633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23634 }
23635 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23636 ecode2 = SWIG_AsVal_int(obj1, &val2);
23637 if (!SWIG_IsOK(ecode2)) {
23638 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23639 }
23640 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23641 {
23642 PyThreadState* __tstate = wxPyBeginAllowThreads();
23643 result = (arg1)->GetPrevWeekDay(arg2);
23644 wxPyEndAllowThreads(__tstate);
23645 if (PyErr_Occurred()) SWIG_fail;
23646 }
23647 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23648 return resultobj;
23649 fail:
23650 return NULL;
23651 }
23652
23653
23654 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23655 PyObject *resultobj = 0;
23656 wxDateTime *arg1 = (wxDateTime *) 0 ;
23657 wxDateTime::WeekDay arg2 ;
23658 int arg3 = (int) 1 ;
23659 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23660 int arg5 = (int) wxDateTime::Inv_Year ;
23661 bool result;
23662 void *argp1 = 0 ;
23663 int res1 = 0 ;
23664 int val2 ;
23665 int ecode2 = 0 ;
23666 int val3 ;
23667 int ecode3 = 0 ;
23668 int val4 ;
23669 int ecode4 = 0 ;
23670 int val5 ;
23671 int ecode5 = 0 ;
23672 PyObject * obj0 = 0 ;
23673 PyObject * obj1 = 0 ;
23674 PyObject * obj2 = 0 ;
23675 PyObject * obj3 = 0 ;
23676 PyObject * obj4 = 0 ;
23677 char * kwnames[] = {
23678 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
23679 };
23680
23681 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
23682 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23683 if (!SWIG_IsOK(res1)) {
23684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23685 }
23686 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23687 ecode2 = SWIG_AsVal_int(obj1, &val2);
23688 if (!SWIG_IsOK(ecode2)) {
23689 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23690 }
23691 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23692 if (obj2) {
23693 ecode3 = SWIG_AsVal_int(obj2, &val3);
23694 if (!SWIG_IsOK(ecode3)) {
23695 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDay" "', expected argument " "3"" of type '" "int""'");
23696 }
23697 arg3 = static_cast< int >(val3);
23698 }
23699 if (obj3) {
23700 ecode4 = SWIG_AsVal_int(obj3, &val4);
23701 if (!SWIG_IsOK(ecode4)) {
23702 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToWeekDay" "', expected argument " "4"" of type '" "wxDateTime::Month""'");
23703 }
23704 arg4 = static_cast< wxDateTime::Month >(val4);
23705 }
23706 if (obj4) {
23707 ecode5 = SWIG_AsVal_int(obj4, &val5);
23708 if (!SWIG_IsOK(ecode5)) {
23709 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetToWeekDay" "', expected argument " "5"" of type '" "int""'");
23710 }
23711 arg5 = static_cast< int >(val5);
23712 }
23713 {
23714 PyThreadState* __tstate = wxPyBeginAllowThreads();
23715 result = (bool)(arg1)->SetToWeekDay(arg2,arg3,arg4,arg5);
23716 wxPyEndAllowThreads(__tstate);
23717 if (PyErr_Occurred()) SWIG_fail;
23718 }
23719 {
23720 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23721 }
23722 return resultobj;
23723 fail:
23724 return NULL;
23725 }
23726
23727
23728 SWIGINTERN PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23729 PyObject *resultobj = 0;
23730 wxDateTime *arg1 = (wxDateTime *) 0 ;
23731 wxDateTime::WeekDay arg2 ;
23732 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23733 int arg4 = (int) wxDateTime::Inv_Year ;
23734 bool result;
23735 void *argp1 = 0 ;
23736 int res1 = 0 ;
23737 int val2 ;
23738 int ecode2 = 0 ;
23739 int val3 ;
23740 int ecode3 = 0 ;
23741 int val4 ;
23742 int ecode4 = 0 ;
23743 PyObject * obj0 = 0 ;
23744 PyObject * obj1 = 0 ;
23745 PyObject * obj2 = 0 ;
23746 PyObject * obj3 = 0 ;
23747 char * kwnames[] = {
23748 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
23749 };
23750
23751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23752 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23753 if (!SWIG_IsOK(res1)) {
23754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23755 }
23756 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23757 ecode2 = SWIG_AsVal_int(obj1, &val2);
23758 if (!SWIG_IsOK(ecode2)) {
23759 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23760 }
23761 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23762 if (obj2) {
23763 ecode3 = SWIG_AsVal_int(obj2, &val3);
23764 if (!SWIG_IsOK(ecode3)) {
23765 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
23766 }
23767 arg3 = static_cast< wxDateTime::Month >(val3);
23768 }
23769 if (obj3) {
23770 ecode4 = SWIG_AsVal_int(obj3, &val4);
23771 if (!SWIG_IsOK(ecode4)) {
23772 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "4"" of type '" "int""'");
23773 }
23774 arg4 = static_cast< int >(val4);
23775 }
23776 {
23777 PyThreadState* __tstate = wxPyBeginAllowThreads();
23778 result = (bool)(arg1)->SetToLastWeekDay(arg2,arg3,arg4);
23779 wxPyEndAllowThreads(__tstate);
23780 if (PyErr_Occurred()) SWIG_fail;
23781 }
23782 {
23783 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23784 }
23785 return resultobj;
23786 fail:
23787 return NULL;
23788 }
23789
23790
23791 SWIGINTERN PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23792 PyObject *resultobj = 0;
23793 wxDateTime *arg1 = (wxDateTime *) 0 ;
23794 wxDateTime::WeekDay arg2 ;
23795 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23796 int arg4 = (int) wxDateTime::Inv_Year ;
23797 wxDateTime result;
23798 void *argp1 = 0 ;
23799 int res1 = 0 ;
23800 int val2 ;
23801 int ecode2 = 0 ;
23802 int val3 ;
23803 int ecode3 = 0 ;
23804 int val4 ;
23805 int ecode4 = 0 ;
23806 PyObject * obj0 = 0 ;
23807 PyObject * obj1 = 0 ;
23808 PyObject * obj2 = 0 ;
23809 PyObject * obj3 = 0 ;
23810 char * kwnames[] = {
23811 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
23812 };
23813
23814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23816 if (!SWIG_IsOK(res1)) {
23817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23818 }
23819 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23820 ecode2 = SWIG_AsVal_int(obj1, &val2);
23821 if (!SWIG_IsOK(ecode2)) {
23822 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23823 }
23824 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23825 if (obj2) {
23826 ecode3 = SWIG_AsVal_int(obj2, &val3);
23827 if (!SWIG_IsOK(ecode3)) {
23828 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
23829 }
23830 arg3 = static_cast< wxDateTime::Month >(val3);
23831 }
23832 if (obj3) {
23833 ecode4 = SWIG_AsVal_int(obj3, &val4);
23834 if (!SWIG_IsOK(ecode4)) {
23835 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "4"" of type '" "int""'");
23836 }
23837 arg4 = static_cast< int >(val4);
23838 }
23839 {
23840 PyThreadState* __tstate = wxPyBeginAllowThreads();
23841 result = (arg1)->GetLastWeekDay(arg2,arg3,arg4);
23842 wxPyEndAllowThreads(__tstate);
23843 if (PyErr_Occurred()) SWIG_fail;
23844 }
23845 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23846 return resultobj;
23847 fail:
23848 return NULL;
23849 }
23850
23851
23852 SWIGINTERN PyObject *_wrap_DateTime_SetToTheWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23853 PyObject *resultobj = 0;
23854 wxDateTime *arg1 = (wxDateTime *) 0 ;
23855 int arg2 ;
23856 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
23857 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
23858 bool result;
23859 void *argp1 = 0 ;
23860 int res1 = 0 ;
23861 int val2 ;
23862 int ecode2 = 0 ;
23863 int val3 ;
23864 int ecode3 = 0 ;
23865 int val4 ;
23866 int ecode4 = 0 ;
23867 PyObject * obj0 = 0 ;
23868 PyObject * obj1 = 0 ;
23869 PyObject * obj2 = 0 ;
23870 PyObject * obj3 = 0 ;
23871 char * kwnames[] = {
23872 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
23873 };
23874
23875 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23876 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23877 if (!SWIG_IsOK(res1)) {
23878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToTheWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
23879 }
23880 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23881 ecode2 = SWIG_AsVal_int(obj1, &val2);
23882 if (!SWIG_IsOK(ecode2)) {
23883 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToTheWeek" "', expected argument " "2"" of type '" "int""'");
23884 }
23885 arg2 = static_cast< int >(val2);
23886 if (obj2) {
23887 ecode3 = SWIG_AsVal_int(obj2, &val3);
23888 if (!SWIG_IsOK(ecode3)) {
23889 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToTheWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
23890 }
23891 arg3 = static_cast< wxDateTime::WeekDay >(val3);
23892 }
23893 if (obj3) {
23894 ecode4 = SWIG_AsVal_int(obj3, &val4);
23895 if (!SWIG_IsOK(ecode4)) {
23896 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToTheWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
23897 }
23898 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
23899 }
23900 {
23901 PyThreadState* __tstate = wxPyBeginAllowThreads();
23902 result = (bool)(arg1)->SetToTheWeek(arg2,arg3,arg4);
23903 wxPyEndAllowThreads(__tstate);
23904 if (PyErr_Occurred()) SWIG_fail;
23905 }
23906 {
23907 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23908 }
23909 return resultobj;
23910 fail:
23911 return NULL;
23912 }
23913
23914
23915 SWIGINTERN PyObject *_wrap_DateTime_GetWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23916 PyObject *resultobj = 0;
23917 wxDateTime *arg1 = (wxDateTime *) 0 ;
23918 int arg2 ;
23919 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
23920 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
23921 wxDateTime result;
23922 void *argp1 = 0 ;
23923 int res1 = 0 ;
23924 int val2 ;
23925 int ecode2 = 0 ;
23926 int val3 ;
23927 int ecode3 = 0 ;
23928 int val4 ;
23929 int ecode4 = 0 ;
23930 PyObject * obj0 = 0 ;
23931 PyObject * obj1 = 0 ;
23932 PyObject * obj2 = 0 ;
23933 PyObject * obj3 = 0 ;
23934 char * kwnames[] = {
23935 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
23936 };
23937
23938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23940 if (!SWIG_IsOK(res1)) {
23941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
23942 }
23943 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23944 ecode2 = SWIG_AsVal_int(obj1, &val2);
23945 if (!SWIG_IsOK(ecode2)) {
23946 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeek" "', expected argument " "2"" of type '" "int""'");
23947 }
23948 arg2 = static_cast< int >(val2);
23949 if (obj2) {
23950 ecode3 = SWIG_AsVal_int(obj2, &val3);
23951 if (!SWIG_IsOK(ecode3)) {
23952 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
23953 }
23954 arg3 = static_cast< wxDateTime::WeekDay >(val3);
23955 }
23956 if (obj3) {
23957 ecode4 = SWIG_AsVal_int(obj3, &val4);
23958 if (!SWIG_IsOK(ecode4)) {
23959 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
23960 }
23961 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
23962 }
23963 {
23964 PyThreadState* __tstate = wxPyBeginAllowThreads();
23965 result = (arg1)->GetWeek(arg2,arg3,arg4);
23966 wxPyEndAllowThreads(__tstate);
23967 if (PyErr_Occurred()) SWIG_fail;
23968 }
23969 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23970 return resultobj;
23971 fail:
23972 return NULL;
23973 }
23974
23975
23976 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23977 PyObject *resultobj = 0;
23978 int arg1 ;
23979 int arg2 ;
23980 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
23981 wxDateTime result;
23982 int val1 ;
23983 int ecode1 = 0 ;
23984 int val2 ;
23985 int ecode2 = 0 ;
23986 int val3 ;
23987 int ecode3 = 0 ;
23988 PyObject * obj0 = 0 ;
23989 PyObject * obj1 = 0 ;
23990 PyObject * obj2 = 0 ;
23991 char * kwnames[] = {
23992 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
23993 };
23994
23995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23996 ecode1 = SWIG_AsVal_int(obj0, &val1);
23997 if (!SWIG_IsOK(ecode1)) {
23998 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "1"" of type '" "int""'");
23999 }
24000 arg1 = static_cast< int >(val1);
24001 ecode2 = SWIG_AsVal_int(obj1, &val2);
24002 if (!SWIG_IsOK(ecode2)) {
24003 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "2"" of type '" "int""'");
24004 }
24005 arg2 = static_cast< int >(val2);
24006 if (obj2) {
24007 ecode3 = SWIG_AsVal_int(obj2, &val3);
24008 if (!SWIG_IsOK(ecode3)) {
24009 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
24010 }
24011 arg3 = static_cast< wxDateTime::WeekDay >(val3);
24012 }
24013 {
24014 PyThreadState* __tstate = wxPyBeginAllowThreads();
24015 result = wxDateTime::SetToWeekOfYear(arg1,arg2,arg3);
24016 wxPyEndAllowThreads(__tstate);
24017 if (PyErr_Occurred()) SWIG_fail;
24018 }
24019 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24020 return resultobj;
24021 fail:
24022 return NULL;
24023 }
24024
24025
24026 SWIGINTERN PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24027 PyObject *resultobj = 0;
24028 wxDateTime *arg1 = (wxDateTime *) 0 ;
24029 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24030 int arg3 = (int) wxDateTime::Inv_Year ;
24031 wxDateTime *result = 0 ;
24032 void *argp1 = 0 ;
24033 int res1 = 0 ;
24034 int val2 ;
24035 int ecode2 = 0 ;
24036 int val3 ;
24037 int ecode3 = 0 ;
24038 PyObject * obj0 = 0 ;
24039 PyObject * obj1 = 0 ;
24040 PyObject * obj2 = 0 ;
24041 char * kwnames[] = {
24042 (char *) "self",(char *) "month",(char *) "year", NULL
24043 };
24044
24045 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24046 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24047 if (!SWIG_IsOK(res1)) {
24048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24049 }
24050 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24051 if (obj1) {
24052 ecode2 = SWIG_AsVal_int(obj1, &val2);
24053 if (!SWIG_IsOK(ecode2)) {
24054 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24055 }
24056 arg2 = static_cast< wxDateTime::Month >(val2);
24057 }
24058 if (obj2) {
24059 ecode3 = SWIG_AsVal_int(obj2, &val3);
24060 if (!SWIG_IsOK(ecode3)) {
24061 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "3"" of type '" "int""'");
24062 }
24063 arg3 = static_cast< int >(val3);
24064 }
24065 {
24066 PyThreadState* __tstate = wxPyBeginAllowThreads();
24067 {
24068 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay(arg2,arg3);
24069 result = (wxDateTime *) &_result_ref;
24070 }
24071 wxPyEndAllowThreads(__tstate);
24072 if (PyErr_Occurred()) SWIG_fail;
24073 }
24074 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24075 return resultobj;
24076 fail:
24077 return NULL;
24078 }
24079
24080
24081 SWIGINTERN PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24082 PyObject *resultobj = 0;
24083 wxDateTime *arg1 = (wxDateTime *) 0 ;
24084 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24085 int arg3 = (int) wxDateTime::Inv_Year ;
24086 wxDateTime result;
24087 void *argp1 = 0 ;
24088 int res1 = 0 ;
24089 int val2 ;
24090 int ecode2 = 0 ;
24091 int val3 ;
24092 int ecode3 = 0 ;
24093 PyObject * obj0 = 0 ;
24094 PyObject * obj1 = 0 ;
24095 PyObject * obj2 = 0 ;
24096 char * kwnames[] = {
24097 (char *) "self",(char *) "month",(char *) "year", NULL
24098 };
24099
24100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24101 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24102 if (!SWIG_IsOK(res1)) {
24103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24104 }
24105 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24106 if (obj1) {
24107 ecode2 = SWIG_AsVal_int(obj1, &val2);
24108 if (!SWIG_IsOK(ecode2)) {
24109 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24110 }
24111 arg2 = static_cast< wxDateTime::Month >(val2);
24112 }
24113 if (obj2) {
24114 ecode3 = SWIG_AsVal_int(obj2, &val3);
24115 if (!SWIG_IsOK(ecode3)) {
24116 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "3"" of type '" "int""'");
24117 }
24118 arg3 = static_cast< int >(val3);
24119 }
24120 {
24121 PyThreadState* __tstate = wxPyBeginAllowThreads();
24122 result = (arg1)->GetLastMonthDay(arg2,arg3);
24123 wxPyEndAllowThreads(__tstate);
24124 if (PyErr_Occurred()) SWIG_fail;
24125 }
24126 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24127 return resultobj;
24128 fail:
24129 return NULL;
24130 }
24131
24132
24133 SWIGINTERN PyObject *_wrap_DateTime_SetToYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24134 PyObject *resultobj = 0;
24135 wxDateTime *arg1 = (wxDateTime *) 0 ;
24136 int arg2 ;
24137 wxDateTime *result = 0 ;
24138 void *argp1 = 0 ;
24139 int res1 = 0 ;
24140 int val2 ;
24141 int ecode2 = 0 ;
24142 PyObject * obj0 = 0 ;
24143 PyObject * obj1 = 0 ;
24144 char * kwnames[] = {
24145 (char *) "self",(char *) "yday", NULL
24146 };
24147
24148 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
24149 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24150 if (!SWIG_IsOK(res1)) {
24151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24152 }
24153 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24154 ecode2 = SWIG_AsVal_int(obj1, &val2);
24155 if (!SWIG_IsOK(ecode2)) {
24156 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToYearDay" "', expected argument " "2"" of type '" "int""'");
24157 }
24158 arg2 = static_cast< int >(val2);
24159 {
24160 PyThreadState* __tstate = wxPyBeginAllowThreads();
24161 {
24162 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
24163 result = (wxDateTime *) &_result_ref;
24164 }
24165 wxPyEndAllowThreads(__tstate);
24166 if (PyErr_Occurred()) SWIG_fail;
24167 }
24168 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24169 return resultobj;
24170 fail:
24171 return NULL;
24172 }
24173
24174
24175 SWIGINTERN PyObject *_wrap_DateTime_GetYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24176 PyObject *resultobj = 0;
24177 wxDateTime *arg1 = (wxDateTime *) 0 ;
24178 int arg2 ;
24179 wxDateTime result;
24180 void *argp1 = 0 ;
24181 int res1 = 0 ;
24182 int val2 ;
24183 int ecode2 = 0 ;
24184 PyObject * obj0 = 0 ;
24185 PyObject * obj1 = 0 ;
24186 char * kwnames[] = {
24187 (char *) "self",(char *) "yday", NULL
24188 };
24189
24190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
24191 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24192 if (!SWIG_IsOK(res1)) {
24193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24194 }
24195 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24196 ecode2 = SWIG_AsVal_int(obj1, &val2);
24197 if (!SWIG_IsOK(ecode2)) {
24198 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetYearDay" "', expected argument " "2"" of type '" "int""'");
24199 }
24200 arg2 = static_cast< int >(val2);
24201 {
24202 PyThreadState* __tstate = wxPyBeginAllowThreads();
24203 result = (arg1)->GetYearDay(arg2);
24204 wxPyEndAllowThreads(__tstate);
24205 if (PyErr_Occurred()) SWIG_fail;
24206 }
24207 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24208 return resultobj;
24209 fail:
24210 return NULL;
24211 }
24212
24213
24214 SWIGINTERN PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24215 PyObject *resultobj = 0;
24216 wxDateTime *arg1 = (wxDateTime *) 0 ;
24217 double result;
24218 void *argp1 = 0 ;
24219 int res1 = 0 ;
24220 PyObject *swig_obj[1] ;
24221
24222 if (!args) SWIG_fail;
24223 swig_obj[0] = args;
24224 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24225 if (!SWIG_IsOK(res1)) {
24226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime *""'");
24227 }
24228 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24229 {
24230 PyThreadState* __tstate = wxPyBeginAllowThreads();
24231 result = (double)(arg1)->GetJulianDayNumber();
24232 wxPyEndAllowThreads(__tstate);
24233 if (PyErr_Occurred()) SWIG_fail;
24234 }
24235 resultobj = SWIG_From_double(static_cast< double >(result));
24236 return resultobj;
24237 fail:
24238 return NULL;
24239 }
24240
24241
24242 SWIGINTERN PyObject *_wrap_DateTime_GetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24243 PyObject *resultobj = 0;
24244 wxDateTime *arg1 = (wxDateTime *) 0 ;
24245 double result;
24246 void *argp1 = 0 ;
24247 int res1 = 0 ;
24248 PyObject *swig_obj[1] ;
24249
24250 if (!args) SWIG_fail;
24251 swig_obj[0] = args;
24252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24253 if (!SWIG_IsOK(res1)) {
24254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
24255 }
24256 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24257 {
24258 PyThreadState* __tstate = wxPyBeginAllowThreads();
24259 result = (double)(arg1)->GetJDN();
24260 wxPyEndAllowThreads(__tstate);
24261 if (PyErr_Occurred()) SWIG_fail;
24262 }
24263 resultobj = SWIG_From_double(static_cast< double >(result));
24264 return resultobj;
24265 fail:
24266 return NULL;
24267 }
24268
24269
24270 SWIGINTERN PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24271 PyObject *resultobj = 0;
24272 wxDateTime *arg1 = (wxDateTime *) 0 ;
24273 double result;
24274 void *argp1 = 0 ;
24275 int res1 = 0 ;
24276 PyObject *swig_obj[1] ;
24277
24278 if (!args) SWIG_fail;
24279 swig_obj[0] = args;
24280 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24281 if (!SWIG_IsOK(res1)) {
24282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetModifiedJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24283 }
24284 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24285 {
24286 PyThreadState* __tstate = wxPyBeginAllowThreads();
24287 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
24288 wxPyEndAllowThreads(__tstate);
24289 if (PyErr_Occurred()) SWIG_fail;
24290 }
24291 resultobj = SWIG_From_double(static_cast< double >(result));
24292 return resultobj;
24293 fail:
24294 return NULL;
24295 }
24296
24297
24298 SWIGINTERN PyObject *_wrap_DateTime_GetMJD(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24299 PyObject *resultobj = 0;
24300 wxDateTime *arg1 = (wxDateTime *) 0 ;
24301 double result;
24302 void *argp1 = 0 ;
24303 int res1 = 0 ;
24304 PyObject *swig_obj[1] ;
24305
24306 if (!args) SWIG_fail;
24307 swig_obj[0] = args;
24308 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24309 if (!SWIG_IsOK(res1)) {
24310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMJD" "', expected argument " "1"" of type '" "wxDateTime *""'");
24311 }
24312 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24313 {
24314 PyThreadState* __tstate = wxPyBeginAllowThreads();
24315 result = (double)(arg1)->GetMJD();
24316 wxPyEndAllowThreads(__tstate);
24317 if (PyErr_Occurred()) SWIG_fail;
24318 }
24319 resultobj = SWIG_From_double(static_cast< double >(result));
24320 return resultobj;
24321 fail:
24322 return NULL;
24323 }
24324
24325
24326 SWIGINTERN PyObject *_wrap_DateTime_GetRataDie(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24327 PyObject *resultobj = 0;
24328 wxDateTime *arg1 = (wxDateTime *) 0 ;
24329 double result;
24330 void *argp1 = 0 ;
24331 int res1 = 0 ;
24332 PyObject *swig_obj[1] ;
24333
24334 if (!args) SWIG_fail;
24335 swig_obj[0] = args;
24336 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24337 if (!SWIG_IsOK(res1)) {
24338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetRataDie" "', expected argument " "1"" of type '" "wxDateTime *""'");
24339 }
24340 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24341 {
24342 PyThreadState* __tstate = wxPyBeginAllowThreads();
24343 result = (double)(arg1)->GetRataDie();
24344 wxPyEndAllowThreads(__tstate);
24345 if (PyErr_Occurred()) SWIG_fail;
24346 }
24347 resultobj = SWIG_From_double(static_cast< double >(result));
24348 return resultobj;
24349 fail:
24350 return NULL;
24351 }
24352
24353
24354 SWIGINTERN PyObject *_wrap_DateTime_ToTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24355 PyObject *resultobj = 0;
24356 wxDateTime *arg1 = (wxDateTime *) 0 ;
24357 wxDateTime::TimeZone *arg2 = 0 ;
24358 bool arg3 = (bool) false ;
24359 wxDateTime result;
24360 void *argp1 = 0 ;
24361 int res1 = 0 ;
24362 bool temp2 = false ;
24363 bool val3 ;
24364 int ecode3 = 0 ;
24365 PyObject * obj0 = 0 ;
24366 PyObject * obj1 = 0 ;
24367 PyObject * obj2 = 0 ;
24368 char * kwnames[] = {
24369 (char *) "self",(char *) "tz",(char *) "noDST", NULL
24370 };
24371
24372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24373 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24374 if (!SWIG_IsOK(res1)) {
24375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
24376 }
24377 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24378 {
24379 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24380 temp2 = true;
24381 }
24382 if (obj2) {
24383 ecode3 = SWIG_AsVal_bool(obj2, &val3);
24384 if (!SWIG_IsOK(ecode3)) {
24385 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_ToTimezone" "', expected argument " "3"" of type '" "bool""'");
24386 }
24387 arg3 = static_cast< bool >(val3);
24388 }
24389 {
24390 PyThreadState* __tstate = wxPyBeginAllowThreads();
24391 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
24392 wxPyEndAllowThreads(__tstate);
24393 if (PyErr_Occurred()) SWIG_fail;
24394 }
24395 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24396 {
24397 if (temp2) delete arg2;
24398 }
24399 return resultobj;
24400 fail:
24401 {
24402 if (temp2) delete arg2;
24403 }
24404 return NULL;
24405 }
24406
24407
24408 SWIGINTERN PyObject *_wrap_DateTime_MakeTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24409 PyObject *resultobj = 0;
24410 wxDateTime *arg1 = (wxDateTime *) 0 ;
24411 wxDateTime::TimeZone *arg2 = 0 ;
24412 bool arg3 = (bool) false ;
24413 wxDateTime *result = 0 ;
24414 void *argp1 = 0 ;
24415 int res1 = 0 ;
24416 bool temp2 = false ;
24417 bool val3 ;
24418 int ecode3 = 0 ;
24419 PyObject * obj0 = 0 ;
24420 PyObject * obj1 = 0 ;
24421 PyObject * obj2 = 0 ;
24422 char * kwnames[] = {
24423 (char *) "self",(char *) "tz",(char *) "noDST", NULL
24424 };
24425
24426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24427 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24428 if (!SWIG_IsOK(res1)) {
24429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
24430 }
24431 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24432 {
24433 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24434 temp2 = true;
24435 }
24436 if (obj2) {
24437 ecode3 = SWIG_AsVal_bool(obj2, &val3);
24438 if (!SWIG_IsOK(ecode3)) {
24439 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeTimezone" "', expected argument " "3"" of type '" "bool""'");
24440 }
24441 arg3 = static_cast< bool >(val3);
24442 }
24443 {
24444 PyThreadState* __tstate = wxPyBeginAllowThreads();
24445 {
24446 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
24447 result = (wxDateTime *) &_result_ref;
24448 }
24449 wxPyEndAllowThreads(__tstate);
24450 if (PyErr_Occurred()) SWIG_fail;
24451 }
24452 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24453 {
24454 if (temp2) delete arg2;
24455 }
24456 return resultobj;
24457 fail:
24458 {
24459 if (temp2) delete arg2;
24460 }
24461 return NULL;
24462 }
24463
24464
24465 SWIGINTERN PyObject *_wrap_DateTime_FromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24466 PyObject *resultobj = 0;
24467 wxDateTime *arg1 = (wxDateTime *) 0 ;
24468 wxDateTime::TimeZone *arg2 = 0 ;
24469 bool arg3 = (bool) false ;
24470 wxDateTime result;
24471 void *argp1 = 0 ;
24472 int res1 = 0 ;
24473 bool temp2 = false ;
24474 bool val3 ;
24475 int ecode3 = 0 ;
24476 PyObject * obj0 = 0 ;
24477 PyObject * obj1 = 0 ;
24478 PyObject * obj2 = 0 ;
24479 char * kwnames[] = {
24480 (char *) "self",(char *) "tz",(char *) "noDST", NULL
24481 };
24482
24483 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_FromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24484 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24485 if (!SWIG_IsOK(res1)) {
24486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromTimezone" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24487 }
24488 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24489 {
24490 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24491 temp2 = true;
24492 }
24493 if (obj2) {
24494 ecode3 = SWIG_AsVal_bool(obj2, &val3);
24495 if (!SWIG_IsOK(ecode3)) {
24496 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_FromTimezone" "', expected argument " "3"" of type '" "bool""'");
24497 }
24498 arg3 = static_cast< bool >(val3);
24499 }
24500 {
24501 PyThreadState* __tstate = wxPyBeginAllowThreads();
24502 result = ((wxDateTime const *)arg1)->FromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
24503 wxPyEndAllowThreads(__tstate);
24504 if (PyErr_Occurred()) SWIG_fail;
24505 }
24506 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24507 {
24508 if (temp2) delete arg2;
24509 }
24510 return resultobj;
24511 fail:
24512 {
24513 if (temp2) delete arg2;
24514 }
24515 return NULL;
24516 }
24517
24518
24519 SWIGINTERN PyObject *_wrap_DateTime_MakeFromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24520 PyObject *resultobj = 0;
24521 wxDateTime *arg1 = (wxDateTime *) 0 ;
24522 wxDateTime::TimeZone *arg2 = 0 ;
24523 bool arg3 = (bool) false ;
24524 wxDateTime *result = 0 ;
24525 void *argp1 = 0 ;
24526 int res1 = 0 ;
24527 bool temp2 = false ;
24528 bool val3 ;
24529 int ecode3 = 0 ;
24530 PyObject * obj0 = 0 ;
24531 PyObject * obj1 = 0 ;
24532 PyObject * obj2 = 0 ;
24533 char * kwnames[] = {
24534 (char *) "self",(char *) "tz",(char *) "noDST", NULL
24535 };
24536
24537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeFromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24538 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24539 if (!SWIG_IsOK(res1)) {
24540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
24541 }
24542 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24543 {
24544 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24545 temp2 = true;
24546 }
24547 if (obj2) {
24548 ecode3 = SWIG_AsVal_bool(obj2, &val3);
24549 if (!SWIG_IsOK(ecode3)) {
24550 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "3"" of type '" "bool""'");
24551 }
24552 arg3 = static_cast< bool >(val3);
24553 }
24554 {
24555 PyThreadState* __tstate = wxPyBeginAllowThreads();
24556 {
24557 wxDateTime &_result_ref = (arg1)->MakeFromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
24558 result = (wxDateTime *) &_result_ref;
24559 }
24560 wxPyEndAllowThreads(__tstate);
24561 if (PyErr_Occurred()) SWIG_fail;
24562 }
24563 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24564 {
24565 if (temp2) delete arg2;
24566 }
24567 return resultobj;
24568 fail:
24569 {
24570 if (temp2) delete arg2;
24571 }
24572 return NULL;
24573 }
24574
24575
24576 SWIGINTERN PyObject *_wrap_DateTime_ToUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24577 PyObject *resultobj = 0;
24578 wxDateTime *arg1 = (wxDateTime *) 0 ;
24579 bool arg2 = (bool) false ;
24580 wxDateTime result;
24581 void *argp1 = 0 ;
24582 int res1 = 0 ;
24583 bool val2 ;
24584 int ecode2 = 0 ;
24585 PyObject * obj0 = 0 ;
24586 PyObject * obj1 = 0 ;
24587 char * kwnames[] = {
24588 (char *) "self",(char *) "noDST", NULL
24589 };
24590
24591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToUTC",kwnames,&obj0,&obj1)) SWIG_fail;
24592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24593 if (!SWIG_IsOK(res1)) {
24594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24595 }
24596 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24597 if (obj1) {
24598 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24599 if (!SWIG_IsOK(ecode2)) {
24600 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToUTC" "', expected argument " "2"" of type '" "bool""'");
24601 }
24602 arg2 = static_cast< bool >(val2);
24603 }
24604 {
24605 PyThreadState* __tstate = wxPyBeginAllowThreads();
24606 result = ((wxDateTime const *)arg1)->ToUTC(arg2);
24607 wxPyEndAllowThreads(__tstate);
24608 if (PyErr_Occurred()) SWIG_fail;
24609 }
24610 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24611 return resultobj;
24612 fail:
24613 return NULL;
24614 }
24615
24616
24617 SWIGINTERN PyObject *_wrap_DateTime_MakeUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24618 PyObject *resultobj = 0;
24619 wxDateTime *arg1 = (wxDateTime *) 0 ;
24620 bool arg2 = (bool) false ;
24621 wxDateTime *result = 0 ;
24622 void *argp1 = 0 ;
24623 int res1 = 0 ;
24624 bool val2 ;
24625 int ecode2 = 0 ;
24626 PyObject * obj0 = 0 ;
24627 PyObject * obj1 = 0 ;
24628 char * kwnames[] = {
24629 (char *) "self",(char *) "noDST", NULL
24630 };
24631
24632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeUTC",kwnames,&obj0,&obj1)) SWIG_fail;
24633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24634 if (!SWIG_IsOK(res1)) {
24635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
24636 }
24637 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24638 if (obj1) {
24639 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24640 if (!SWIG_IsOK(ecode2)) {
24641 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeUTC" "', expected argument " "2"" of type '" "bool""'");
24642 }
24643 arg2 = static_cast< bool >(val2);
24644 }
24645 {
24646 PyThreadState* __tstate = wxPyBeginAllowThreads();
24647 {
24648 wxDateTime &_result_ref = (arg1)->MakeUTC(arg2);
24649 result = (wxDateTime *) &_result_ref;
24650 }
24651 wxPyEndAllowThreads(__tstate);
24652 if (PyErr_Occurred()) SWIG_fail;
24653 }
24654 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24655 return resultobj;
24656 fail:
24657 return NULL;
24658 }
24659
24660
24661 SWIGINTERN PyObject *_wrap_DateTime_ToGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24662 PyObject *resultobj = 0;
24663 wxDateTime *arg1 = (wxDateTime *) 0 ;
24664 bool arg2 = (bool) false ;
24665 wxDateTime result;
24666 void *argp1 = 0 ;
24667 int res1 = 0 ;
24668 bool val2 ;
24669 int ecode2 = 0 ;
24670 PyObject * obj0 = 0 ;
24671 PyObject * obj1 = 0 ;
24672 char * kwnames[] = {
24673 (char *) "self",(char *) "noDST", NULL
24674 };
24675
24676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) SWIG_fail;
24677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24678 if (!SWIG_IsOK(res1)) {
24679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToGMT" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24680 }
24681 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24682 if (obj1) {
24683 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24684 if (!SWIG_IsOK(ecode2)) {
24685 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToGMT" "', expected argument " "2"" of type '" "bool""'");
24686 }
24687 arg2 = static_cast< bool >(val2);
24688 }
24689 {
24690 PyThreadState* __tstate = wxPyBeginAllowThreads();
24691 result = ((wxDateTime const *)arg1)->ToGMT(arg2);
24692 wxPyEndAllowThreads(__tstate);
24693 if (PyErr_Occurred()) SWIG_fail;
24694 }
24695 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24696 return resultobj;
24697 fail:
24698 return NULL;
24699 }
24700
24701
24702 SWIGINTERN PyObject *_wrap_DateTime_MakeGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24703 PyObject *resultobj = 0;
24704 wxDateTime *arg1 = (wxDateTime *) 0 ;
24705 bool arg2 = (bool) false ;
24706 wxDateTime *result = 0 ;
24707 void *argp1 = 0 ;
24708 int res1 = 0 ;
24709 bool val2 ;
24710 int ecode2 = 0 ;
24711 PyObject * obj0 = 0 ;
24712 PyObject * obj1 = 0 ;
24713 char * kwnames[] = {
24714 (char *) "self",(char *) "noDST", NULL
24715 };
24716
24717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) SWIG_fail;
24718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24719 if (!SWIG_IsOK(res1)) {
24720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeGMT" "', expected argument " "1"" of type '" "wxDateTime *""'");
24721 }
24722 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24723 if (obj1) {
24724 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24725 if (!SWIG_IsOK(ecode2)) {
24726 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeGMT" "', expected argument " "2"" of type '" "bool""'");
24727 }
24728 arg2 = static_cast< bool >(val2);
24729 }
24730 {
24731 PyThreadState* __tstate = wxPyBeginAllowThreads();
24732 {
24733 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
24734 result = (wxDateTime *) &_result_ref;
24735 }
24736 wxPyEndAllowThreads(__tstate);
24737 if (PyErr_Occurred()) SWIG_fail;
24738 }
24739 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24740 return resultobj;
24741 fail:
24742 return NULL;
24743 }
24744
24745
24746 SWIGINTERN PyObject *_wrap_DateTime_FromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24747 PyObject *resultobj = 0;
24748 wxDateTime *arg1 = (wxDateTime *) 0 ;
24749 bool arg2 = (bool) false ;
24750 wxDateTime result;
24751 void *argp1 = 0 ;
24752 int res1 = 0 ;
24753 bool val2 ;
24754 int ecode2 = 0 ;
24755 PyObject * obj0 = 0 ;
24756 PyObject * obj1 = 0 ;
24757 char * kwnames[] = {
24758 (char *) "self",(char *) "noDST", NULL
24759 };
24760
24761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_FromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
24762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24763 if (!SWIG_IsOK(res1)) {
24764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24765 }
24766 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24767 if (obj1) {
24768 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24769 if (!SWIG_IsOK(ecode2)) {
24770 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_FromUTC" "', expected argument " "2"" of type '" "bool""'");
24771 }
24772 arg2 = static_cast< bool >(val2);
24773 }
24774 {
24775 PyThreadState* __tstate = wxPyBeginAllowThreads();
24776 result = ((wxDateTime const *)arg1)->FromUTC(arg2);
24777 wxPyEndAllowThreads(__tstate);
24778 if (PyErr_Occurred()) SWIG_fail;
24779 }
24780 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24781 return resultobj;
24782 fail:
24783 return NULL;
24784 }
24785
24786
24787 SWIGINTERN PyObject *_wrap_DateTime_MakeFromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24788 PyObject *resultobj = 0;
24789 wxDateTime *arg1 = (wxDateTime *) 0 ;
24790 bool arg2 = (bool) false ;
24791 wxDateTime *result = 0 ;
24792 void *argp1 = 0 ;
24793 int res1 = 0 ;
24794 bool val2 ;
24795 int ecode2 = 0 ;
24796 PyObject * obj0 = 0 ;
24797 PyObject * obj1 = 0 ;
24798 char * kwnames[] = {
24799 (char *) "self",(char *) "noDST", NULL
24800 };
24801
24802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeFromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
24803 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24804 if (!SWIG_IsOK(res1)) {
24805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
24806 }
24807 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24808 if (obj1) {
24809 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24810 if (!SWIG_IsOK(ecode2)) {
24811 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeFromUTC" "', expected argument " "2"" of type '" "bool""'");
24812 }
24813 arg2 = static_cast< bool >(val2);
24814 }
24815 {
24816 PyThreadState* __tstate = wxPyBeginAllowThreads();
24817 {
24818 wxDateTime &_result_ref = (arg1)->MakeFromUTC(arg2);
24819 result = (wxDateTime *) &_result_ref;
24820 }
24821 wxPyEndAllowThreads(__tstate);
24822 if (PyErr_Occurred()) SWIG_fail;
24823 }
24824 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24825 return resultobj;
24826 fail:
24827 return NULL;
24828 }
24829
24830
24831 SWIGINTERN PyObject *_wrap_DateTime_IsDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24832 PyObject *resultobj = 0;
24833 wxDateTime *arg1 = (wxDateTime *) 0 ;
24834 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
24835 int result;
24836 void *argp1 = 0 ;
24837 int res1 = 0 ;
24838 int val2 ;
24839 int ecode2 = 0 ;
24840 PyObject * obj0 = 0 ;
24841 PyObject * obj1 = 0 ;
24842 char * kwnames[] = {
24843 (char *) "self",(char *) "country", NULL
24844 };
24845
24846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) SWIG_fail;
24847 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24848 if (!SWIG_IsOK(res1)) {
24849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsDST" "', expected argument " "1"" of type '" "wxDateTime *""'");
24850 }
24851 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24852 if (obj1) {
24853 ecode2 = SWIG_AsVal_int(obj1, &val2);
24854 if (!SWIG_IsOK(ecode2)) {
24855 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
24856 }
24857 arg2 = static_cast< wxDateTime::Country >(val2);
24858 }
24859 {
24860 PyThreadState* __tstate = wxPyBeginAllowThreads();
24861 result = (int)(arg1)->IsDST(arg2);
24862 wxPyEndAllowThreads(__tstate);
24863 if (PyErr_Occurred()) SWIG_fail;
24864 }
24865 resultobj = SWIG_From_int(static_cast< int >(result));
24866 return resultobj;
24867 fail:
24868 return NULL;
24869 }
24870
24871
24872 SWIGINTERN PyObject *_wrap_DateTime_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24873 PyObject *resultobj = 0;
24874 wxDateTime *arg1 = (wxDateTime *) 0 ;
24875 bool result;
24876 void *argp1 = 0 ;
24877 int res1 = 0 ;
24878 PyObject *swig_obj[1] ;
24879
24880 if (!args) SWIG_fail;
24881 swig_obj[0] = args;
24882 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24883 if (!SWIG_IsOK(res1)) {
24884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsValid" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24885 }
24886 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24887 {
24888 PyThreadState* __tstate = wxPyBeginAllowThreads();
24889 result = (bool)((wxDateTime const *)arg1)->IsValid();
24890 wxPyEndAllowThreads(__tstate);
24891 if (PyErr_Occurred()) SWIG_fail;
24892 }
24893 {
24894 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24895 }
24896 return resultobj;
24897 fail:
24898 return NULL;
24899 }
24900
24901
24902 SWIGINTERN PyObject *_wrap_DateTime_GetTicks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24903 PyObject *resultobj = 0;
24904 wxDateTime *arg1 = (wxDateTime *) 0 ;
24905 time_t result;
24906 void *argp1 = 0 ;
24907 int res1 = 0 ;
24908 PyObject *swig_obj[1] ;
24909
24910 if (!args) SWIG_fail;
24911 swig_obj[0] = args;
24912 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24913 if (!SWIG_IsOK(res1)) {
24914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetTicks" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24915 }
24916 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24917 {
24918 PyThreadState* __tstate = wxPyBeginAllowThreads();
24919 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
24920 wxPyEndAllowThreads(__tstate);
24921 if (PyErr_Occurred()) SWIG_fail;
24922 }
24923 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
24924 return resultobj;
24925 fail:
24926 return NULL;
24927 }
24928
24929
24930 SWIGINTERN PyObject *_wrap_DateTime_GetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24931 PyObject *resultobj = 0;
24932 wxDateTime *arg1 = (wxDateTime *) 0 ;
24933 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
24934 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
24935 int result;
24936 void *argp1 = 0 ;
24937 int res1 = 0 ;
24938 bool temp2 = false ;
24939 PyObject * obj0 = 0 ;
24940 PyObject * obj1 = 0 ;
24941 char * kwnames[] = {
24942 (char *) "self",(char *) "tz", NULL
24943 };
24944
24945 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) SWIG_fail;
24946 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24947 if (!SWIG_IsOK(res1)) {
24948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24949 }
24950 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24951 if (obj1) {
24952 {
24953 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24954 temp2 = true;
24955 }
24956 }
24957 {
24958 PyThreadState* __tstate = wxPyBeginAllowThreads();
24959 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
24960 wxPyEndAllowThreads(__tstate);
24961 if (PyErr_Occurred()) SWIG_fail;
24962 }
24963 resultobj = SWIG_From_int(static_cast< int >(result));
24964 {
24965 if (temp2) delete arg2;
24966 }
24967 return resultobj;
24968 fail:
24969 {
24970 if (temp2) delete arg2;
24971 }
24972 return NULL;
24973 }
24974
24975
24976 SWIGINTERN PyObject *_wrap_DateTime_GetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24977 PyObject *resultobj = 0;
24978 wxDateTime *arg1 = (wxDateTime *) 0 ;
24979 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
24980 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
24981 wxDateTime::Month result;
24982 void *argp1 = 0 ;
24983 int res1 = 0 ;
24984 bool temp2 = false ;
24985 PyObject * obj0 = 0 ;
24986 PyObject * obj1 = 0 ;
24987 char * kwnames[] = {
24988 (char *) "self",(char *) "tz", NULL
24989 };
24990
24991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
24992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24993 if (!SWIG_IsOK(res1)) {
24994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24995 }
24996 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24997 if (obj1) {
24998 {
24999 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25000 temp2 = true;
25001 }
25002 }
25003 {
25004 PyThreadState* __tstate = wxPyBeginAllowThreads();
25005 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
25006 wxPyEndAllowThreads(__tstate);
25007 if (PyErr_Occurred()) SWIG_fail;
25008 }
25009 resultobj = SWIG_From_int(static_cast< int >(result));
25010 {
25011 if (temp2) delete arg2;
25012 }
25013 return resultobj;
25014 fail:
25015 {
25016 if (temp2) delete arg2;
25017 }
25018 return NULL;
25019 }
25020
25021
25022 SWIGINTERN PyObject *_wrap_DateTime_GetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25023 PyObject *resultobj = 0;
25024 wxDateTime *arg1 = (wxDateTime *) 0 ;
25025 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25026 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25027 int result;
25028 void *argp1 = 0 ;
25029 int res1 = 0 ;
25030 bool temp2 = false ;
25031 PyObject * obj0 = 0 ;
25032 PyObject * obj1 = 0 ;
25033 char * kwnames[] = {
25034 (char *) "self",(char *) "tz", NULL
25035 };
25036
25037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) SWIG_fail;
25038 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25039 if (!SWIG_IsOK(res1)) {
25040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25041 }
25042 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25043 if (obj1) {
25044 {
25045 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25046 temp2 = true;
25047 }
25048 }
25049 {
25050 PyThreadState* __tstate = wxPyBeginAllowThreads();
25051 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
25052 wxPyEndAllowThreads(__tstate);
25053 if (PyErr_Occurred()) SWIG_fail;
25054 }
25055 resultobj = SWIG_From_int(static_cast< int >(result));
25056 {
25057 if (temp2) delete arg2;
25058 }
25059 return resultobj;
25060 fail:
25061 {
25062 if (temp2) delete arg2;
25063 }
25064 return NULL;
25065 }
25066
25067
25068 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25069 PyObject *resultobj = 0;
25070 wxDateTime *arg1 = (wxDateTime *) 0 ;
25071 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25072 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25073 wxDateTime::WeekDay result;
25074 void *argp1 = 0 ;
25075 int res1 = 0 ;
25076 bool temp2 = false ;
25077 PyObject * obj0 = 0 ;
25078 PyObject * obj1 = 0 ;
25079 char * kwnames[] = {
25080 (char *) "self",(char *) "tz", NULL
25081 };
25082
25083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
25084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25085 if (!SWIG_IsOK(res1)) {
25086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25087 }
25088 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25089 if (obj1) {
25090 {
25091 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25092 temp2 = true;
25093 }
25094 }
25095 {
25096 PyThreadState* __tstate = wxPyBeginAllowThreads();
25097 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
25098 wxPyEndAllowThreads(__tstate);
25099 if (PyErr_Occurred()) SWIG_fail;
25100 }
25101 resultobj = SWIG_From_int(static_cast< int >(result));
25102 {
25103 if (temp2) delete arg2;
25104 }
25105 return resultobj;
25106 fail:
25107 {
25108 if (temp2) delete arg2;
25109 }
25110 return NULL;
25111 }
25112
25113
25114 SWIGINTERN PyObject *_wrap_DateTime_GetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25115 PyObject *resultobj = 0;
25116 wxDateTime *arg1 = (wxDateTime *) 0 ;
25117 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25118 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25119 int result;
25120 void *argp1 = 0 ;
25121 int res1 = 0 ;
25122 bool temp2 = false ;
25123 PyObject * obj0 = 0 ;
25124 PyObject * obj1 = 0 ;
25125 char * kwnames[] = {
25126 (char *) "self",(char *) "tz", NULL
25127 };
25128
25129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) SWIG_fail;
25130 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25131 if (!SWIG_IsOK(res1)) {
25132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetHour" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25133 }
25134 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25135 if (obj1) {
25136 {
25137 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25138 temp2 = true;
25139 }
25140 }
25141 {
25142 PyThreadState* __tstate = wxPyBeginAllowThreads();
25143 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
25144 wxPyEndAllowThreads(__tstate);
25145 if (PyErr_Occurred()) SWIG_fail;
25146 }
25147 resultobj = SWIG_From_int(static_cast< int >(result));
25148 {
25149 if (temp2) delete arg2;
25150 }
25151 return resultobj;
25152 fail:
25153 {
25154 if (temp2) delete arg2;
25155 }
25156 return NULL;
25157 }
25158
25159
25160 SWIGINTERN PyObject *_wrap_DateTime_GetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25161 PyObject *resultobj = 0;
25162 wxDateTime *arg1 = (wxDateTime *) 0 ;
25163 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25164 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25165 int result;
25166 void *argp1 = 0 ;
25167 int res1 = 0 ;
25168 bool temp2 = false ;
25169 PyObject * obj0 = 0 ;
25170 PyObject * obj1 = 0 ;
25171 char * kwnames[] = {
25172 (char *) "self",(char *) "tz", NULL
25173 };
25174
25175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
25176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25177 if (!SWIG_IsOK(res1)) {
25178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMinute" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25179 }
25180 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25181 if (obj1) {
25182 {
25183 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25184 temp2 = true;
25185 }
25186 }
25187 {
25188 PyThreadState* __tstate = wxPyBeginAllowThreads();
25189 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
25190 wxPyEndAllowThreads(__tstate);
25191 if (PyErr_Occurred()) SWIG_fail;
25192 }
25193 resultobj = SWIG_From_int(static_cast< int >(result));
25194 {
25195 if (temp2) delete arg2;
25196 }
25197 return resultobj;
25198 fail:
25199 {
25200 if (temp2) delete arg2;
25201 }
25202 return NULL;
25203 }
25204
25205
25206 SWIGINTERN PyObject *_wrap_DateTime_GetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25207 PyObject *resultobj = 0;
25208 wxDateTime *arg1 = (wxDateTime *) 0 ;
25209 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25210 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25211 int result;
25212 void *argp1 = 0 ;
25213 int res1 = 0 ;
25214 bool temp2 = false ;
25215 PyObject * obj0 = 0 ;
25216 PyObject * obj1 = 0 ;
25217 char * kwnames[] = {
25218 (char *) "self",(char *) "tz", NULL
25219 };
25220
25221 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
25222 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25223 if (!SWIG_IsOK(res1)) {
25224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetSecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25225 }
25226 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25227 if (obj1) {
25228 {
25229 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25230 temp2 = true;
25231 }
25232 }
25233 {
25234 PyThreadState* __tstate = wxPyBeginAllowThreads();
25235 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
25236 wxPyEndAllowThreads(__tstate);
25237 if (PyErr_Occurred()) SWIG_fail;
25238 }
25239 resultobj = SWIG_From_int(static_cast< int >(result));
25240 {
25241 if (temp2) delete arg2;
25242 }
25243 return resultobj;
25244 fail:
25245 {
25246 if (temp2) delete arg2;
25247 }
25248 return NULL;
25249 }
25250
25251
25252 SWIGINTERN PyObject *_wrap_DateTime_GetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25253 PyObject *resultobj = 0;
25254 wxDateTime *arg1 = (wxDateTime *) 0 ;
25255 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25256 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25257 int result;
25258 void *argp1 = 0 ;
25259 int res1 = 0 ;
25260 bool temp2 = false ;
25261 PyObject * obj0 = 0 ;
25262 PyObject * obj1 = 0 ;
25263 char * kwnames[] = {
25264 (char *) "self",(char *) "tz", NULL
25265 };
25266
25267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
25268 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25269 if (!SWIG_IsOK(res1)) {
25270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMillisecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25271 }
25272 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25273 if (obj1) {
25274 {
25275 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25276 temp2 = true;
25277 }
25278 }
25279 {
25280 PyThreadState* __tstate = wxPyBeginAllowThreads();
25281 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
25282 wxPyEndAllowThreads(__tstate);
25283 if (PyErr_Occurred()) SWIG_fail;
25284 }
25285 resultobj = SWIG_From_int(static_cast< int >(result));
25286 {
25287 if (temp2) delete arg2;
25288 }
25289 return resultobj;
25290 fail:
25291 {
25292 if (temp2) delete arg2;
25293 }
25294 return NULL;
25295 }
25296
25297
25298 SWIGINTERN PyObject *_wrap_DateTime_GetDayOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25299 PyObject *resultobj = 0;
25300 wxDateTime *arg1 = (wxDateTime *) 0 ;
25301 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25302 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25303 int result;
25304 void *argp1 = 0 ;
25305 int res1 = 0 ;
25306 bool temp2 = false ;
25307 PyObject * obj0 = 0 ;
25308 PyObject * obj1 = 0 ;
25309 char * kwnames[] = {
25310 (char *) "self",(char *) "tz", NULL
25311 };
25312
25313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) SWIG_fail;
25314 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25315 if (!SWIG_IsOK(res1)) {
25316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDayOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25317 }
25318 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25319 if (obj1) {
25320 {
25321 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25322 temp2 = true;
25323 }
25324 }
25325 {
25326 PyThreadState* __tstate = wxPyBeginAllowThreads();
25327 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
25328 wxPyEndAllowThreads(__tstate);
25329 if (PyErr_Occurred()) SWIG_fail;
25330 }
25331 resultobj = SWIG_From_int(static_cast< int >(result));
25332 {
25333 if (temp2) delete arg2;
25334 }
25335 return resultobj;
25336 fail:
25337 {
25338 if (temp2) delete arg2;
25339 }
25340 return NULL;
25341 }
25342
25343
25344 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25345 PyObject *resultobj = 0;
25346 wxDateTime *arg1 = (wxDateTime *) 0 ;
25347 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25348 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
25349 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
25350 int result;
25351 void *argp1 = 0 ;
25352 int res1 = 0 ;
25353 int val2 ;
25354 int ecode2 = 0 ;
25355 bool temp3 = false ;
25356 PyObject * obj0 = 0 ;
25357 PyObject * obj1 = 0 ;
25358 PyObject * obj2 = 0 ;
25359 char * kwnames[] = {
25360 (char *) "self",(char *) "flags",(char *) "tz", NULL
25361 };
25362
25363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25364 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25365 if (!SWIG_IsOK(res1)) {
25366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25367 }
25368 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25369 if (obj1) {
25370 ecode2 = SWIG_AsVal_int(obj1, &val2);
25371 if (!SWIG_IsOK(ecode2)) {
25372 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
25373 }
25374 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
25375 }
25376 if (obj2) {
25377 {
25378 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
25379 temp3 = true;
25380 }
25381 }
25382 {
25383 PyThreadState* __tstate = wxPyBeginAllowThreads();
25384 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear(arg2,(wxDateTime::TimeZone const &)*arg3);
25385 wxPyEndAllowThreads(__tstate);
25386 if (PyErr_Occurred()) SWIG_fail;
25387 }
25388 resultobj = SWIG_From_int(static_cast< int >(result));
25389 {
25390 if (temp3) delete arg3;
25391 }
25392 return resultobj;
25393 fail:
25394 {
25395 if (temp3) delete arg3;
25396 }
25397 return NULL;
25398 }
25399
25400
25401 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25402 PyObject *resultobj = 0;
25403 wxDateTime *arg1 = (wxDateTime *) 0 ;
25404 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25405 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
25406 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
25407 int result;
25408 void *argp1 = 0 ;
25409 int res1 = 0 ;
25410 int val2 ;
25411 int ecode2 = 0 ;
25412 bool temp3 = false ;
25413 PyObject * obj0 = 0 ;
25414 PyObject * obj1 = 0 ;
25415 PyObject * obj2 = 0 ;
25416 char * kwnames[] = {
25417 (char *) "self",(char *) "flags",(char *) "tz", NULL
25418 };
25419
25420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25421 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25422 if (!SWIG_IsOK(res1)) {
25423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25424 }
25425 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25426 if (obj1) {
25427 ecode2 = SWIG_AsVal_int(obj1, &val2);
25428 if (!SWIG_IsOK(ecode2)) {
25429 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
25430 }
25431 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
25432 }
25433 if (obj2) {
25434 {
25435 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
25436 temp3 = true;
25437 }
25438 }
25439 {
25440 PyThreadState* __tstate = wxPyBeginAllowThreads();
25441 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth(arg2,(wxDateTime::TimeZone const &)*arg3);
25442 wxPyEndAllowThreads(__tstate);
25443 if (PyErr_Occurred()) SWIG_fail;
25444 }
25445 resultobj = SWIG_From_int(static_cast< int >(result));
25446 {
25447 if (temp3) delete arg3;
25448 }
25449 return resultobj;
25450 fail:
25451 {
25452 if (temp3) delete arg3;
25453 }
25454 return NULL;
25455 }
25456
25457
25458 SWIGINTERN PyObject *_wrap_DateTime_IsWorkDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25459 PyObject *resultobj = 0;
25460 wxDateTime *arg1 = (wxDateTime *) 0 ;
25461 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
25462 bool result;
25463 void *argp1 = 0 ;
25464 int res1 = 0 ;
25465 int val2 ;
25466 int ecode2 = 0 ;
25467 PyObject * obj0 = 0 ;
25468 PyObject * obj1 = 0 ;
25469 char * kwnames[] = {
25470 (char *) "self",(char *) "country", NULL
25471 };
25472
25473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) SWIG_fail;
25474 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25475 if (!SWIG_IsOK(res1)) {
25476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsWorkDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25477 }
25478 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25479 if (obj1) {
25480 ecode2 = SWIG_AsVal_int(obj1, &val2);
25481 if (!SWIG_IsOK(ecode2)) {
25482 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsWorkDay" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
25483 }
25484 arg2 = static_cast< wxDateTime::Country >(val2);
25485 }
25486 {
25487 PyThreadState* __tstate = wxPyBeginAllowThreads();
25488 result = (bool)((wxDateTime const *)arg1)->IsWorkDay(arg2);
25489 wxPyEndAllowThreads(__tstate);
25490 if (PyErr_Occurred()) SWIG_fail;
25491 }
25492 {
25493 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25494 }
25495 return resultobj;
25496 fail:
25497 return NULL;
25498 }
25499
25500
25501 SWIGINTERN PyObject *_wrap_DateTime_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25502 PyObject *resultobj = 0;
25503 wxDateTime *arg1 = (wxDateTime *) 0 ;
25504 wxDateTime *arg2 = 0 ;
25505 bool result;
25506 void *argp1 = 0 ;
25507 int res1 = 0 ;
25508 void *argp2 = 0 ;
25509 int res2 = 0 ;
25510 PyObject * obj0 = 0 ;
25511 PyObject * obj1 = 0 ;
25512 char * kwnames[] = {
25513 (char *) "self",(char *) "datetime", NULL
25514 };
25515
25516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
25517 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25518 if (!SWIG_IsOK(res1)) {
25519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25520 }
25521 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25522 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25523 if (!SWIG_IsOK(res2)) {
25524 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25525 }
25526 if (!argp2) {
25527 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25528 }
25529 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25530 {
25531 PyThreadState* __tstate = wxPyBeginAllowThreads();
25532 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
25533 wxPyEndAllowThreads(__tstate);
25534 if (PyErr_Occurred()) SWIG_fail;
25535 }
25536 {
25537 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25538 }
25539 return resultobj;
25540 fail:
25541 return NULL;
25542 }
25543
25544
25545 SWIGINTERN PyObject *_wrap_DateTime_IsEarlierThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25546 PyObject *resultobj = 0;
25547 wxDateTime *arg1 = (wxDateTime *) 0 ;
25548 wxDateTime *arg2 = 0 ;
25549 bool result;
25550 void *argp1 = 0 ;
25551 int res1 = 0 ;
25552 void *argp2 = 0 ;
25553 int res2 = 0 ;
25554 PyObject * obj0 = 0 ;
25555 PyObject * obj1 = 0 ;
25556 char * kwnames[] = {
25557 (char *) "self",(char *) "datetime", NULL
25558 };
25559
25560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) SWIG_fail;
25561 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25562 if (!SWIG_IsOK(res1)) {
25563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEarlierThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25564 }
25565 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25566 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25567 if (!SWIG_IsOK(res2)) {
25568 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25569 }
25570 if (!argp2) {
25571 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25572 }
25573 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25574 {
25575 PyThreadState* __tstate = wxPyBeginAllowThreads();
25576 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
25577 wxPyEndAllowThreads(__tstate);
25578 if (PyErr_Occurred()) SWIG_fail;
25579 }
25580 {
25581 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25582 }
25583 return resultobj;
25584 fail:
25585 return NULL;
25586 }
25587
25588
25589 SWIGINTERN PyObject *_wrap_DateTime_IsLaterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25590 PyObject *resultobj = 0;
25591 wxDateTime *arg1 = (wxDateTime *) 0 ;
25592 wxDateTime *arg2 = 0 ;
25593 bool result;
25594 void *argp1 = 0 ;
25595 int res1 = 0 ;
25596 void *argp2 = 0 ;
25597 int res2 = 0 ;
25598 PyObject * obj0 = 0 ;
25599 PyObject * obj1 = 0 ;
25600 char * kwnames[] = {
25601 (char *) "self",(char *) "datetime", NULL
25602 };
25603
25604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) SWIG_fail;
25605 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25606 if (!SWIG_IsOK(res1)) {
25607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsLaterThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25608 }
25609 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25610 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25611 if (!SWIG_IsOK(res2)) {
25612 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25613 }
25614 if (!argp2) {
25615 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25616 }
25617 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25618 {
25619 PyThreadState* __tstate = wxPyBeginAllowThreads();
25620 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
25621 wxPyEndAllowThreads(__tstate);
25622 if (PyErr_Occurred()) SWIG_fail;
25623 }
25624 {
25625 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25626 }
25627 return resultobj;
25628 fail:
25629 return NULL;
25630 }
25631
25632
25633 SWIGINTERN PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25634 PyObject *resultobj = 0;
25635 wxDateTime *arg1 = (wxDateTime *) 0 ;
25636 wxDateTime *arg2 = 0 ;
25637 wxDateTime *arg3 = 0 ;
25638 bool result;
25639 void *argp1 = 0 ;
25640 int res1 = 0 ;
25641 void *argp2 = 0 ;
25642 int res2 = 0 ;
25643 void *argp3 = 0 ;
25644 int res3 = 0 ;
25645 PyObject * obj0 = 0 ;
25646 PyObject * obj1 = 0 ;
25647 PyObject * obj2 = 0 ;
25648 char * kwnames[] = {
25649 (char *) "self",(char *) "t1",(char *) "t2", NULL
25650 };
25651
25652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25654 if (!SWIG_IsOK(res1)) {
25655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25656 }
25657 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25658 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25659 if (!SWIG_IsOK(res2)) {
25660 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25661 }
25662 if (!argp2) {
25663 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25664 }
25665 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25666 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
25667 if (!SWIG_IsOK(res3)) {
25668 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
25669 }
25670 if (!argp3) {
25671 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
25672 }
25673 arg3 = reinterpret_cast< wxDateTime * >(argp3);
25674 {
25675 PyThreadState* __tstate = wxPyBeginAllowThreads();
25676 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
25677 wxPyEndAllowThreads(__tstate);
25678 if (PyErr_Occurred()) SWIG_fail;
25679 }
25680 {
25681 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25682 }
25683 return resultobj;
25684 fail:
25685 return NULL;
25686 }
25687
25688
25689 SWIGINTERN PyObject *_wrap_DateTime_IsBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25690 PyObject *resultobj = 0;
25691 wxDateTime *arg1 = (wxDateTime *) 0 ;
25692 wxDateTime *arg2 = 0 ;
25693 wxDateTime *arg3 = 0 ;
25694 bool result;
25695 void *argp1 = 0 ;
25696 int res1 = 0 ;
25697 void *argp2 = 0 ;
25698 int res2 = 0 ;
25699 void *argp3 = 0 ;
25700 int res3 = 0 ;
25701 PyObject * obj0 = 0 ;
25702 PyObject * obj1 = 0 ;
25703 PyObject * obj2 = 0 ;
25704 char * kwnames[] = {
25705 (char *) "self",(char *) "t1",(char *) "t2", NULL
25706 };
25707
25708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25709 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25710 if (!SWIG_IsOK(res1)) {
25711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25712 }
25713 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25714 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25715 if (!SWIG_IsOK(res2)) {
25716 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25717 }
25718 if (!argp2) {
25719 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25720 }
25721 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25722 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
25723 if (!SWIG_IsOK(res3)) {
25724 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
25725 }
25726 if (!argp3) {
25727 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
25728 }
25729 arg3 = reinterpret_cast< wxDateTime * >(argp3);
25730 {
25731 PyThreadState* __tstate = wxPyBeginAllowThreads();
25732 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
25733 wxPyEndAllowThreads(__tstate);
25734 if (PyErr_Occurred()) SWIG_fail;
25735 }
25736 {
25737 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25738 }
25739 return resultobj;
25740 fail:
25741 return NULL;
25742 }
25743
25744
25745 SWIGINTERN PyObject *_wrap_DateTime_IsSameDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25746 PyObject *resultobj = 0;
25747 wxDateTime *arg1 = (wxDateTime *) 0 ;
25748 wxDateTime *arg2 = 0 ;
25749 bool result;
25750 void *argp1 = 0 ;
25751 int res1 = 0 ;
25752 void *argp2 = 0 ;
25753 int res2 = 0 ;
25754 PyObject * obj0 = 0 ;
25755 PyObject * obj1 = 0 ;
25756 char * kwnames[] = {
25757 (char *) "self",(char *) "dt", NULL
25758 };
25759
25760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) SWIG_fail;
25761 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25762 if (!SWIG_IsOK(res1)) {
25763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25764 }
25765 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25766 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25767 if (!SWIG_IsOK(res2)) {
25768 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25769 }
25770 if (!argp2) {
25771 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25772 }
25773 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25774 {
25775 PyThreadState* __tstate = wxPyBeginAllowThreads();
25776 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
25777 wxPyEndAllowThreads(__tstate);
25778 if (PyErr_Occurred()) SWIG_fail;
25779 }
25780 {
25781 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25782 }
25783 return resultobj;
25784 fail:
25785 return NULL;
25786 }
25787
25788
25789 SWIGINTERN PyObject *_wrap_DateTime_IsSameTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25790 PyObject *resultobj = 0;
25791 wxDateTime *arg1 = (wxDateTime *) 0 ;
25792 wxDateTime *arg2 = 0 ;
25793 bool result;
25794 void *argp1 = 0 ;
25795 int res1 = 0 ;
25796 void *argp2 = 0 ;
25797 int res2 = 0 ;
25798 PyObject * obj0 = 0 ;
25799 PyObject * obj1 = 0 ;
25800 char * kwnames[] = {
25801 (char *) "self",(char *) "dt", NULL
25802 };
25803
25804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) SWIG_fail;
25805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25806 if (!SWIG_IsOK(res1)) {
25807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25808 }
25809 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25810 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25811 if (!SWIG_IsOK(res2)) {
25812 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25813 }
25814 if (!argp2) {
25815 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25816 }
25817 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25818 {
25819 PyThreadState* __tstate = wxPyBeginAllowThreads();
25820 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
25821 wxPyEndAllowThreads(__tstate);
25822 if (PyErr_Occurred()) SWIG_fail;
25823 }
25824 {
25825 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25826 }
25827 return resultobj;
25828 fail:
25829 return NULL;
25830 }
25831
25832
25833 SWIGINTERN PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25834 PyObject *resultobj = 0;
25835 wxDateTime *arg1 = (wxDateTime *) 0 ;
25836 wxDateTime *arg2 = 0 ;
25837 wxTimeSpan *arg3 = 0 ;
25838 bool result;
25839 void *argp1 = 0 ;
25840 int res1 = 0 ;
25841 void *argp2 = 0 ;
25842 int res2 = 0 ;
25843 void *argp3 = 0 ;
25844 int res3 = 0 ;
25845 PyObject * obj0 = 0 ;
25846 PyObject * obj1 = 0 ;
25847 PyObject * obj2 = 0 ;
25848 char * kwnames[] = {
25849 (char *) "self",(char *) "dt",(char *) "ts", NULL
25850 };
25851
25852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25853 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25854 if (!SWIG_IsOK(res1)) {
25855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25856 }
25857 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25858 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25859 if (!SWIG_IsOK(res2)) {
25860 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25861 }
25862 if (!argp2) {
25863 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25864 }
25865 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25866 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxTimeSpan, 0 | 0);
25867 if (!SWIG_IsOK(res3)) {
25868 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
25869 }
25870 if (!argp3) {
25871 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
25872 }
25873 arg3 = reinterpret_cast< wxTimeSpan * >(argp3);
25874 {
25875 PyThreadState* __tstate = wxPyBeginAllowThreads();
25876 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
25877 wxPyEndAllowThreads(__tstate);
25878 if (PyErr_Occurred()) SWIG_fail;
25879 }
25880 {
25881 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25882 }
25883 return resultobj;
25884 fail:
25885 return NULL;
25886 }
25887
25888
25889 SWIGINTERN PyObject *_wrap_DateTime_AddTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25890 PyObject *resultobj = 0;
25891 wxDateTime *arg1 = (wxDateTime *) 0 ;
25892 wxTimeSpan *arg2 = 0 ;
25893 wxDateTime *result = 0 ;
25894 void *argp1 = 0 ;
25895 int res1 = 0 ;
25896 void *argp2 = 0 ;
25897 int res2 = 0 ;
25898 PyObject * obj0 = 0 ;
25899 PyObject * obj1 = 0 ;
25900 char * kwnames[] = {
25901 (char *) "self",(char *) "diff", NULL
25902 };
25903
25904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) SWIG_fail;
25905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25906 if (!SWIG_IsOK(res1)) {
25907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
25908 }
25909 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25910 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
25911 if (!SWIG_IsOK(res2)) {
25912 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
25913 }
25914 if (!argp2) {
25915 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
25916 }
25917 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
25918 {
25919 PyThreadState* __tstate = wxPyBeginAllowThreads();
25920 {
25921 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
25922 result = (wxDateTime *) &_result_ref;
25923 }
25924 wxPyEndAllowThreads(__tstate);
25925 if (PyErr_Occurred()) SWIG_fail;
25926 }
25927 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25928 return resultobj;
25929 fail:
25930 return NULL;
25931 }
25932
25933
25934 SWIGINTERN PyObject *_wrap_DateTime_AddDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25935 PyObject *resultobj = 0;
25936 wxDateTime *arg1 = (wxDateTime *) 0 ;
25937 wxDateSpan *arg2 = 0 ;
25938 wxDateTime *result = 0 ;
25939 void *argp1 = 0 ;
25940 int res1 = 0 ;
25941 void *argp2 = 0 ;
25942 int res2 = 0 ;
25943 PyObject * obj0 = 0 ;
25944 PyObject * obj1 = 0 ;
25945 char * kwnames[] = {
25946 (char *) "self",(char *) "diff", NULL
25947 };
25948
25949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) SWIG_fail;
25950 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25951 if (!SWIG_IsOK(res1)) {
25952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
25953 }
25954 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25955 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
25956 if (!SWIG_IsOK(res2)) {
25957 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
25958 }
25959 if (!argp2) {
25960 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
25961 }
25962 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
25963 {
25964 PyThreadState* __tstate = wxPyBeginAllowThreads();
25965 {
25966 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
25967 result = (wxDateTime *) &_result_ref;
25968 }
25969 wxPyEndAllowThreads(__tstate);
25970 if (PyErr_Occurred()) SWIG_fail;
25971 }
25972 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25973 return resultobj;
25974 fail:
25975 return NULL;
25976 }
25977
25978
25979 SWIGINTERN PyObject *_wrap_DateTime_SubtractTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25980 PyObject *resultobj = 0;
25981 wxDateTime *arg1 = (wxDateTime *) 0 ;
25982 wxTimeSpan *arg2 = 0 ;
25983 wxDateTime *result = 0 ;
25984 void *argp1 = 0 ;
25985 int res1 = 0 ;
25986 void *argp2 = 0 ;
25987 int res2 = 0 ;
25988 PyObject * obj0 = 0 ;
25989 PyObject * obj1 = 0 ;
25990 char * kwnames[] = {
25991 (char *) "self",(char *) "diff", NULL
25992 };
25993
25994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) SWIG_fail;
25995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25996 if (!SWIG_IsOK(res1)) {
25997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
25998 }
25999 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26000 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26001 if (!SWIG_IsOK(res2)) {
26002 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26003 }
26004 if (!argp2) {
26005 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26006 }
26007 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26008 {
26009 PyThreadState* __tstate = wxPyBeginAllowThreads();
26010 {
26011 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
26012 result = (wxDateTime *) &_result_ref;
26013 }
26014 wxPyEndAllowThreads(__tstate);
26015 if (PyErr_Occurred()) SWIG_fail;
26016 }
26017 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26018 return resultobj;
26019 fail:
26020 return NULL;
26021 }
26022
26023
26024 SWIGINTERN PyObject *_wrap_DateTime_SubtractDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26025 PyObject *resultobj = 0;
26026 wxDateTime *arg1 = (wxDateTime *) 0 ;
26027 wxDateSpan *arg2 = 0 ;
26028 wxDateTime *result = 0 ;
26029 void *argp1 = 0 ;
26030 int res1 = 0 ;
26031 void *argp2 = 0 ;
26032 int res2 = 0 ;
26033 PyObject * obj0 = 0 ;
26034 PyObject * obj1 = 0 ;
26035 char * kwnames[] = {
26036 (char *) "self",(char *) "diff", NULL
26037 };
26038
26039 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) SWIG_fail;
26040 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26041 if (!SWIG_IsOK(res1)) {
26042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
26043 }
26044 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26045 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26046 if (!SWIG_IsOK(res2)) {
26047 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26048 }
26049 if (!argp2) {
26050 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26051 }
26052 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26053 {
26054 PyThreadState* __tstate = wxPyBeginAllowThreads();
26055 {
26056 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
26057 result = (wxDateTime *) &_result_ref;
26058 }
26059 wxPyEndAllowThreads(__tstate);
26060 if (PyErr_Occurred()) SWIG_fail;
26061 }
26062 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26063 return resultobj;
26064 fail:
26065 return NULL;
26066 }
26067
26068
26069 SWIGINTERN PyObject *_wrap_DateTime_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26070 PyObject *resultobj = 0;
26071 wxDateTime *arg1 = (wxDateTime *) 0 ;
26072 wxDateTime *arg2 = 0 ;
26073 wxTimeSpan result;
26074 void *argp1 = 0 ;
26075 int res1 = 0 ;
26076 void *argp2 = 0 ;
26077 int res2 = 0 ;
26078 PyObject * obj0 = 0 ;
26079 PyObject * obj1 = 0 ;
26080 char * kwnames[] = {
26081 (char *) "self",(char *) "dt", NULL
26082 };
26083
26084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
26085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26086 if (!SWIG_IsOK(res1)) {
26087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Subtract" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26088 }
26089 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26090 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26091 if (!SWIG_IsOK(res2)) {
26092 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26093 }
26094 if (!argp2) {
26095 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26096 }
26097 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26098 {
26099 PyThreadState* __tstate = wxPyBeginAllowThreads();
26100 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
26101 wxPyEndAllowThreads(__tstate);
26102 if (PyErr_Occurred()) SWIG_fail;
26103 }
26104 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
26105 return resultobj;
26106 fail:
26107 return NULL;
26108 }
26109
26110
26111 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26112 PyObject *resultobj = 0;
26113 wxDateTime *arg1 = (wxDateTime *) 0 ;
26114 wxTimeSpan *arg2 = 0 ;
26115 wxDateTime *result = 0 ;
26116 void *argp1 = 0 ;
26117 int res1 = 0 ;
26118 void *argp2 = 0 ;
26119 int res2 = 0 ;
26120
26121 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26122 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
26123 if (!SWIG_IsOK(res1)) {
26124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26125 }
26126 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26127 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26128 if (!SWIG_IsOK(res2)) {
26129 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26130 }
26131 if (!argp2) {
26132 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26133 }
26134 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26135 {
26136 PyThreadState* __tstate = wxPyBeginAllowThreads();
26137 {
26138 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
26139 result = (wxDateTime *) &_result_ref;
26140 }
26141 wxPyEndAllowThreads(__tstate);
26142 if (PyErr_Occurred()) SWIG_fail;
26143 }
26144 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26145 return resultobj;
26146 fail:
26147 return NULL;
26148 }
26149
26150
26151 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26152 PyObject *resultobj = 0;
26153 wxDateTime *arg1 = (wxDateTime *) 0 ;
26154 wxDateSpan *arg2 = 0 ;
26155 wxDateTime *result = 0 ;
26156 void *argp1 = 0 ;
26157 int res1 = 0 ;
26158 void *argp2 = 0 ;
26159 int res2 = 0 ;
26160
26161 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26162 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
26163 if (!SWIG_IsOK(res1)) {
26164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26165 }
26166 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26167 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26168 if (!SWIG_IsOK(res2)) {
26169 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26170 }
26171 if (!argp2) {
26172 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26173 }
26174 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26175 {
26176 PyThreadState* __tstate = wxPyBeginAllowThreads();
26177 {
26178 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
26179 result = (wxDateTime *) &_result_ref;
26180 }
26181 wxPyEndAllowThreads(__tstate);
26182 if (PyErr_Occurred()) SWIG_fail;
26183 }
26184 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26185 return resultobj;
26186 fail:
26187 return NULL;
26188 }
26189
26190
26191 SWIGINTERN PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
26192 int argc;
26193 PyObject *argv[3];
26194
26195 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___iadd__",0,2,argv))) SWIG_fail;
26196 --argc;
26197 if (argc == 2) {
26198 int _v = 0;
26199 {
26200 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
26201 _v = SWIG_CheckState(res);
26202 }
26203 if (!_v) goto check_1;
26204 return _wrap_DateTime___iadd____SWIG_0(self, argc, argv);
26205 }
26206 check_1:
26207
26208 if (argc == 2) {
26209 return _wrap_DateTime___iadd____SWIG_1(self, argc, argv);
26210 }
26211
26212 fail:
26213 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
26214 return NULL;
26215 }
26216
26217
26218 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26219 PyObject *resultobj = 0;
26220 wxDateTime *arg1 = (wxDateTime *) 0 ;
26221 wxTimeSpan *arg2 = 0 ;
26222 wxDateTime *result = 0 ;
26223 void *argp1 = 0 ;
26224 int res1 = 0 ;
26225 void *argp2 = 0 ;
26226 int res2 = 0 ;
26227
26228 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26229 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
26230 if (!SWIG_IsOK(res1)) {
26231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26232 }
26233 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26234 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26235 if (!SWIG_IsOK(res2)) {
26236 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26237 }
26238 if (!argp2) {
26239 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26240 }
26241 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26242 {
26243 PyThreadState* __tstate = wxPyBeginAllowThreads();
26244 {
26245 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
26246 result = (wxDateTime *) &_result_ref;
26247 }
26248 wxPyEndAllowThreads(__tstate);
26249 if (PyErr_Occurred()) SWIG_fail;
26250 }
26251 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26252 return resultobj;
26253 fail:
26254 return NULL;
26255 }
26256
26257
26258 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26259 PyObject *resultobj = 0;
26260 wxDateTime *arg1 = (wxDateTime *) 0 ;
26261 wxDateSpan *arg2 = 0 ;
26262 wxDateTime *result = 0 ;
26263 void *argp1 = 0 ;
26264 int res1 = 0 ;
26265 void *argp2 = 0 ;
26266 int res2 = 0 ;
26267
26268 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
26270 if (!SWIG_IsOK(res1)) {
26271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26272 }
26273 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26274 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26275 if (!SWIG_IsOK(res2)) {
26276 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26277 }
26278 if (!argp2) {
26279 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26280 }
26281 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26282 {
26283 PyThreadState* __tstate = wxPyBeginAllowThreads();
26284 {
26285 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
26286 result = (wxDateTime *) &_result_ref;
26287 }
26288 wxPyEndAllowThreads(__tstate);
26289 if (PyErr_Occurred()) SWIG_fail;
26290 }
26291 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26292 return resultobj;
26293 fail:
26294 return NULL;
26295 }
26296
26297
26298 SWIGINTERN PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
26299 int argc;
26300 PyObject *argv[3];
26301
26302 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___isub__",0,2,argv))) SWIG_fail;
26303 --argc;
26304 if (argc == 2) {
26305 int _v = 0;
26306 {
26307 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
26308 _v = SWIG_CheckState(res);
26309 }
26310 if (!_v) goto check_1;
26311 return _wrap_DateTime___isub____SWIG_0(self, argc, argv);
26312 }
26313 check_1:
26314
26315 if (argc == 2) {
26316 return _wrap_DateTime___isub____SWIG_1(self, argc, argv);
26317 }
26318
26319 fail:
26320 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
26321 return NULL;
26322 }
26323
26324
26325 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26326 PyObject *resultobj = 0;
26327 wxDateTime *arg1 = (wxDateTime *) 0 ;
26328 wxTimeSpan *arg2 = 0 ;
26329 wxDateTime result;
26330 void *argp1 = 0 ;
26331 int res1 = 0 ;
26332 void *argp2 = 0 ;
26333 int res2 = 0 ;
26334
26335 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26336 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26337 if (!SWIG_IsOK(res1)) {
26338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26339 }
26340 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26341 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26342 if (!SWIG_IsOK(res2)) {
26343 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26344 }
26345 if (!argp2) {
26346 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26347 }
26348 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26349 {
26350 PyThreadState* __tstate = wxPyBeginAllowThreads();
26351 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
26352 wxPyEndAllowThreads(__tstate);
26353 if (PyErr_Occurred()) SWIG_fail;
26354 }
26355 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26356 return resultobj;
26357 fail:
26358 return NULL;
26359 }
26360
26361
26362 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26363 PyObject *resultobj = 0;
26364 wxDateTime *arg1 = (wxDateTime *) 0 ;
26365 wxDateSpan *arg2 = 0 ;
26366 wxDateTime result;
26367 void *argp1 = 0 ;
26368 int res1 = 0 ;
26369 void *argp2 = 0 ;
26370 int res2 = 0 ;
26371
26372 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26373 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26374 if (!SWIG_IsOK(res1)) {
26375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26376 }
26377 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26378 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26379 if (!SWIG_IsOK(res2)) {
26380 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26381 }
26382 if (!argp2) {
26383 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26384 }
26385 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26386 {
26387 PyThreadState* __tstate = wxPyBeginAllowThreads();
26388 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
26389 wxPyEndAllowThreads(__tstate);
26390 if (PyErr_Occurred()) SWIG_fail;
26391 }
26392 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26393 return resultobj;
26394 fail:
26395 return NULL;
26396 }
26397
26398
26399 SWIGINTERN PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
26400 int argc;
26401 PyObject *argv[3];
26402
26403 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___add__",0,2,argv))) SWIG_fail;
26404 --argc;
26405 if (argc == 2) {
26406 int _v = 0;
26407 {
26408 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
26409 _v = SWIG_CheckState(res);
26410 }
26411 if (!_v) goto check_1;
26412 return _wrap_DateTime___add____SWIG_0(self, argc, argv);
26413 }
26414 check_1:
26415
26416 if (argc == 2) {
26417 return _wrap_DateTime___add____SWIG_1(self, argc, argv);
26418 }
26419
26420 fail:
26421 Py_INCREF(Py_NotImplemented);
26422 return Py_NotImplemented;
26423 }
26424
26425
26426 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26427 PyObject *resultobj = 0;
26428 wxDateTime *arg1 = (wxDateTime *) 0 ;
26429 wxDateTime *arg2 = 0 ;
26430 wxTimeSpan result;
26431 void *argp1 = 0 ;
26432 int res1 = 0 ;
26433 void *argp2 = 0 ;
26434 int res2 = 0 ;
26435
26436 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26437 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26438 if (!SWIG_IsOK(res1)) {
26439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26440 }
26441 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26442 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26443 if (!SWIG_IsOK(res2)) {
26444 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26445 }
26446 if (!argp2) {
26447 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26448 }
26449 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26450 {
26451 PyThreadState* __tstate = wxPyBeginAllowThreads();
26452 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
26453 wxPyEndAllowThreads(__tstate);
26454 if (PyErr_Occurred()) SWIG_fail;
26455 }
26456 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
26457 return resultobj;
26458 fail:
26459 return NULL;
26460 }
26461
26462
26463 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26464 PyObject *resultobj = 0;
26465 wxDateTime *arg1 = (wxDateTime *) 0 ;
26466 wxTimeSpan *arg2 = 0 ;
26467 wxDateTime result;
26468 void *argp1 = 0 ;
26469 int res1 = 0 ;
26470 void *argp2 = 0 ;
26471 int res2 = 0 ;
26472
26473 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26475 if (!SWIG_IsOK(res1)) {
26476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26477 }
26478 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26479 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26480 if (!SWIG_IsOK(res2)) {
26481 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26482 }
26483 if (!argp2) {
26484 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26485 }
26486 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26487 {
26488 PyThreadState* __tstate = wxPyBeginAllowThreads();
26489 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
26490 wxPyEndAllowThreads(__tstate);
26491 if (PyErr_Occurred()) SWIG_fail;
26492 }
26493 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26494 return resultobj;
26495 fail:
26496 return NULL;
26497 }
26498
26499
26500 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26501 PyObject *resultobj = 0;
26502 wxDateTime *arg1 = (wxDateTime *) 0 ;
26503 wxDateSpan *arg2 = 0 ;
26504 wxDateTime result;
26505 void *argp1 = 0 ;
26506 int res1 = 0 ;
26507 void *argp2 = 0 ;
26508 int res2 = 0 ;
26509
26510 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26511 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26512 if (!SWIG_IsOK(res1)) {
26513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26514 }
26515 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26516 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26517 if (!SWIG_IsOK(res2)) {
26518 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26519 }
26520 if (!argp2) {
26521 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26522 }
26523 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26524 {
26525 PyThreadState* __tstate = wxPyBeginAllowThreads();
26526 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
26527 wxPyEndAllowThreads(__tstate);
26528 if (PyErr_Occurred()) SWIG_fail;
26529 }
26530 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26531 return resultobj;
26532 fail:
26533 return NULL;
26534 }
26535
26536
26537 SWIGINTERN PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
26538 int argc;
26539 PyObject *argv[3];
26540
26541 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___sub__",0,2,argv))) SWIG_fail;
26542 --argc;
26543 if (argc == 2) {
26544 int _v = 0;
26545 {
26546 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDateTime, 0);
26547 _v = SWIG_CheckState(res);
26548 }
26549 if (!_v) goto check_1;
26550 return _wrap_DateTime___sub____SWIG_0(self, argc, argv);
26551 }
26552 check_1:
26553
26554 if (argc == 2) {
26555 int _v = 0;
26556 {
26557 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
26558 _v = SWIG_CheckState(res);
26559 }
26560 if (!_v) goto check_2;
26561 return _wrap_DateTime___sub____SWIG_1(self, argc, argv);
26562 }
26563 check_2:
26564
26565 if (argc == 2) {
26566 return _wrap_DateTime___sub____SWIG_2(self, argc, argv);
26567 }
26568
26569 fail:
26570 Py_INCREF(Py_NotImplemented);
26571 return Py_NotImplemented;
26572 }
26573
26574
26575 SWIGINTERN PyObject *_wrap_DateTime___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26576 PyObject *resultobj = 0;
26577 wxDateTime *arg1 = (wxDateTime *) 0 ;
26578 wxDateTime *arg2 = (wxDateTime *) 0 ;
26579 bool result;
26580 void *argp1 = 0 ;
26581 int res1 = 0 ;
26582 void *argp2 = 0 ;
26583 int res2 = 0 ;
26584 PyObject * obj0 = 0 ;
26585 PyObject * obj1 = 0 ;
26586 char * kwnames[] = {
26587 (char *) "self",(char *) "other", NULL
26588 };
26589
26590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
26591 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26592 if (!SWIG_IsOK(res1)) {
26593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___lt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26594 }
26595 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26596 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26597 if (!SWIG_IsOK(res2)) {
26598 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___lt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26599 }
26600 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26601 {
26602 PyThreadState* __tstate = wxPyBeginAllowThreads();
26603 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
26604 wxPyEndAllowThreads(__tstate);
26605 if (PyErr_Occurred()) SWIG_fail;
26606 }
26607 {
26608 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26609 }
26610 return resultobj;
26611 fail:
26612 return NULL;
26613 }
26614
26615
26616 SWIGINTERN PyObject *_wrap_DateTime___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26617 PyObject *resultobj = 0;
26618 wxDateTime *arg1 = (wxDateTime *) 0 ;
26619 wxDateTime *arg2 = (wxDateTime *) 0 ;
26620 bool result;
26621 void *argp1 = 0 ;
26622 int res1 = 0 ;
26623 void *argp2 = 0 ;
26624 int res2 = 0 ;
26625 PyObject * obj0 = 0 ;
26626 PyObject * obj1 = 0 ;
26627 char * kwnames[] = {
26628 (char *) "self",(char *) "other", NULL
26629 };
26630
26631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) SWIG_fail;
26632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26633 if (!SWIG_IsOK(res1)) {
26634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___le__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26635 }
26636 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26637 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26638 if (!SWIG_IsOK(res2)) {
26639 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___le__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26640 }
26641 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26642 {
26643 PyThreadState* __tstate = wxPyBeginAllowThreads();
26644 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
26645 wxPyEndAllowThreads(__tstate);
26646 if (PyErr_Occurred()) SWIG_fail;
26647 }
26648 {
26649 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26650 }
26651 return resultobj;
26652 fail:
26653 return NULL;
26654 }
26655
26656
26657 SWIGINTERN PyObject *_wrap_DateTime___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26658 PyObject *resultobj = 0;
26659 wxDateTime *arg1 = (wxDateTime *) 0 ;
26660 wxDateTime *arg2 = (wxDateTime *) 0 ;
26661 bool result;
26662 void *argp1 = 0 ;
26663 int res1 = 0 ;
26664 void *argp2 = 0 ;
26665 int res2 = 0 ;
26666 PyObject * obj0 = 0 ;
26667 PyObject * obj1 = 0 ;
26668 char * kwnames[] = {
26669 (char *) "self",(char *) "other", NULL
26670 };
26671
26672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
26673 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26674 if (!SWIG_IsOK(res1)) {
26675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___gt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26676 }
26677 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26678 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26679 if (!SWIG_IsOK(res2)) {
26680 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___gt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26681 }
26682 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26683 {
26684 PyThreadState* __tstate = wxPyBeginAllowThreads();
26685 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
26686 wxPyEndAllowThreads(__tstate);
26687 if (PyErr_Occurred()) SWIG_fail;
26688 }
26689 {
26690 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26691 }
26692 return resultobj;
26693 fail:
26694 return NULL;
26695 }
26696
26697
26698 SWIGINTERN PyObject *_wrap_DateTime___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26699 PyObject *resultobj = 0;
26700 wxDateTime *arg1 = (wxDateTime *) 0 ;
26701 wxDateTime *arg2 = (wxDateTime *) 0 ;
26702 bool result;
26703 void *argp1 = 0 ;
26704 int res1 = 0 ;
26705 void *argp2 = 0 ;
26706 int res2 = 0 ;
26707 PyObject * obj0 = 0 ;
26708 PyObject * obj1 = 0 ;
26709 char * kwnames[] = {
26710 (char *) "self",(char *) "other", NULL
26711 };
26712
26713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
26714 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26715 if (!SWIG_IsOK(res1)) {
26716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ge__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26717 }
26718 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26719 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26720 if (!SWIG_IsOK(res2)) {
26721 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ge__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26722 }
26723 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26724 {
26725 PyThreadState* __tstate = wxPyBeginAllowThreads();
26726 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
26727 wxPyEndAllowThreads(__tstate);
26728 if (PyErr_Occurred()) SWIG_fail;
26729 }
26730 {
26731 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26732 }
26733 return resultobj;
26734 fail:
26735 return NULL;
26736 }
26737
26738
26739 SWIGINTERN PyObject *_wrap_DateTime___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26740 PyObject *resultobj = 0;
26741 wxDateTime *arg1 = (wxDateTime *) 0 ;
26742 wxDateTime *arg2 = (wxDateTime *) 0 ;
26743 bool result;
26744 void *argp1 = 0 ;
26745 int res1 = 0 ;
26746 void *argp2 = 0 ;
26747 int res2 = 0 ;
26748 PyObject * obj0 = 0 ;
26749 PyObject * obj1 = 0 ;
26750 char * kwnames[] = {
26751 (char *) "self",(char *) "other", NULL
26752 };
26753
26754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
26755 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26756 if (!SWIG_IsOK(res1)) {
26757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___eq__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26758 }
26759 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26760 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26761 if (!SWIG_IsOK(res2)) {
26762 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___eq__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26763 }
26764 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26765 {
26766 PyThreadState* __tstate = wxPyBeginAllowThreads();
26767 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
26768 wxPyEndAllowThreads(__tstate);
26769 if (PyErr_Occurred()) SWIG_fail;
26770 }
26771 {
26772 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26773 }
26774 return resultobj;
26775 fail:
26776 return NULL;
26777 }
26778
26779
26780 SWIGINTERN PyObject *_wrap_DateTime___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26781 PyObject *resultobj = 0;
26782 wxDateTime *arg1 = (wxDateTime *) 0 ;
26783 wxDateTime *arg2 = (wxDateTime *) 0 ;
26784 bool result;
26785 void *argp1 = 0 ;
26786 int res1 = 0 ;
26787 void *argp2 = 0 ;
26788 int res2 = 0 ;
26789 PyObject * obj0 = 0 ;
26790 PyObject * obj1 = 0 ;
26791 char * kwnames[] = {
26792 (char *) "self",(char *) "other", NULL
26793 };
26794
26795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
26796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26797 if (!SWIG_IsOK(res1)) {
26798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ne__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26799 }
26800 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26801 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26802 if (!SWIG_IsOK(res2)) {
26803 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ne__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26804 }
26805 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26806 {
26807 PyThreadState* __tstate = wxPyBeginAllowThreads();
26808 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
26809 wxPyEndAllowThreads(__tstate);
26810 if (PyErr_Occurred()) SWIG_fail;
26811 }
26812 {
26813 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26814 }
26815 return resultobj;
26816 fail:
26817 return NULL;
26818 }
26819
26820
26821 SWIGINTERN PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26822 PyObject *resultobj = 0;
26823 wxDateTime *arg1 = (wxDateTime *) 0 ;
26824 wxString *arg2 = 0 ;
26825 int result;
26826 void *argp1 = 0 ;
26827 int res1 = 0 ;
26828 bool temp2 = false ;
26829 PyObject * obj0 = 0 ;
26830 PyObject * obj1 = 0 ;
26831 char * kwnames[] = {
26832 (char *) "self",(char *) "date", NULL
26833 };
26834
26835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) SWIG_fail;
26836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26837 if (!SWIG_IsOK(res1)) {
26838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseRfc822Date" "', expected argument " "1"" of type '" "wxDateTime *""'");
26839 }
26840 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26841 {
26842 arg2 = wxString_in_helper(obj1);
26843 if (arg2 == NULL) SWIG_fail;
26844 temp2 = true;
26845 }
26846 {
26847 PyThreadState* __tstate = wxPyBeginAllowThreads();
26848 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
26849 wxPyEndAllowThreads(__tstate);
26850 if (PyErr_Occurred()) SWIG_fail;
26851 }
26852 resultobj = SWIG_From_int(static_cast< int >(result));
26853 {
26854 if (temp2)
26855 delete arg2;
26856 }
26857 return resultobj;
26858 fail:
26859 {
26860 if (temp2)
26861 delete arg2;
26862 }
26863 return NULL;
26864 }
26865
26866
26867 SWIGINTERN PyObject *_wrap_DateTime_ParseFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26868 PyObject *resultobj = 0;
26869 wxDateTime *arg1 = (wxDateTime *) 0 ;
26870 wxString *arg2 = 0 ;
26871 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
26872 wxString *arg3 = (wxString *) &arg3_defvalue ;
26873 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
26874 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
26875 int result;
26876 void *argp1 = 0 ;
26877 int res1 = 0 ;
26878 bool temp2 = false ;
26879 bool temp3 = false ;
26880 void *argp4 = 0 ;
26881 int res4 = 0 ;
26882 PyObject * obj0 = 0 ;
26883 PyObject * obj1 = 0 ;
26884 PyObject * obj2 = 0 ;
26885 PyObject * obj3 = 0 ;
26886 char * kwnames[] = {
26887 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
26888 };
26889
26890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
26891 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26892 if (!SWIG_IsOK(res1)) {
26893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseFormat" "', expected argument " "1"" of type '" "wxDateTime *""'");
26894 }
26895 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26896 {
26897 arg2 = wxString_in_helper(obj1);
26898 if (arg2 == NULL) SWIG_fail;
26899 temp2 = true;
26900 }
26901 if (obj2) {
26902 {
26903 arg3 = wxString_in_helper(obj2);
26904 if (arg3 == NULL) SWIG_fail;
26905 temp3 = true;
26906 }
26907 }
26908 if (obj3) {
26909 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDateTime, 0 | 0);
26910 if (!SWIG_IsOK(res4)) {
26911 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
26912 }
26913 if (!argp4) {
26914 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
26915 }
26916 arg4 = reinterpret_cast< wxDateTime * >(argp4);
26917 }
26918 {
26919 PyThreadState* __tstate = wxPyBeginAllowThreads();
26920 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
26921 wxPyEndAllowThreads(__tstate);
26922 if (PyErr_Occurred()) SWIG_fail;
26923 }
26924 resultobj = SWIG_From_int(static_cast< int >(result));
26925 {
26926 if (temp2)
26927 delete arg2;
26928 }
26929 {
26930 if (temp3)
26931 delete arg3;
26932 }
26933 return resultobj;
26934 fail:
26935 {
26936 if (temp2)
26937 delete arg2;
26938 }
26939 {
26940 if (temp3)
26941 delete arg3;
26942 }
26943 return NULL;
26944 }
26945
26946
26947 SWIGINTERN PyObject *_wrap_DateTime_ParseDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26948 PyObject *resultobj = 0;
26949 wxDateTime *arg1 = (wxDateTime *) 0 ;
26950 wxString *arg2 = 0 ;
26951 int result;
26952 void *argp1 = 0 ;
26953 int res1 = 0 ;
26954 bool temp2 = false ;
26955 PyObject * obj0 = 0 ;
26956 PyObject * obj1 = 0 ;
26957 char * kwnames[] = {
26958 (char *) "self",(char *) "datetime", NULL
26959 };
26960
26961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) SWIG_fail;
26962 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26963 if (!SWIG_IsOK(res1)) {
26964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
26965 }
26966 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26967 {
26968 arg2 = wxString_in_helper(obj1);
26969 if (arg2 == NULL) SWIG_fail;
26970 temp2 = true;
26971 }
26972 {
26973 PyThreadState* __tstate = wxPyBeginAllowThreads();
26974 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
26975 wxPyEndAllowThreads(__tstate);
26976 if (PyErr_Occurred()) SWIG_fail;
26977 }
26978 resultobj = SWIG_From_int(static_cast< int >(result));
26979 {
26980 if (temp2)
26981 delete arg2;
26982 }
26983 return resultobj;
26984 fail:
26985 {
26986 if (temp2)
26987 delete arg2;
26988 }
26989 return NULL;
26990 }
26991
26992
26993 SWIGINTERN PyObject *_wrap_DateTime_ParseDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26994 PyObject *resultobj = 0;
26995 wxDateTime *arg1 = (wxDateTime *) 0 ;
26996 wxString *arg2 = 0 ;
26997 int result;
26998 void *argp1 = 0 ;
26999 int res1 = 0 ;
27000 bool temp2 = false ;
27001 PyObject * obj0 = 0 ;
27002 PyObject * obj1 = 0 ;
27003 char * kwnames[] = {
27004 (char *) "self",(char *) "date", NULL
27005 };
27006
27007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) SWIG_fail;
27008 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27009 if (!SWIG_IsOK(res1)) {
27010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDate" "', expected argument " "1"" of type '" "wxDateTime *""'");
27011 }
27012 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27013 {
27014 arg2 = wxString_in_helper(obj1);
27015 if (arg2 == NULL) SWIG_fail;
27016 temp2 = true;
27017 }
27018 {
27019 PyThreadState* __tstate = wxPyBeginAllowThreads();
27020 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
27021 wxPyEndAllowThreads(__tstate);
27022 if (PyErr_Occurred()) SWIG_fail;
27023 }
27024 resultobj = SWIG_From_int(static_cast< int >(result));
27025 {
27026 if (temp2)
27027 delete arg2;
27028 }
27029 return resultobj;
27030 fail:
27031 {
27032 if (temp2)
27033 delete arg2;
27034 }
27035 return NULL;
27036 }
27037
27038
27039 SWIGINTERN PyObject *_wrap_DateTime_ParseTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27040 PyObject *resultobj = 0;
27041 wxDateTime *arg1 = (wxDateTime *) 0 ;
27042 wxString *arg2 = 0 ;
27043 int result;
27044 void *argp1 = 0 ;
27045 int res1 = 0 ;
27046 bool temp2 = false ;
27047 PyObject * obj0 = 0 ;
27048 PyObject * obj1 = 0 ;
27049 char * kwnames[] = {
27050 (char *) "self",(char *) "time", NULL
27051 };
27052
27053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) SWIG_fail;
27054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27055 if (!SWIG_IsOK(res1)) {
27056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
27057 }
27058 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27059 {
27060 arg2 = wxString_in_helper(obj1);
27061 if (arg2 == NULL) SWIG_fail;
27062 temp2 = true;
27063 }
27064 {
27065 PyThreadState* __tstate = wxPyBeginAllowThreads();
27066 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
27067 wxPyEndAllowThreads(__tstate);
27068 if (PyErr_Occurred()) SWIG_fail;
27069 }
27070 resultobj = SWIG_From_int(static_cast< int >(result));
27071 {
27072 if (temp2)
27073 delete arg2;
27074 }
27075 return resultobj;
27076 fail:
27077 {
27078 if (temp2)
27079 delete arg2;
27080 }
27081 return NULL;
27082 }
27083
27084
27085 SWIGINTERN PyObject *_wrap_DateTime_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27086 PyObject *resultobj = 0;
27087 wxDateTime *arg1 = (wxDateTime *) 0 ;
27088 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
27089 wxString *arg2 = (wxString *) &arg2_defvalue ;
27090 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
27091 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
27092 wxString result;
27093 void *argp1 = 0 ;
27094 int res1 = 0 ;
27095 bool temp2 = false ;
27096 bool temp3 = false ;
27097 PyObject * obj0 = 0 ;
27098 PyObject * obj1 = 0 ;
27099 PyObject * obj2 = 0 ;
27100 char * kwnames[] = {
27101 (char *) "self",(char *) "format",(char *) "tz", NULL
27102 };
27103
27104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27105 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27106 if (!SWIG_IsOK(res1)) {
27107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Format" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27108 }
27109 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27110 if (obj1) {
27111 {
27112 arg2 = wxString_in_helper(obj1);
27113 if (arg2 == NULL) SWIG_fail;
27114 temp2 = true;
27115 }
27116 }
27117 if (obj2) {
27118 {
27119 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
27120 temp3 = true;
27121 }
27122 }
27123 {
27124 PyThreadState* __tstate = wxPyBeginAllowThreads();
27125 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
27126 wxPyEndAllowThreads(__tstate);
27127 if (PyErr_Occurred()) SWIG_fail;
27128 }
27129 {
27130 #if wxUSE_UNICODE
27131 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27132 #else
27133 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27134 #endif
27135 }
27136 {
27137 if (temp2)
27138 delete arg2;
27139 }
27140 {
27141 if (temp3) delete arg3;
27142 }
27143 return resultobj;
27144 fail:
27145 {
27146 if (temp2)
27147 delete arg2;
27148 }
27149 {
27150 if (temp3) delete arg3;
27151 }
27152 return NULL;
27153 }
27154
27155
27156 SWIGINTERN PyObject *_wrap_DateTime_FormatDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27157 PyObject *resultobj = 0;
27158 wxDateTime *arg1 = (wxDateTime *) 0 ;
27159 wxString result;
27160 void *argp1 = 0 ;
27161 int res1 = 0 ;
27162 PyObject *swig_obj[1] ;
27163
27164 if (!args) SWIG_fail;
27165 swig_obj[0] = args;
27166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27167 if (!SWIG_IsOK(res1)) {
27168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27169 }
27170 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27171 {
27172 PyThreadState* __tstate = wxPyBeginAllowThreads();
27173 result = ((wxDateTime const *)arg1)->FormatDate();
27174 wxPyEndAllowThreads(__tstate);
27175 if (PyErr_Occurred()) SWIG_fail;
27176 }
27177 {
27178 #if wxUSE_UNICODE
27179 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27180 #else
27181 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27182 #endif
27183 }
27184 return resultobj;
27185 fail:
27186 return NULL;
27187 }
27188
27189
27190 SWIGINTERN PyObject *_wrap_DateTime_FormatTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27191 PyObject *resultobj = 0;
27192 wxDateTime *arg1 = (wxDateTime *) 0 ;
27193 wxString result;
27194 void *argp1 = 0 ;
27195 int res1 = 0 ;
27196 PyObject *swig_obj[1] ;
27197
27198 if (!args) SWIG_fail;
27199 swig_obj[0] = args;
27200 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27201 if (!SWIG_IsOK(res1)) {
27202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27203 }
27204 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27205 {
27206 PyThreadState* __tstate = wxPyBeginAllowThreads();
27207 result = ((wxDateTime const *)arg1)->FormatTime();
27208 wxPyEndAllowThreads(__tstate);
27209 if (PyErr_Occurred()) SWIG_fail;
27210 }
27211 {
27212 #if wxUSE_UNICODE
27213 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27214 #else
27215 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27216 #endif
27217 }
27218 return resultobj;
27219 fail:
27220 return NULL;
27221 }
27222
27223
27224 SWIGINTERN PyObject *_wrap_DateTime_FormatISODate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27225 PyObject *resultobj = 0;
27226 wxDateTime *arg1 = (wxDateTime *) 0 ;
27227 wxString result;
27228 void *argp1 = 0 ;
27229 int res1 = 0 ;
27230 PyObject *swig_obj[1] ;
27231
27232 if (!args) SWIG_fail;
27233 swig_obj[0] = args;
27234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27235 if (!SWIG_IsOK(res1)) {
27236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISODate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27237 }
27238 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27239 {
27240 PyThreadState* __tstate = wxPyBeginAllowThreads();
27241 result = ((wxDateTime const *)arg1)->FormatISODate();
27242 wxPyEndAllowThreads(__tstate);
27243 if (PyErr_Occurred()) SWIG_fail;
27244 }
27245 {
27246 #if wxUSE_UNICODE
27247 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27248 #else
27249 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27250 #endif
27251 }
27252 return resultobj;
27253 fail:
27254 return NULL;
27255 }
27256
27257
27258 SWIGINTERN PyObject *_wrap_DateTime_FormatISOTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27259 PyObject *resultobj = 0;
27260 wxDateTime *arg1 = (wxDateTime *) 0 ;
27261 wxString result;
27262 void *argp1 = 0 ;
27263 int res1 = 0 ;
27264 PyObject *swig_obj[1] ;
27265
27266 if (!args) SWIG_fail;
27267 swig_obj[0] = args;
27268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27269 if (!SWIG_IsOK(res1)) {
27270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISOTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27271 }
27272 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27273 {
27274 PyThreadState* __tstate = wxPyBeginAllowThreads();
27275 result = ((wxDateTime const *)arg1)->FormatISOTime();
27276 wxPyEndAllowThreads(__tstate);
27277 if (PyErr_Occurred()) SWIG_fail;
27278 }
27279 {
27280 #if wxUSE_UNICODE
27281 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27282 #else
27283 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27284 #endif
27285 }
27286 return resultobj;
27287 fail:
27288 return NULL;
27289 }
27290
27291
27292 SWIGINTERN PyObject *DateTime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27293 PyObject *obj;
27294 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27295 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateTime, SWIG_NewClientData(obj));
27296 return SWIG_Py_Void();
27297 }
27298
27299 SWIGINTERN PyObject *DateTime_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27300 return SWIG_Python_InitShadowInstance(args);
27301 }
27302
27303 SWIGINTERN PyObject *_wrap_TimeSpan_Milliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27304 PyObject *resultobj = 0;
27305 long arg1 ;
27306 wxTimeSpan result;
27307 long val1 ;
27308 int ecode1 = 0 ;
27309 PyObject * obj0 = 0 ;
27310 char * kwnames[] = {
27311 (char *) "ms", NULL
27312 };
27313
27314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Milliseconds",kwnames,&obj0)) SWIG_fail;
27315 ecode1 = SWIG_AsVal_long(obj0, &val1);
27316 if (!SWIG_IsOK(ecode1)) {
27317 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Milliseconds" "', expected argument " "1"" of type '" "long""'");
27318 }
27319 arg1 = static_cast< long >(val1);
27320 {
27321 PyThreadState* __tstate = wxPyBeginAllowThreads();
27322 result = wxTimeSpan::Milliseconds(arg1);
27323 wxPyEndAllowThreads(__tstate);
27324 if (PyErr_Occurred()) SWIG_fail;
27325 }
27326 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27327 return resultobj;
27328 fail:
27329 return NULL;
27330 }
27331
27332
27333 SWIGINTERN PyObject *_wrap_TimeSpan_Millisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27334 PyObject *resultobj = 0;
27335 wxTimeSpan result;
27336
27337 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Millisecond",0,0,0)) SWIG_fail;
27338 {
27339 PyThreadState* __tstate = wxPyBeginAllowThreads();
27340 result = wxTimeSpan::Millisecond();
27341 wxPyEndAllowThreads(__tstate);
27342 if (PyErr_Occurred()) SWIG_fail;
27343 }
27344 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27345 return resultobj;
27346 fail:
27347 return NULL;
27348 }
27349
27350
27351 SWIGINTERN PyObject *_wrap_TimeSpan_Seconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27352 PyObject *resultobj = 0;
27353 long arg1 ;
27354 wxTimeSpan result;
27355 long val1 ;
27356 int ecode1 = 0 ;
27357 PyObject * obj0 = 0 ;
27358 char * kwnames[] = {
27359 (char *) "sec", NULL
27360 };
27361
27362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) SWIG_fail;
27363 ecode1 = SWIG_AsVal_long(obj0, &val1);
27364 if (!SWIG_IsOK(ecode1)) {
27365 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Seconds" "', expected argument " "1"" of type '" "long""'");
27366 }
27367 arg1 = static_cast< long >(val1);
27368 {
27369 PyThreadState* __tstate = wxPyBeginAllowThreads();
27370 result = wxTimeSpan::Seconds(arg1);
27371 wxPyEndAllowThreads(__tstate);
27372 if (PyErr_Occurred()) SWIG_fail;
27373 }
27374 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27375 return resultobj;
27376 fail:
27377 return NULL;
27378 }
27379
27380
27381 SWIGINTERN PyObject *_wrap_TimeSpan_Second(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27382 PyObject *resultobj = 0;
27383 wxTimeSpan result;
27384
27385 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Second",0,0,0)) SWIG_fail;
27386 {
27387 PyThreadState* __tstate = wxPyBeginAllowThreads();
27388 result = wxTimeSpan::Second();
27389 wxPyEndAllowThreads(__tstate);
27390 if (PyErr_Occurred()) SWIG_fail;
27391 }
27392 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27393 return resultobj;
27394 fail:
27395 return NULL;
27396 }
27397
27398
27399 SWIGINTERN PyObject *_wrap_TimeSpan_Minutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27400 PyObject *resultobj = 0;
27401 long arg1 ;
27402 wxTimeSpan result;
27403 long val1 ;
27404 int ecode1 = 0 ;
27405 PyObject * obj0 = 0 ;
27406 char * kwnames[] = {
27407 (char *) "min", NULL
27408 };
27409
27410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) SWIG_fail;
27411 ecode1 = SWIG_AsVal_long(obj0, &val1);
27412 if (!SWIG_IsOK(ecode1)) {
27413 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Minutes" "', expected argument " "1"" of type '" "long""'");
27414 }
27415 arg1 = static_cast< long >(val1);
27416 {
27417 PyThreadState* __tstate = wxPyBeginAllowThreads();
27418 result = wxTimeSpan::Minutes(arg1);
27419 wxPyEndAllowThreads(__tstate);
27420 if (PyErr_Occurred()) SWIG_fail;
27421 }
27422 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27423 return resultobj;
27424 fail:
27425 return NULL;
27426 }
27427
27428
27429 SWIGINTERN PyObject *_wrap_TimeSpan_Minute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27430 PyObject *resultobj = 0;
27431 wxTimeSpan result;
27432
27433 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Minute",0,0,0)) SWIG_fail;
27434 {
27435 PyThreadState* __tstate = wxPyBeginAllowThreads();
27436 result = wxTimeSpan::Minute();
27437 wxPyEndAllowThreads(__tstate);
27438 if (PyErr_Occurred()) SWIG_fail;
27439 }
27440 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27441 return resultobj;
27442 fail:
27443 return NULL;
27444 }
27445
27446
27447 SWIGINTERN PyObject *_wrap_TimeSpan_Hours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27448 PyObject *resultobj = 0;
27449 long arg1 ;
27450 wxTimeSpan result;
27451 long val1 ;
27452 int ecode1 = 0 ;
27453 PyObject * obj0 = 0 ;
27454 char * kwnames[] = {
27455 (char *) "hours", NULL
27456 };
27457
27458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) SWIG_fail;
27459 ecode1 = SWIG_AsVal_long(obj0, &val1);
27460 if (!SWIG_IsOK(ecode1)) {
27461 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Hours" "', expected argument " "1"" of type '" "long""'");
27462 }
27463 arg1 = static_cast< long >(val1);
27464 {
27465 PyThreadState* __tstate = wxPyBeginAllowThreads();
27466 result = wxTimeSpan::Hours(arg1);
27467 wxPyEndAllowThreads(__tstate);
27468 if (PyErr_Occurred()) SWIG_fail;
27469 }
27470 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27471 return resultobj;
27472 fail:
27473 return NULL;
27474 }
27475
27476
27477 SWIGINTERN PyObject *_wrap_TimeSpan_Hour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27478 PyObject *resultobj = 0;
27479 wxTimeSpan result;
27480
27481 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Hour",0,0,0)) SWIG_fail;
27482 {
27483 PyThreadState* __tstate = wxPyBeginAllowThreads();
27484 result = wxTimeSpan::Hour();
27485 wxPyEndAllowThreads(__tstate);
27486 if (PyErr_Occurred()) SWIG_fail;
27487 }
27488 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27489 return resultobj;
27490 fail:
27491 return NULL;
27492 }
27493
27494
27495 SWIGINTERN PyObject *_wrap_TimeSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27496 PyObject *resultobj = 0;
27497 long arg1 ;
27498 wxTimeSpan result;
27499 long val1 ;
27500 int ecode1 = 0 ;
27501 PyObject * obj0 = 0 ;
27502 char * kwnames[] = {
27503 (char *) "days", NULL
27504 };
27505
27506 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) SWIG_fail;
27507 ecode1 = SWIG_AsVal_long(obj0, &val1);
27508 if (!SWIG_IsOK(ecode1)) {
27509 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Days" "', expected argument " "1"" of type '" "long""'");
27510 }
27511 arg1 = static_cast< long >(val1);
27512 {
27513 PyThreadState* __tstate = wxPyBeginAllowThreads();
27514 result = wxTimeSpan::Days(arg1);
27515 wxPyEndAllowThreads(__tstate);
27516 if (PyErr_Occurred()) SWIG_fail;
27517 }
27518 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27519 return resultobj;
27520 fail:
27521 return NULL;
27522 }
27523
27524
27525 SWIGINTERN PyObject *_wrap_TimeSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27526 PyObject *resultobj = 0;
27527 wxTimeSpan result;
27528
27529 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Day",0,0,0)) SWIG_fail;
27530 {
27531 PyThreadState* __tstate = wxPyBeginAllowThreads();
27532 result = wxTimeSpan::Day();
27533 wxPyEndAllowThreads(__tstate);
27534 if (PyErr_Occurred()) SWIG_fail;
27535 }
27536 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27537 return resultobj;
27538 fail:
27539 return NULL;
27540 }
27541
27542
27543 SWIGINTERN PyObject *_wrap_TimeSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27544 PyObject *resultobj = 0;
27545 long arg1 ;
27546 wxTimeSpan result;
27547 long val1 ;
27548 int ecode1 = 0 ;
27549 PyObject * obj0 = 0 ;
27550 char * kwnames[] = {
27551 (char *) "days", NULL
27552 };
27553
27554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) SWIG_fail;
27555 ecode1 = SWIG_AsVal_long(obj0, &val1);
27556 if (!SWIG_IsOK(ecode1)) {
27557 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Weeks" "', expected argument " "1"" of type '" "long""'");
27558 }
27559 arg1 = static_cast< long >(val1);
27560 {
27561 PyThreadState* __tstate = wxPyBeginAllowThreads();
27562 result = wxTimeSpan::Weeks(arg1);
27563 wxPyEndAllowThreads(__tstate);
27564 if (PyErr_Occurred()) SWIG_fail;
27565 }
27566 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27567 return resultobj;
27568 fail:
27569 return NULL;
27570 }
27571
27572
27573 SWIGINTERN PyObject *_wrap_TimeSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27574 PyObject *resultobj = 0;
27575 wxTimeSpan result;
27576
27577 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Week",0,0,0)) SWIG_fail;
27578 {
27579 PyThreadState* __tstate = wxPyBeginAllowThreads();
27580 result = wxTimeSpan::Week();
27581 wxPyEndAllowThreads(__tstate);
27582 if (PyErr_Occurred()) SWIG_fail;
27583 }
27584 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27585 return resultobj;
27586 fail:
27587 return NULL;
27588 }
27589
27590
27591 SWIGINTERN PyObject *_wrap_new_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27592 PyObject *resultobj = 0;
27593 long arg1 = (long) 0 ;
27594 long arg2 = (long) 0 ;
27595 long arg3 = (long) 0 ;
27596 long arg4 = (long) 0 ;
27597 wxTimeSpan *result = 0 ;
27598 long val1 ;
27599 int ecode1 = 0 ;
27600 long val2 ;
27601 int ecode2 = 0 ;
27602 long val3 ;
27603 int ecode3 = 0 ;
27604 long val4 ;
27605 int ecode4 = 0 ;
27606 PyObject * obj0 = 0 ;
27607 PyObject * obj1 = 0 ;
27608 PyObject * obj2 = 0 ;
27609 PyObject * obj3 = 0 ;
27610 char * kwnames[] = {
27611 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
27612 };
27613
27614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27615 if (obj0) {
27616 ecode1 = SWIG_AsVal_long(obj0, &val1);
27617 if (!SWIG_IsOK(ecode1)) {
27618 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimeSpan" "', expected argument " "1"" of type '" "long""'");
27619 }
27620 arg1 = static_cast< long >(val1);
27621 }
27622 if (obj1) {
27623 ecode2 = SWIG_AsVal_long(obj1, &val2);
27624 if (!SWIG_IsOK(ecode2)) {
27625 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimeSpan" "', expected argument " "2"" of type '" "long""'");
27626 }
27627 arg2 = static_cast< long >(val2);
27628 }
27629 if (obj2) {
27630 ecode3 = SWIG_AsVal_long(obj2, &val3);
27631 if (!SWIG_IsOK(ecode3)) {
27632 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimeSpan" "', expected argument " "3"" of type '" "long""'");
27633 }
27634 arg3 = static_cast< long >(val3);
27635 }
27636 if (obj3) {
27637 ecode4 = SWIG_AsVal_long(obj3, &val4);
27638 if (!SWIG_IsOK(ecode4)) {
27639 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TimeSpan" "', expected argument " "4"" of type '" "long""'");
27640 }
27641 arg4 = static_cast< long >(val4);
27642 }
27643 {
27644 PyThreadState* __tstate = wxPyBeginAllowThreads();
27645 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
27646 wxPyEndAllowThreads(__tstate);
27647 if (PyErr_Occurred()) SWIG_fail;
27648 }
27649 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_NEW | 0 );
27650 return resultobj;
27651 fail:
27652 return NULL;
27653 }
27654
27655
27656 SWIGINTERN PyObject *_wrap_delete_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27657 PyObject *resultobj = 0;
27658 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27659 void *argp1 = 0 ;
27660 int res1 = 0 ;
27661 PyObject *swig_obj[1] ;
27662
27663 if (!args) SWIG_fail;
27664 swig_obj[0] = args;
27665 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
27666 if (!SWIG_IsOK(res1)) {
27667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimeSpan" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27668 }
27669 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27670 {
27671 PyThreadState* __tstate = wxPyBeginAllowThreads();
27672 delete arg1;
27673
27674 wxPyEndAllowThreads(__tstate);
27675 if (PyErr_Occurred()) SWIG_fail;
27676 }
27677 resultobj = SWIG_Py_Void();
27678 return resultobj;
27679 fail:
27680 return NULL;
27681 }
27682
27683
27684 SWIGINTERN PyObject *_wrap_TimeSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27685 PyObject *resultobj = 0;
27686 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27687 wxTimeSpan *arg2 = 0 ;
27688 wxTimeSpan *result = 0 ;
27689 void *argp1 = 0 ;
27690 int res1 = 0 ;
27691 void *argp2 = 0 ;
27692 int res2 = 0 ;
27693 PyObject * obj0 = 0 ;
27694 PyObject * obj1 = 0 ;
27695 char * kwnames[] = {
27696 (char *) "self",(char *) "diff", NULL
27697 };
27698
27699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
27700 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27701 if (!SWIG_IsOK(res1)) {
27702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Add" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27703 }
27704 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27705 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27706 if (!SWIG_IsOK(res2)) {
27707 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27708 }
27709 if (!argp2) {
27710 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27711 }
27712 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27713 {
27714 PyThreadState* __tstate = wxPyBeginAllowThreads();
27715 {
27716 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
27717 result = (wxTimeSpan *) &_result_ref;
27718 }
27719 wxPyEndAllowThreads(__tstate);
27720 if (PyErr_Occurred()) SWIG_fail;
27721 }
27722 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27723 return resultobj;
27724 fail:
27725 return NULL;
27726 }
27727
27728
27729 SWIGINTERN PyObject *_wrap_TimeSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27730 PyObject *resultobj = 0;
27731 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27732 wxTimeSpan *arg2 = 0 ;
27733 wxTimeSpan *result = 0 ;
27734 void *argp1 = 0 ;
27735 int res1 = 0 ;
27736 void *argp2 = 0 ;
27737 int res2 = 0 ;
27738 PyObject * obj0 = 0 ;
27739 PyObject * obj1 = 0 ;
27740 char * kwnames[] = {
27741 (char *) "self",(char *) "diff", NULL
27742 };
27743
27744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
27745 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27746 if (!SWIG_IsOK(res1)) {
27747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Subtract" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27748 }
27749 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27750 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27751 if (!SWIG_IsOK(res2)) {
27752 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27753 }
27754 if (!argp2) {
27755 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27756 }
27757 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27758 {
27759 PyThreadState* __tstate = wxPyBeginAllowThreads();
27760 {
27761 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
27762 result = (wxTimeSpan *) &_result_ref;
27763 }
27764 wxPyEndAllowThreads(__tstate);
27765 if (PyErr_Occurred()) SWIG_fail;
27766 }
27767 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27768 return resultobj;
27769 fail:
27770 return NULL;
27771 }
27772
27773
27774 SWIGINTERN PyObject *_wrap_TimeSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27775 PyObject *resultobj = 0;
27776 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27777 int arg2 ;
27778 wxTimeSpan *result = 0 ;
27779 void *argp1 = 0 ;
27780 int res1 = 0 ;
27781 int val2 ;
27782 int ecode2 = 0 ;
27783 PyObject * obj0 = 0 ;
27784 PyObject * obj1 = 0 ;
27785 char * kwnames[] = {
27786 (char *) "self",(char *) "n", NULL
27787 };
27788
27789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
27790 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27791 if (!SWIG_IsOK(res1)) {
27792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Multiply" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27793 }
27794 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27795 ecode2 = SWIG_AsVal_int(obj1, &val2);
27796 if (!SWIG_IsOK(ecode2)) {
27797 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
27798 }
27799 arg2 = static_cast< int >(val2);
27800 {
27801 PyThreadState* __tstate = wxPyBeginAllowThreads();
27802 {
27803 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
27804 result = (wxTimeSpan *) &_result_ref;
27805 }
27806 wxPyEndAllowThreads(__tstate);
27807 if (PyErr_Occurred()) SWIG_fail;
27808 }
27809 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27810 return resultobj;
27811 fail:
27812 return NULL;
27813 }
27814
27815
27816 SWIGINTERN PyObject *_wrap_TimeSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27817 PyObject *resultobj = 0;
27818 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27819 wxTimeSpan *result = 0 ;
27820 void *argp1 = 0 ;
27821 int res1 = 0 ;
27822 PyObject *swig_obj[1] ;
27823
27824 if (!args) SWIG_fail;
27825 swig_obj[0] = args;
27826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27827 if (!SWIG_IsOK(res1)) {
27828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Neg" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27829 }
27830 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27831 {
27832 PyThreadState* __tstate = wxPyBeginAllowThreads();
27833 {
27834 wxTimeSpan &_result_ref = (arg1)->Neg();
27835 result = (wxTimeSpan *) &_result_ref;
27836 }
27837 wxPyEndAllowThreads(__tstate);
27838 if (PyErr_Occurred()) SWIG_fail;
27839 }
27840 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27841 return resultobj;
27842 fail:
27843 return NULL;
27844 }
27845
27846
27847 SWIGINTERN PyObject *_wrap_TimeSpan_Abs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27848 PyObject *resultobj = 0;
27849 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27850 wxTimeSpan result;
27851 void *argp1 = 0 ;
27852 int res1 = 0 ;
27853 PyObject *swig_obj[1] ;
27854
27855 if (!args) SWIG_fail;
27856 swig_obj[0] = args;
27857 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27858 if (!SWIG_IsOK(res1)) {
27859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Abs" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
27860 }
27861 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27862 {
27863 PyThreadState* __tstate = wxPyBeginAllowThreads();
27864 result = ((wxTimeSpan const *)arg1)->Abs();
27865 wxPyEndAllowThreads(__tstate);
27866 if (PyErr_Occurred()) SWIG_fail;
27867 }
27868 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27869 return resultobj;
27870 fail:
27871 return NULL;
27872 }
27873
27874
27875 SWIGINTERN PyObject *_wrap_TimeSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27876 PyObject *resultobj = 0;
27877 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27878 wxTimeSpan *arg2 = 0 ;
27879 wxTimeSpan *result = 0 ;
27880 void *argp1 = 0 ;
27881 int res1 = 0 ;
27882 void *argp2 = 0 ;
27883 int res2 = 0 ;
27884 PyObject * obj0 = 0 ;
27885 PyObject * obj1 = 0 ;
27886 char * kwnames[] = {
27887 (char *) "self",(char *) "diff", NULL
27888 };
27889
27890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
27891 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
27892 if (!SWIG_IsOK(res1)) {
27893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___iadd__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27894 }
27895 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27896 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27897 if (!SWIG_IsOK(res2)) {
27898 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27899 }
27900 if (!argp2) {
27901 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27902 }
27903 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27904 {
27905 PyThreadState* __tstate = wxPyBeginAllowThreads();
27906 {
27907 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
27908 result = (wxTimeSpan *) &_result_ref;
27909 }
27910 wxPyEndAllowThreads(__tstate);
27911 if (PyErr_Occurred()) SWIG_fail;
27912 }
27913 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27914 return resultobj;
27915 fail:
27916 return NULL;
27917 }
27918
27919
27920 SWIGINTERN PyObject *_wrap_TimeSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27921 PyObject *resultobj = 0;
27922 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27923 wxTimeSpan *arg2 = 0 ;
27924 wxTimeSpan *result = 0 ;
27925 void *argp1 = 0 ;
27926 int res1 = 0 ;
27927 void *argp2 = 0 ;
27928 int res2 = 0 ;
27929 PyObject * obj0 = 0 ;
27930 PyObject * obj1 = 0 ;
27931 char * kwnames[] = {
27932 (char *) "self",(char *) "diff", NULL
27933 };
27934
27935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
27936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
27937 if (!SWIG_IsOK(res1)) {
27938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___isub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27939 }
27940 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27941 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27942 if (!SWIG_IsOK(res2)) {
27943 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27944 }
27945 if (!argp2) {
27946 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27947 }
27948 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27949 {
27950 PyThreadState* __tstate = wxPyBeginAllowThreads();
27951 {
27952 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
27953 result = (wxTimeSpan *) &_result_ref;
27954 }
27955 wxPyEndAllowThreads(__tstate);
27956 if (PyErr_Occurred()) SWIG_fail;
27957 }
27958 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27959 return resultobj;
27960 fail:
27961 return NULL;
27962 }
27963
27964
27965 SWIGINTERN PyObject *_wrap_TimeSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27966 PyObject *resultobj = 0;
27967 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27968 int arg2 ;
27969 wxTimeSpan *result = 0 ;
27970 void *argp1 = 0 ;
27971 int res1 = 0 ;
27972 int val2 ;
27973 int ecode2 = 0 ;
27974 PyObject * obj0 = 0 ;
27975 PyObject * obj1 = 0 ;
27976 char * kwnames[] = {
27977 (char *) "self",(char *) "n", NULL
27978 };
27979
27980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
27981 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
27982 if (!SWIG_IsOK(res1)) {
27983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___imul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27984 }
27985 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27986 ecode2 = SWIG_AsVal_int(obj1, &val2);
27987 if (!SWIG_IsOK(ecode2)) {
27988 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___imul__" "', expected argument " "2"" of type '" "int""'");
27989 }
27990 arg2 = static_cast< int >(val2);
27991 {
27992 PyThreadState* __tstate = wxPyBeginAllowThreads();
27993 {
27994 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
27995 result = (wxTimeSpan *) &_result_ref;
27996 }
27997 wxPyEndAllowThreads(__tstate);
27998 if (PyErr_Occurred()) SWIG_fail;
27999 }
28000 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28001 return resultobj;
28002 fail:
28003 return NULL;
28004 }
28005
28006
28007 SWIGINTERN PyObject *_wrap_TimeSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28008 PyObject *resultobj = 0;
28009 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28010 wxTimeSpan *result = 0 ;
28011 void *argp1 = 0 ;
28012 int res1 = 0 ;
28013 PyObject *swig_obj[1] ;
28014
28015 if (!args) SWIG_fail;
28016 swig_obj[0] = args;
28017 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28018 if (!SWIG_IsOK(res1)) {
28019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___neg__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28020 }
28021 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28022 {
28023 PyThreadState* __tstate = wxPyBeginAllowThreads();
28024 {
28025 wxTimeSpan &_result_ref = (arg1)->operator -();
28026 result = (wxTimeSpan *) &_result_ref;
28027 }
28028 wxPyEndAllowThreads(__tstate);
28029 if (PyErr_Occurred()) SWIG_fail;
28030 }
28031 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28032 return resultobj;
28033 fail:
28034 return NULL;
28035 }
28036
28037
28038 SWIGINTERN PyObject *_wrap_TimeSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28039 PyObject *resultobj = 0;
28040 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28041 wxTimeSpan *arg2 = 0 ;
28042 wxTimeSpan result;
28043 void *argp1 = 0 ;
28044 int res1 = 0 ;
28045 void *argp2 = 0 ;
28046 int res2 = 0 ;
28047 PyObject * obj0 = 0 ;
28048 PyObject * obj1 = 0 ;
28049 char * kwnames[] = {
28050 (char *) "self",(char *) "other", NULL
28051 };
28052
28053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
28054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28055 if (!SWIG_IsOK(res1)) {
28056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___add__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28057 }
28058 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28059 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28060 if (!SWIG_IsOK(res2)) {
28061 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28062 }
28063 if (!argp2) {
28064 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28065 }
28066 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28067 {
28068 PyThreadState* __tstate = wxPyBeginAllowThreads();
28069 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
28070 wxPyEndAllowThreads(__tstate);
28071 if (PyErr_Occurred()) SWIG_fail;
28072 }
28073 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28074 return resultobj;
28075 fail:
28076 return NULL;
28077 }
28078
28079
28080 SWIGINTERN PyObject *_wrap_TimeSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28081 PyObject *resultobj = 0;
28082 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28083 wxTimeSpan *arg2 = 0 ;
28084 wxTimeSpan result;
28085 void *argp1 = 0 ;
28086 int res1 = 0 ;
28087 void *argp2 = 0 ;
28088 int res2 = 0 ;
28089 PyObject * obj0 = 0 ;
28090 PyObject * obj1 = 0 ;
28091 char * kwnames[] = {
28092 (char *) "self",(char *) "other", NULL
28093 };
28094
28095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
28096 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28097 if (!SWIG_IsOK(res1)) {
28098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___sub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28099 }
28100 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28101 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28102 if (!SWIG_IsOK(res2)) {
28103 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28104 }
28105 if (!argp2) {
28106 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28107 }
28108 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28109 {
28110 PyThreadState* __tstate = wxPyBeginAllowThreads();
28111 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
28112 wxPyEndAllowThreads(__tstate);
28113 if (PyErr_Occurred()) SWIG_fail;
28114 }
28115 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28116 return resultobj;
28117 fail:
28118 return NULL;
28119 }
28120
28121
28122 SWIGINTERN PyObject *_wrap_TimeSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28123 PyObject *resultobj = 0;
28124 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28125 int arg2 ;
28126 wxTimeSpan result;
28127 void *argp1 = 0 ;
28128 int res1 = 0 ;
28129 int val2 ;
28130 int ecode2 = 0 ;
28131 PyObject * obj0 = 0 ;
28132 PyObject * obj1 = 0 ;
28133 char * kwnames[] = {
28134 (char *) "self",(char *) "n", NULL
28135 };
28136
28137 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
28138 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28139 if (!SWIG_IsOK(res1)) {
28140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___mul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28141 }
28142 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28143 ecode2 = SWIG_AsVal_int(obj1, &val2);
28144 if (!SWIG_IsOK(ecode2)) {
28145 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___mul__" "', expected argument " "2"" of type '" "int""'");
28146 }
28147 arg2 = static_cast< int >(val2);
28148 {
28149 PyThreadState* __tstate = wxPyBeginAllowThreads();
28150 result = wxTimeSpan___mul__(arg1,arg2);
28151 wxPyEndAllowThreads(__tstate);
28152 if (PyErr_Occurred()) SWIG_fail;
28153 }
28154 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28155 return resultobj;
28156 fail:
28157 return NULL;
28158 }
28159
28160
28161 SWIGINTERN PyObject *_wrap_TimeSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28162 PyObject *resultobj = 0;
28163 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28164 int arg2 ;
28165 wxTimeSpan result;
28166 void *argp1 = 0 ;
28167 int res1 = 0 ;
28168 int val2 ;
28169 int ecode2 = 0 ;
28170 PyObject * obj0 = 0 ;
28171 PyObject * obj1 = 0 ;
28172 char * kwnames[] = {
28173 (char *) "self",(char *) "n", NULL
28174 };
28175
28176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
28177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28178 if (!SWIG_IsOK(res1)) {
28179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___rmul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28180 }
28181 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28182 ecode2 = SWIG_AsVal_int(obj1, &val2);
28183 if (!SWIG_IsOK(ecode2)) {
28184 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
28185 }
28186 arg2 = static_cast< int >(val2);
28187 {
28188 PyThreadState* __tstate = wxPyBeginAllowThreads();
28189 result = wxTimeSpan___rmul__(arg1,arg2);
28190 wxPyEndAllowThreads(__tstate);
28191 if (PyErr_Occurred()) SWIG_fail;
28192 }
28193 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28194 return resultobj;
28195 fail:
28196 return NULL;
28197 }
28198
28199
28200 SWIGINTERN PyObject *_wrap_TimeSpan___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28201 PyObject *resultobj = 0;
28202 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28203 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28204 bool result;
28205 void *argp1 = 0 ;
28206 int res1 = 0 ;
28207 void *argp2 = 0 ;
28208 int res2 = 0 ;
28209 PyObject * obj0 = 0 ;
28210 PyObject * obj1 = 0 ;
28211 char * kwnames[] = {
28212 (char *) "self",(char *) "other", NULL
28213 };
28214
28215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
28216 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28217 if (!SWIG_IsOK(res1)) {
28218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___lt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28219 }
28220 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28221 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28222 if (!SWIG_IsOK(res2)) {
28223 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___lt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28224 }
28225 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28226 {
28227 PyThreadState* __tstate = wxPyBeginAllowThreads();
28228 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
28229 wxPyEndAllowThreads(__tstate);
28230 if (PyErr_Occurred()) SWIG_fail;
28231 }
28232 {
28233 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28234 }
28235 return resultobj;
28236 fail:
28237 return NULL;
28238 }
28239
28240
28241 SWIGINTERN PyObject *_wrap_TimeSpan___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28242 PyObject *resultobj = 0;
28243 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28244 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28245 bool result;
28246 void *argp1 = 0 ;
28247 int res1 = 0 ;
28248 void *argp2 = 0 ;
28249 int res2 = 0 ;
28250 PyObject * obj0 = 0 ;
28251 PyObject * obj1 = 0 ;
28252 char * kwnames[] = {
28253 (char *) "self",(char *) "other", NULL
28254 };
28255
28256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) SWIG_fail;
28257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28258 if (!SWIG_IsOK(res1)) {
28259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___le__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28260 }
28261 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28262 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28263 if (!SWIG_IsOK(res2)) {
28264 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___le__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28265 }
28266 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28267 {
28268 PyThreadState* __tstate = wxPyBeginAllowThreads();
28269 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
28270 wxPyEndAllowThreads(__tstate);
28271 if (PyErr_Occurred()) SWIG_fail;
28272 }
28273 {
28274 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28275 }
28276 return resultobj;
28277 fail:
28278 return NULL;
28279 }
28280
28281
28282 SWIGINTERN PyObject *_wrap_TimeSpan___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28283 PyObject *resultobj = 0;
28284 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28285 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28286 bool result;
28287 void *argp1 = 0 ;
28288 int res1 = 0 ;
28289 void *argp2 = 0 ;
28290 int res2 = 0 ;
28291 PyObject * obj0 = 0 ;
28292 PyObject * obj1 = 0 ;
28293 char * kwnames[] = {
28294 (char *) "self",(char *) "other", NULL
28295 };
28296
28297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
28298 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28299 if (!SWIG_IsOK(res1)) {
28300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___gt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28301 }
28302 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28303 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28304 if (!SWIG_IsOK(res2)) {
28305 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___gt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28306 }
28307 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28308 {
28309 PyThreadState* __tstate = wxPyBeginAllowThreads();
28310 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
28311 wxPyEndAllowThreads(__tstate);
28312 if (PyErr_Occurred()) SWIG_fail;
28313 }
28314 {
28315 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28316 }
28317 return resultobj;
28318 fail:
28319 return NULL;
28320 }
28321
28322
28323 SWIGINTERN PyObject *_wrap_TimeSpan___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28324 PyObject *resultobj = 0;
28325 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28326 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28327 bool result;
28328 void *argp1 = 0 ;
28329 int res1 = 0 ;
28330 void *argp2 = 0 ;
28331 int res2 = 0 ;
28332 PyObject * obj0 = 0 ;
28333 PyObject * obj1 = 0 ;
28334 char * kwnames[] = {
28335 (char *) "self",(char *) "other", NULL
28336 };
28337
28338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
28339 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28340 if (!SWIG_IsOK(res1)) {
28341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ge__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28342 }
28343 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28344 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28345 if (!SWIG_IsOK(res2)) {
28346 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ge__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28347 }
28348 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28349 {
28350 PyThreadState* __tstate = wxPyBeginAllowThreads();
28351 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
28352 wxPyEndAllowThreads(__tstate);
28353 if (PyErr_Occurred()) SWIG_fail;
28354 }
28355 {
28356 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28357 }
28358 return resultobj;
28359 fail:
28360 return NULL;
28361 }
28362
28363
28364 SWIGINTERN PyObject *_wrap_TimeSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28365 PyObject *resultobj = 0;
28366 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28367 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28368 bool result;
28369 void *argp1 = 0 ;
28370 int res1 = 0 ;
28371 void *argp2 = 0 ;
28372 int res2 = 0 ;
28373 PyObject * obj0 = 0 ;
28374 PyObject * obj1 = 0 ;
28375 char * kwnames[] = {
28376 (char *) "self",(char *) "other", NULL
28377 };
28378
28379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
28380 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28381 if (!SWIG_IsOK(res1)) {
28382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___eq__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28383 }
28384 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28385 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28386 if (!SWIG_IsOK(res2)) {
28387 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___eq__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28388 }
28389 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28390 {
28391 PyThreadState* __tstate = wxPyBeginAllowThreads();
28392 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
28393 wxPyEndAllowThreads(__tstate);
28394 if (PyErr_Occurred()) SWIG_fail;
28395 }
28396 {
28397 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28398 }
28399 return resultobj;
28400 fail:
28401 return NULL;
28402 }
28403
28404
28405 SWIGINTERN PyObject *_wrap_TimeSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28406 PyObject *resultobj = 0;
28407 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28408 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28409 bool result;
28410 void *argp1 = 0 ;
28411 int res1 = 0 ;
28412 void *argp2 = 0 ;
28413 int res2 = 0 ;
28414 PyObject * obj0 = 0 ;
28415 PyObject * obj1 = 0 ;
28416 char * kwnames[] = {
28417 (char *) "self",(char *) "other", NULL
28418 };
28419
28420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
28421 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28422 if (!SWIG_IsOK(res1)) {
28423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ne__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28424 }
28425 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28426 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28427 if (!SWIG_IsOK(res2)) {
28428 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ne__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28429 }
28430 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28431 {
28432 PyThreadState* __tstate = wxPyBeginAllowThreads();
28433 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
28434 wxPyEndAllowThreads(__tstate);
28435 if (PyErr_Occurred()) SWIG_fail;
28436 }
28437 {
28438 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28439 }
28440 return resultobj;
28441 fail:
28442 return NULL;
28443 }
28444
28445
28446 SWIGINTERN PyObject *_wrap_TimeSpan_IsNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28447 PyObject *resultobj = 0;
28448 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28449 bool result;
28450 void *argp1 = 0 ;
28451 int res1 = 0 ;
28452 PyObject *swig_obj[1] ;
28453
28454 if (!args) SWIG_fail;
28455 swig_obj[0] = args;
28456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28457 if (!SWIG_IsOK(res1)) {
28458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNull" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28459 }
28460 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28461 {
28462 PyThreadState* __tstate = wxPyBeginAllowThreads();
28463 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
28464 wxPyEndAllowThreads(__tstate);
28465 if (PyErr_Occurred()) SWIG_fail;
28466 }
28467 {
28468 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28469 }
28470 return resultobj;
28471 fail:
28472 return NULL;
28473 }
28474
28475
28476 SWIGINTERN PyObject *_wrap_TimeSpan_IsPositive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28477 PyObject *resultobj = 0;
28478 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28479 bool result;
28480 void *argp1 = 0 ;
28481 int res1 = 0 ;
28482 PyObject *swig_obj[1] ;
28483
28484 if (!args) SWIG_fail;
28485 swig_obj[0] = args;
28486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28487 if (!SWIG_IsOK(res1)) {
28488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsPositive" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28489 }
28490 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28491 {
28492 PyThreadState* __tstate = wxPyBeginAllowThreads();
28493 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
28494 wxPyEndAllowThreads(__tstate);
28495 if (PyErr_Occurred()) SWIG_fail;
28496 }
28497 {
28498 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28499 }
28500 return resultobj;
28501 fail:
28502 return NULL;
28503 }
28504
28505
28506 SWIGINTERN PyObject *_wrap_TimeSpan_IsNegative(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28507 PyObject *resultobj = 0;
28508 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28509 bool result;
28510 void *argp1 = 0 ;
28511 int res1 = 0 ;
28512 PyObject *swig_obj[1] ;
28513
28514 if (!args) SWIG_fail;
28515 swig_obj[0] = args;
28516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28517 if (!SWIG_IsOK(res1)) {
28518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNegative" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28519 }
28520 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28521 {
28522 PyThreadState* __tstate = wxPyBeginAllowThreads();
28523 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
28524 wxPyEndAllowThreads(__tstate);
28525 if (PyErr_Occurred()) SWIG_fail;
28526 }
28527 {
28528 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28529 }
28530 return resultobj;
28531 fail:
28532 return NULL;
28533 }
28534
28535
28536 SWIGINTERN PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28537 PyObject *resultobj = 0;
28538 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28539 wxTimeSpan *arg2 = 0 ;
28540 bool result;
28541 void *argp1 = 0 ;
28542 int res1 = 0 ;
28543 void *argp2 = 0 ;
28544 int res2 = 0 ;
28545 PyObject * obj0 = 0 ;
28546 PyObject * obj1 = 0 ;
28547 char * kwnames[] = {
28548 (char *) "self",(char *) "ts", NULL
28549 };
28550
28551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
28552 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28553 if (!SWIG_IsOK(res1)) {
28554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28555 }
28556 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28557 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28558 if (!SWIG_IsOK(res2)) {
28559 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28560 }
28561 if (!argp2) {
28562 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28563 }
28564 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28565 {
28566 PyThreadState* __tstate = wxPyBeginAllowThreads();
28567 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
28568 wxPyEndAllowThreads(__tstate);
28569 if (PyErr_Occurred()) SWIG_fail;
28570 }
28571 {
28572 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28573 }
28574 return resultobj;
28575 fail:
28576 return NULL;
28577 }
28578
28579
28580 SWIGINTERN PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28581 PyObject *resultobj = 0;
28582 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28583 wxTimeSpan *arg2 = 0 ;
28584 bool result;
28585 void *argp1 = 0 ;
28586 int res1 = 0 ;
28587 void *argp2 = 0 ;
28588 int res2 = 0 ;
28589 PyObject * obj0 = 0 ;
28590 PyObject * obj1 = 0 ;
28591 char * kwnames[] = {
28592 (char *) "self",(char *) "ts", NULL
28593 };
28594
28595 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) SWIG_fail;
28596 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28597 if (!SWIG_IsOK(res1)) {
28598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28599 }
28600 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28601 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28602 if (!SWIG_IsOK(res2)) {
28603 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28604 }
28605 if (!argp2) {
28606 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28607 }
28608 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28609 {
28610 PyThreadState* __tstate = wxPyBeginAllowThreads();
28611 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
28612 wxPyEndAllowThreads(__tstate);
28613 if (PyErr_Occurred()) SWIG_fail;
28614 }
28615 {
28616 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28617 }
28618 return resultobj;
28619 fail:
28620 return NULL;
28621 }
28622
28623
28624 SWIGINTERN PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28625 PyObject *resultobj = 0;
28626 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28627 wxTimeSpan *arg2 = 0 ;
28628 bool result;
28629 void *argp1 = 0 ;
28630 int res1 = 0 ;
28631 void *argp2 = 0 ;
28632 int res2 = 0 ;
28633 PyObject * obj0 = 0 ;
28634 PyObject * obj1 = 0 ;
28635 char * kwnames[] = {
28636 (char *) "self",(char *) "t", NULL
28637 };
28638
28639 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) SWIG_fail;
28640 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28641 if (!SWIG_IsOK(res1)) {
28642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28643 }
28644 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28645 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28646 if (!SWIG_IsOK(res2)) {
28647 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28648 }
28649 if (!argp2) {
28650 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28651 }
28652 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28653 {
28654 PyThreadState* __tstate = wxPyBeginAllowThreads();
28655 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
28656 wxPyEndAllowThreads(__tstate);
28657 if (PyErr_Occurred()) SWIG_fail;
28658 }
28659 {
28660 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28661 }
28662 return resultobj;
28663 fail:
28664 return NULL;
28665 }
28666
28667
28668 SWIGINTERN PyObject *_wrap_TimeSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28669 PyObject *resultobj = 0;
28670 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28671 int result;
28672 void *argp1 = 0 ;
28673 int res1 = 0 ;
28674 PyObject *swig_obj[1] ;
28675
28676 if (!args) SWIG_fail;
28677 swig_obj[0] = args;
28678 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28679 if (!SWIG_IsOK(res1)) {
28680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetWeeks" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28681 }
28682 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28683 {
28684 PyThreadState* __tstate = wxPyBeginAllowThreads();
28685 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
28686 wxPyEndAllowThreads(__tstate);
28687 if (PyErr_Occurred()) SWIG_fail;
28688 }
28689 resultobj = SWIG_From_int(static_cast< int >(result));
28690 return resultobj;
28691 fail:
28692 return NULL;
28693 }
28694
28695
28696 SWIGINTERN PyObject *_wrap_TimeSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28697 PyObject *resultobj = 0;
28698 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28699 int result;
28700 void *argp1 = 0 ;
28701 int res1 = 0 ;
28702 PyObject *swig_obj[1] ;
28703
28704 if (!args) SWIG_fail;
28705 swig_obj[0] = args;
28706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28707 if (!SWIG_IsOK(res1)) {
28708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetDays" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28709 }
28710 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28711 {
28712 PyThreadState* __tstate = wxPyBeginAllowThreads();
28713 result = (int)((wxTimeSpan const *)arg1)->GetDays();
28714 wxPyEndAllowThreads(__tstate);
28715 if (PyErr_Occurred()) SWIG_fail;
28716 }
28717 resultobj = SWIG_From_int(static_cast< int >(result));
28718 return resultobj;
28719 fail:
28720 return NULL;
28721 }
28722
28723
28724 SWIGINTERN PyObject *_wrap_TimeSpan_GetHours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28725 PyObject *resultobj = 0;
28726 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28727 int result;
28728 void *argp1 = 0 ;
28729 int res1 = 0 ;
28730 PyObject *swig_obj[1] ;
28731
28732 if (!args) SWIG_fail;
28733 swig_obj[0] = args;
28734 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28735 if (!SWIG_IsOK(res1)) {
28736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetHours" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28737 }
28738 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28739 {
28740 PyThreadState* __tstate = wxPyBeginAllowThreads();
28741 result = (int)((wxTimeSpan const *)arg1)->GetHours();
28742 wxPyEndAllowThreads(__tstate);
28743 if (PyErr_Occurred()) SWIG_fail;
28744 }
28745 resultobj = SWIG_From_int(static_cast< int >(result));
28746 return resultobj;
28747 fail:
28748 return NULL;
28749 }
28750
28751
28752 SWIGINTERN PyObject *_wrap_TimeSpan_GetMinutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28753 PyObject *resultobj = 0;
28754 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28755 int result;
28756 void *argp1 = 0 ;
28757 int res1 = 0 ;
28758 PyObject *swig_obj[1] ;
28759
28760 if (!args) SWIG_fail;
28761 swig_obj[0] = args;
28762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28763 if (!SWIG_IsOK(res1)) {
28764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMinutes" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28765 }
28766 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28767 {
28768 PyThreadState* __tstate = wxPyBeginAllowThreads();
28769 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
28770 wxPyEndAllowThreads(__tstate);
28771 if (PyErr_Occurred()) SWIG_fail;
28772 }
28773 resultobj = SWIG_From_int(static_cast< int >(result));
28774 return resultobj;
28775 fail:
28776 return NULL;
28777 }
28778
28779
28780 SWIGINTERN PyObject *_wrap_TimeSpan_GetSeconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28781 PyObject *resultobj = 0;
28782 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28783 wxLongLong result;
28784 void *argp1 = 0 ;
28785 int res1 = 0 ;
28786 PyObject *swig_obj[1] ;
28787
28788 if (!args) SWIG_fail;
28789 swig_obj[0] = args;
28790 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28791 if (!SWIG_IsOK(res1)) {
28792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetSeconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28793 }
28794 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28795 {
28796 PyThreadState* __tstate = wxPyBeginAllowThreads();
28797 result = ((wxTimeSpan const *)arg1)->GetSeconds();
28798 wxPyEndAllowThreads(__tstate);
28799 if (PyErr_Occurred()) SWIG_fail;
28800 }
28801 {
28802 PyObject *hi, *lo, *shifter, *shifted;
28803 hi = PyLong_FromLong( (&result)->GetHi() );
28804 lo = PyLong_FromLong( (&result)->GetLo() );
28805 shifter = PyLong_FromLong(32);
28806 shifted = PyNumber_Lshift(hi, shifter);
28807 resultobj = PyNumber_Or(shifted, lo);
28808 Py_DECREF(hi);
28809 Py_DECREF(lo);
28810 Py_DECREF(shifter);
28811 Py_DECREF(shifted);
28812 }
28813 return resultobj;
28814 fail:
28815 return NULL;
28816 }
28817
28818
28819 SWIGINTERN PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28820 PyObject *resultobj = 0;
28821 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28822 wxLongLong result;
28823 void *argp1 = 0 ;
28824 int res1 = 0 ;
28825 PyObject *swig_obj[1] ;
28826
28827 if (!args) SWIG_fail;
28828 swig_obj[0] = args;
28829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28830 if (!SWIG_IsOK(res1)) {
28831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMilliseconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28832 }
28833 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28834 {
28835 PyThreadState* __tstate = wxPyBeginAllowThreads();
28836 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
28837 wxPyEndAllowThreads(__tstate);
28838 if (PyErr_Occurred()) SWIG_fail;
28839 }
28840 {
28841 PyObject *hi, *lo, *shifter, *shifted;
28842 hi = PyLong_FromLong( (&result)->GetHi() );
28843 lo = PyLong_FromLong( (&result)->GetLo() );
28844 shifter = PyLong_FromLong(32);
28845 shifted = PyNumber_Lshift(hi, shifter);
28846 resultobj = PyNumber_Or(shifted, lo);
28847 Py_DECREF(hi);
28848 Py_DECREF(lo);
28849 Py_DECREF(shifter);
28850 Py_DECREF(shifted);
28851 }
28852 return resultobj;
28853 fail:
28854 return NULL;
28855 }
28856
28857
28858 SWIGINTERN PyObject *_wrap_TimeSpan_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28859 PyObject *resultobj = 0;
28860 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28861 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
28862 wxString *arg2 = (wxString *) &arg2_defvalue ;
28863 wxString result;
28864 void *argp1 = 0 ;
28865 int res1 = 0 ;
28866 bool temp2 = false ;
28867 PyObject * obj0 = 0 ;
28868 PyObject * obj1 = 0 ;
28869 char * kwnames[] = {
28870 (char *) "self",(char *) "format", NULL
28871 };
28872
28873 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) SWIG_fail;
28874 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28875 if (!SWIG_IsOK(res1)) {
28876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Format" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28877 }
28878 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28879 if (obj1) {
28880 {
28881 arg2 = wxString_in_helper(obj1);
28882 if (arg2 == NULL) SWIG_fail;
28883 temp2 = true;
28884 }
28885 }
28886 {
28887 PyThreadState* __tstate = wxPyBeginAllowThreads();
28888 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
28889 wxPyEndAllowThreads(__tstate);
28890 if (PyErr_Occurred()) SWIG_fail;
28891 }
28892 {
28893 #if wxUSE_UNICODE
28894 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28895 #else
28896 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28897 #endif
28898 }
28899 {
28900 if (temp2)
28901 delete arg2;
28902 }
28903 return resultobj;
28904 fail:
28905 {
28906 if (temp2)
28907 delete arg2;
28908 }
28909 return NULL;
28910 }
28911
28912
28913 SWIGINTERN PyObject *TimeSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28914 PyObject *obj;
28915 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28916 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimeSpan, SWIG_NewClientData(obj));
28917 return SWIG_Py_Void();
28918 }
28919
28920 SWIGINTERN PyObject *TimeSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28921 return SWIG_Python_InitShadowInstance(args);
28922 }
28923
28924 SWIGINTERN PyObject *_wrap_new_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28925 PyObject *resultobj = 0;
28926 int arg1 = (int) 0 ;
28927 int arg2 = (int) 0 ;
28928 int arg3 = (int) 0 ;
28929 int arg4 = (int) 0 ;
28930 wxDateSpan *result = 0 ;
28931 int val1 ;
28932 int ecode1 = 0 ;
28933 int val2 ;
28934 int ecode2 = 0 ;
28935 int val3 ;
28936 int ecode3 = 0 ;
28937 int val4 ;
28938 int ecode4 = 0 ;
28939 PyObject * obj0 = 0 ;
28940 PyObject * obj1 = 0 ;
28941 PyObject * obj2 = 0 ;
28942 PyObject * obj3 = 0 ;
28943 char * kwnames[] = {
28944 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
28945 };
28946
28947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28948 if (obj0) {
28949 ecode1 = SWIG_AsVal_int(obj0, &val1);
28950 if (!SWIG_IsOK(ecode1)) {
28951 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateSpan" "', expected argument " "1"" of type '" "int""'");
28952 }
28953 arg1 = static_cast< int >(val1);
28954 }
28955 if (obj1) {
28956 ecode2 = SWIG_AsVal_int(obj1, &val2);
28957 if (!SWIG_IsOK(ecode2)) {
28958 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateSpan" "', expected argument " "2"" of type '" "int""'");
28959 }
28960 arg2 = static_cast< int >(val2);
28961 }
28962 if (obj2) {
28963 ecode3 = SWIG_AsVal_int(obj2, &val3);
28964 if (!SWIG_IsOK(ecode3)) {
28965 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateSpan" "', expected argument " "3"" of type '" "int""'");
28966 }
28967 arg3 = static_cast< int >(val3);
28968 }
28969 if (obj3) {
28970 ecode4 = SWIG_AsVal_int(obj3, &val4);
28971 if (!SWIG_IsOK(ecode4)) {
28972 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateSpan" "', expected argument " "4"" of type '" "int""'");
28973 }
28974 arg4 = static_cast< int >(val4);
28975 }
28976 {
28977 PyThreadState* __tstate = wxPyBeginAllowThreads();
28978 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
28979 wxPyEndAllowThreads(__tstate);
28980 if (PyErr_Occurred()) SWIG_fail;
28981 }
28982 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_NEW | 0 );
28983 return resultobj;
28984 fail:
28985 return NULL;
28986 }
28987
28988
28989 SWIGINTERN PyObject *_wrap_delete_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28990 PyObject *resultobj = 0;
28991 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
28992 void *argp1 = 0 ;
28993 int res1 = 0 ;
28994 PyObject *swig_obj[1] ;
28995
28996 if (!args) SWIG_fail;
28997 swig_obj[0] = args;
28998 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
28999 if (!SWIG_IsOK(res1)) {
29000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateSpan" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29001 }
29002 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29003 {
29004 PyThreadState* __tstate = wxPyBeginAllowThreads();
29005 delete arg1;
29006
29007 wxPyEndAllowThreads(__tstate);
29008 if (PyErr_Occurred()) SWIG_fail;
29009 }
29010 resultobj = SWIG_Py_Void();
29011 return resultobj;
29012 fail:
29013 return NULL;
29014 }
29015
29016
29017 SWIGINTERN PyObject *_wrap_DateSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29018 PyObject *resultobj = 0;
29019 int arg1 ;
29020 wxDateSpan result;
29021 int val1 ;
29022 int ecode1 = 0 ;
29023 PyObject * obj0 = 0 ;
29024 char * kwnames[] = {
29025 (char *) "days", NULL
29026 };
29027
29028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) SWIG_fail;
29029 ecode1 = SWIG_AsVal_int(obj0, &val1);
29030 if (!SWIG_IsOK(ecode1)) {
29031 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Days" "', expected argument " "1"" of type '" "int""'");
29032 }
29033 arg1 = static_cast< int >(val1);
29034 {
29035 PyThreadState* __tstate = wxPyBeginAllowThreads();
29036 result = wxDateSpan::Days(arg1);
29037 wxPyEndAllowThreads(__tstate);
29038 if (PyErr_Occurred()) SWIG_fail;
29039 }
29040 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29041 return resultobj;
29042 fail:
29043 return NULL;
29044 }
29045
29046
29047 SWIGINTERN PyObject *_wrap_DateSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29048 PyObject *resultobj = 0;
29049 wxDateSpan result;
29050
29051 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Day",0,0,0)) SWIG_fail;
29052 {
29053 PyThreadState* __tstate = wxPyBeginAllowThreads();
29054 result = wxDateSpan::Day();
29055 wxPyEndAllowThreads(__tstate);
29056 if (PyErr_Occurred()) SWIG_fail;
29057 }
29058 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29059 return resultobj;
29060 fail:
29061 return NULL;
29062 }
29063
29064
29065 SWIGINTERN PyObject *_wrap_DateSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29066 PyObject *resultobj = 0;
29067 int arg1 ;
29068 wxDateSpan result;
29069 int val1 ;
29070 int ecode1 = 0 ;
29071 PyObject * obj0 = 0 ;
29072 char * kwnames[] = {
29073 (char *) "weeks", NULL
29074 };
29075
29076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) SWIG_fail;
29077 ecode1 = SWIG_AsVal_int(obj0, &val1);
29078 if (!SWIG_IsOK(ecode1)) {
29079 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Weeks" "', expected argument " "1"" of type '" "int""'");
29080 }
29081 arg1 = static_cast< int >(val1);
29082 {
29083 PyThreadState* __tstate = wxPyBeginAllowThreads();
29084 result = wxDateSpan::Weeks(arg1);
29085 wxPyEndAllowThreads(__tstate);
29086 if (PyErr_Occurred()) SWIG_fail;
29087 }
29088 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29089 return resultobj;
29090 fail:
29091 return NULL;
29092 }
29093
29094
29095 SWIGINTERN PyObject *_wrap_DateSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29096 PyObject *resultobj = 0;
29097 wxDateSpan result;
29098
29099 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Week",0,0,0)) SWIG_fail;
29100 {
29101 PyThreadState* __tstate = wxPyBeginAllowThreads();
29102 result = wxDateSpan::Week();
29103 wxPyEndAllowThreads(__tstate);
29104 if (PyErr_Occurred()) SWIG_fail;
29105 }
29106 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29107 return resultobj;
29108 fail:
29109 return NULL;
29110 }
29111
29112
29113 SWIGINTERN PyObject *_wrap_DateSpan_Months(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29114 PyObject *resultobj = 0;
29115 int arg1 ;
29116 wxDateSpan result;
29117 int val1 ;
29118 int ecode1 = 0 ;
29119 PyObject * obj0 = 0 ;
29120 char * kwnames[] = {
29121 (char *) "mon", NULL
29122 };
29123
29124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) SWIG_fail;
29125 ecode1 = SWIG_AsVal_int(obj0, &val1);
29126 if (!SWIG_IsOK(ecode1)) {
29127 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Months" "', expected argument " "1"" of type '" "int""'");
29128 }
29129 arg1 = static_cast< int >(val1);
29130 {
29131 PyThreadState* __tstate = wxPyBeginAllowThreads();
29132 result = wxDateSpan::Months(arg1);
29133 wxPyEndAllowThreads(__tstate);
29134 if (PyErr_Occurred()) SWIG_fail;
29135 }
29136 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29137 return resultobj;
29138 fail:
29139 return NULL;
29140 }
29141
29142
29143 SWIGINTERN PyObject *_wrap_DateSpan_Month(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29144 PyObject *resultobj = 0;
29145 wxDateSpan result;
29146
29147 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Month",0,0,0)) SWIG_fail;
29148 {
29149 PyThreadState* __tstate = wxPyBeginAllowThreads();
29150 result = wxDateSpan::Month();
29151 wxPyEndAllowThreads(__tstate);
29152 if (PyErr_Occurred()) SWIG_fail;
29153 }
29154 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29155 return resultobj;
29156 fail:
29157 return NULL;
29158 }
29159
29160
29161 SWIGINTERN PyObject *_wrap_DateSpan_Years(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29162 PyObject *resultobj = 0;
29163 int arg1 ;
29164 wxDateSpan result;
29165 int val1 ;
29166 int ecode1 = 0 ;
29167 PyObject * obj0 = 0 ;
29168 char * kwnames[] = {
29169 (char *) "years", NULL
29170 };
29171
29172 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) SWIG_fail;
29173 ecode1 = SWIG_AsVal_int(obj0, &val1);
29174 if (!SWIG_IsOK(ecode1)) {
29175 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Years" "', expected argument " "1"" of type '" "int""'");
29176 }
29177 arg1 = static_cast< int >(val1);
29178 {
29179 PyThreadState* __tstate = wxPyBeginAllowThreads();
29180 result = wxDateSpan::Years(arg1);
29181 wxPyEndAllowThreads(__tstate);
29182 if (PyErr_Occurred()) SWIG_fail;
29183 }
29184 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29185 return resultobj;
29186 fail:
29187 return NULL;
29188 }
29189
29190
29191 SWIGINTERN PyObject *_wrap_DateSpan_Year(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29192 PyObject *resultobj = 0;
29193 wxDateSpan result;
29194
29195 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Year",0,0,0)) SWIG_fail;
29196 {
29197 PyThreadState* __tstate = wxPyBeginAllowThreads();
29198 result = wxDateSpan::Year();
29199 wxPyEndAllowThreads(__tstate);
29200 if (PyErr_Occurred()) SWIG_fail;
29201 }
29202 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29203 return resultobj;
29204 fail:
29205 return NULL;
29206 }
29207
29208
29209 SWIGINTERN PyObject *_wrap_DateSpan_SetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29210 PyObject *resultobj = 0;
29211 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29212 int arg2 ;
29213 wxDateSpan *result = 0 ;
29214 void *argp1 = 0 ;
29215 int res1 = 0 ;
29216 int val2 ;
29217 int ecode2 = 0 ;
29218 PyObject * obj0 = 0 ;
29219 PyObject * obj1 = 0 ;
29220 char * kwnames[] = {
29221 (char *) "self",(char *) "n", NULL
29222 };
29223
29224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) SWIG_fail;
29225 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29226 if (!SWIG_IsOK(res1)) {
29227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetYears" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29228 }
29229 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29230 ecode2 = SWIG_AsVal_int(obj1, &val2);
29231 if (!SWIG_IsOK(ecode2)) {
29232 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetYears" "', expected argument " "2"" of type '" "int""'");
29233 }
29234 arg2 = static_cast< int >(val2);
29235 {
29236 PyThreadState* __tstate = wxPyBeginAllowThreads();
29237 {
29238 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
29239 result = (wxDateSpan *) &_result_ref;
29240 }
29241 wxPyEndAllowThreads(__tstate);
29242 if (PyErr_Occurred()) SWIG_fail;
29243 }
29244 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29245 return resultobj;
29246 fail:
29247 return NULL;
29248 }
29249
29250
29251 SWIGINTERN PyObject *_wrap_DateSpan_SetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29252 PyObject *resultobj = 0;
29253 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29254 int arg2 ;
29255 wxDateSpan *result = 0 ;
29256 void *argp1 = 0 ;
29257 int res1 = 0 ;
29258 int val2 ;
29259 int ecode2 = 0 ;
29260 PyObject * obj0 = 0 ;
29261 PyObject * obj1 = 0 ;
29262 char * kwnames[] = {
29263 (char *) "self",(char *) "n", NULL
29264 };
29265
29266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) SWIG_fail;
29267 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29268 if (!SWIG_IsOK(res1)) {
29269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetMonths" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29270 }
29271 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29272 ecode2 = SWIG_AsVal_int(obj1, &val2);
29273 if (!SWIG_IsOK(ecode2)) {
29274 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetMonths" "', expected argument " "2"" of type '" "int""'");
29275 }
29276 arg2 = static_cast< int >(val2);
29277 {
29278 PyThreadState* __tstate = wxPyBeginAllowThreads();
29279 {
29280 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
29281 result = (wxDateSpan *) &_result_ref;
29282 }
29283 wxPyEndAllowThreads(__tstate);
29284 if (PyErr_Occurred()) SWIG_fail;
29285 }
29286 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29287 return resultobj;
29288 fail:
29289 return NULL;
29290 }
29291
29292
29293 SWIGINTERN PyObject *_wrap_DateSpan_SetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29294 PyObject *resultobj = 0;
29295 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29296 int arg2 ;
29297 wxDateSpan *result = 0 ;
29298 void *argp1 = 0 ;
29299 int res1 = 0 ;
29300 int val2 ;
29301 int ecode2 = 0 ;
29302 PyObject * obj0 = 0 ;
29303 PyObject * obj1 = 0 ;
29304 char * kwnames[] = {
29305 (char *) "self",(char *) "n", NULL
29306 };
29307
29308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) SWIG_fail;
29309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29310 if (!SWIG_IsOK(res1)) {
29311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetWeeks" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29312 }
29313 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29314 ecode2 = SWIG_AsVal_int(obj1, &val2);
29315 if (!SWIG_IsOK(ecode2)) {
29316 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetWeeks" "', expected argument " "2"" of type '" "int""'");
29317 }
29318 arg2 = static_cast< int >(val2);
29319 {
29320 PyThreadState* __tstate = wxPyBeginAllowThreads();
29321 {
29322 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
29323 result = (wxDateSpan *) &_result_ref;
29324 }
29325 wxPyEndAllowThreads(__tstate);
29326 if (PyErr_Occurred()) SWIG_fail;
29327 }
29328 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29329 return resultobj;
29330 fail:
29331 return NULL;
29332 }
29333
29334
29335 SWIGINTERN PyObject *_wrap_DateSpan_SetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29336 PyObject *resultobj = 0;
29337 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29338 int arg2 ;
29339 wxDateSpan *result = 0 ;
29340 void *argp1 = 0 ;
29341 int res1 = 0 ;
29342 int val2 ;
29343 int ecode2 = 0 ;
29344 PyObject * obj0 = 0 ;
29345 PyObject * obj1 = 0 ;
29346 char * kwnames[] = {
29347 (char *) "self",(char *) "n", NULL
29348 };
29349
29350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) SWIG_fail;
29351 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29352 if (!SWIG_IsOK(res1)) {
29353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetDays" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29354 }
29355 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29356 ecode2 = SWIG_AsVal_int(obj1, &val2);
29357 if (!SWIG_IsOK(ecode2)) {
29358 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetDays" "', expected argument " "2"" of type '" "int""'");
29359 }
29360 arg2 = static_cast< int >(val2);
29361 {
29362 PyThreadState* __tstate = wxPyBeginAllowThreads();
29363 {
29364 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
29365 result = (wxDateSpan *) &_result_ref;
29366 }
29367 wxPyEndAllowThreads(__tstate);
29368 if (PyErr_Occurred()) SWIG_fail;
29369 }
29370 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29371 return resultobj;
29372 fail:
29373 return NULL;
29374 }
29375
29376
29377 SWIGINTERN PyObject *_wrap_DateSpan_GetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29378 PyObject *resultobj = 0;
29379 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29380 int result;
29381 void *argp1 = 0 ;
29382 int res1 = 0 ;
29383 PyObject *swig_obj[1] ;
29384
29385 if (!args) SWIG_fail;
29386 swig_obj[0] = args;
29387 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29388 if (!SWIG_IsOK(res1)) {
29389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetYears" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29390 }
29391 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29392 {
29393 PyThreadState* __tstate = wxPyBeginAllowThreads();
29394 result = (int)((wxDateSpan const *)arg1)->GetYears();
29395 wxPyEndAllowThreads(__tstate);
29396 if (PyErr_Occurred()) SWIG_fail;
29397 }
29398 resultobj = SWIG_From_int(static_cast< int >(result));
29399 return resultobj;
29400 fail:
29401 return NULL;
29402 }
29403
29404
29405 SWIGINTERN PyObject *_wrap_DateSpan_GetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29406 PyObject *resultobj = 0;
29407 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29408 int result;
29409 void *argp1 = 0 ;
29410 int res1 = 0 ;
29411 PyObject *swig_obj[1] ;
29412
29413 if (!args) SWIG_fail;
29414 swig_obj[0] = args;
29415 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29416 if (!SWIG_IsOK(res1)) {
29417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetMonths" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29418 }
29419 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29420 {
29421 PyThreadState* __tstate = wxPyBeginAllowThreads();
29422 result = (int)((wxDateSpan const *)arg1)->GetMonths();
29423 wxPyEndAllowThreads(__tstate);
29424 if (PyErr_Occurred()) SWIG_fail;
29425 }
29426 resultobj = SWIG_From_int(static_cast< int >(result));
29427 return resultobj;
29428 fail:
29429 return NULL;
29430 }
29431
29432
29433 SWIGINTERN PyObject *_wrap_DateSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29434 PyObject *resultobj = 0;
29435 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29436 int result;
29437 void *argp1 = 0 ;
29438 int res1 = 0 ;
29439 PyObject *swig_obj[1] ;
29440
29441 if (!args) SWIG_fail;
29442 swig_obj[0] = args;
29443 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29444 if (!SWIG_IsOK(res1)) {
29445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetWeeks" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29446 }
29447 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29448 {
29449 PyThreadState* __tstate = wxPyBeginAllowThreads();
29450 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
29451 wxPyEndAllowThreads(__tstate);
29452 if (PyErr_Occurred()) SWIG_fail;
29453 }
29454 resultobj = SWIG_From_int(static_cast< int >(result));
29455 return resultobj;
29456 fail:
29457 return NULL;
29458 }
29459
29460
29461 SWIGINTERN PyObject *_wrap_DateSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29462 PyObject *resultobj = 0;
29463 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29464 int result;
29465 void *argp1 = 0 ;
29466 int res1 = 0 ;
29467 PyObject *swig_obj[1] ;
29468
29469 if (!args) SWIG_fail;
29470 swig_obj[0] = args;
29471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29472 if (!SWIG_IsOK(res1)) {
29473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29474 }
29475 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29476 {
29477 PyThreadState* __tstate = wxPyBeginAllowThreads();
29478 result = (int)((wxDateSpan const *)arg1)->GetDays();
29479 wxPyEndAllowThreads(__tstate);
29480 if (PyErr_Occurred()) SWIG_fail;
29481 }
29482 resultobj = SWIG_From_int(static_cast< int >(result));
29483 return resultobj;
29484 fail:
29485 return NULL;
29486 }
29487
29488
29489 SWIGINTERN PyObject *_wrap_DateSpan_GetTotalDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29490 PyObject *resultobj = 0;
29491 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29492 int result;
29493 void *argp1 = 0 ;
29494 int res1 = 0 ;
29495 PyObject *swig_obj[1] ;
29496
29497 if (!args) SWIG_fail;
29498 swig_obj[0] = args;
29499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29500 if (!SWIG_IsOK(res1)) {
29501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetTotalDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29502 }
29503 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29504 {
29505 PyThreadState* __tstate = wxPyBeginAllowThreads();
29506 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
29507 wxPyEndAllowThreads(__tstate);
29508 if (PyErr_Occurred()) SWIG_fail;
29509 }
29510 resultobj = SWIG_From_int(static_cast< int >(result));
29511 return resultobj;
29512 fail:
29513 return NULL;
29514 }
29515
29516
29517 SWIGINTERN PyObject *_wrap_DateSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29518 PyObject *resultobj = 0;
29519 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29520 wxDateSpan *arg2 = 0 ;
29521 wxDateSpan *result = 0 ;
29522 void *argp1 = 0 ;
29523 int res1 = 0 ;
29524 void *argp2 = 0 ;
29525 int res2 = 0 ;
29526 PyObject * obj0 = 0 ;
29527 PyObject * obj1 = 0 ;
29528 char * kwnames[] = {
29529 (char *) "self",(char *) "other", NULL
29530 };
29531
29532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
29533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29534 if (!SWIG_IsOK(res1)) {
29535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Add" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29536 }
29537 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29538 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29539 if (!SWIG_IsOK(res2)) {
29540 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29541 }
29542 if (!argp2) {
29543 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29544 }
29545 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29546 {
29547 PyThreadState* __tstate = wxPyBeginAllowThreads();
29548 {
29549 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
29550 result = (wxDateSpan *) &_result_ref;
29551 }
29552 wxPyEndAllowThreads(__tstate);
29553 if (PyErr_Occurred()) SWIG_fail;
29554 }
29555 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29556 return resultobj;
29557 fail:
29558 return NULL;
29559 }
29560
29561
29562 SWIGINTERN PyObject *_wrap_DateSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29563 PyObject *resultobj = 0;
29564 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29565 wxDateSpan *arg2 = 0 ;
29566 wxDateSpan *result = 0 ;
29567 void *argp1 = 0 ;
29568 int res1 = 0 ;
29569 void *argp2 = 0 ;
29570 int res2 = 0 ;
29571 PyObject * obj0 = 0 ;
29572 PyObject * obj1 = 0 ;
29573 char * kwnames[] = {
29574 (char *) "self",(char *) "other", NULL
29575 };
29576
29577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
29578 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29579 if (!SWIG_IsOK(res1)) {
29580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Subtract" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29581 }
29582 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29583 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29584 if (!SWIG_IsOK(res2)) {
29585 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29586 }
29587 if (!argp2) {
29588 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29589 }
29590 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29591 {
29592 PyThreadState* __tstate = wxPyBeginAllowThreads();
29593 {
29594 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
29595 result = (wxDateSpan *) &_result_ref;
29596 }
29597 wxPyEndAllowThreads(__tstate);
29598 if (PyErr_Occurred()) SWIG_fail;
29599 }
29600 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29601 return resultobj;
29602 fail:
29603 return NULL;
29604 }
29605
29606
29607 SWIGINTERN PyObject *_wrap_DateSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29608 PyObject *resultobj = 0;
29609 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29610 wxDateSpan *result = 0 ;
29611 void *argp1 = 0 ;
29612 int res1 = 0 ;
29613 PyObject *swig_obj[1] ;
29614
29615 if (!args) SWIG_fail;
29616 swig_obj[0] = args;
29617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29618 if (!SWIG_IsOK(res1)) {
29619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Neg" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29620 }
29621 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29622 {
29623 PyThreadState* __tstate = wxPyBeginAllowThreads();
29624 {
29625 wxDateSpan &_result_ref = (arg1)->Neg();
29626 result = (wxDateSpan *) &_result_ref;
29627 }
29628 wxPyEndAllowThreads(__tstate);
29629 if (PyErr_Occurred()) SWIG_fail;
29630 }
29631 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29632 return resultobj;
29633 fail:
29634 return NULL;
29635 }
29636
29637
29638 SWIGINTERN PyObject *_wrap_DateSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29639 PyObject *resultobj = 0;
29640 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29641 int arg2 ;
29642 wxDateSpan *result = 0 ;
29643 void *argp1 = 0 ;
29644 int res1 = 0 ;
29645 int val2 ;
29646 int ecode2 = 0 ;
29647 PyObject * obj0 = 0 ;
29648 PyObject * obj1 = 0 ;
29649 char * kwnames[] = {
29650 (char *) "self",(char *) "factor", NULL
29651 };
29652
29653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
29654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29655 if (!SWIG_IsOK(res1)) {
29656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Multiply" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29657 }
29658 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29659 ecode2 = SWIG_AsVal_int(obj1, &val2);
29660 if (!SWIG_IsOK(ecode2)) {
29661 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
29662 }
29663 arg2 = static_cast< int >(val2);
29664 {
29665 PyThreadState* __tstate = wxPyBeginAllowThreads();
29666 {
29667 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
29668 result = (wxDateSpan *) &_result_ref;
29669 }
29670 wxPyEndAllowThreads(__tstate);
29671 if (PyErr_Occurred()) SWIG_fail;
29672 }
29673 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29674 return resultobj;
29675 fail:
29676 return NULL;
29677 }
29678
29679
29680 SWIGINTERN PyObject *_wrap_DateSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29681 PyObject *resultobj = 0;
29682 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29683 wxDateSpan *arg2 = 0 ;
29684 wxDateSpan *result = 0 ;
29685 void *argp1 = 0 ;
29686 int res1 = 0 ;
29687 void *argp2 = 0 ;
29688 int res2 = 0 ;
29689 PyObject * obj0 = 0 ;
29690 PyObject * obj1 = 0 ;
29691 char * kwnames[] = {
29692 (char *) "self",(char *) "other", NULL
29693 };
29694
29695 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
29696 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
29697 if (!SWIG_IsOK(res1)) {
29698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___iadd__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29699 }
29700 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29701 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29702 if (!SWIG_IsOK(res2)) {
29703 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29704 }
29705 if (!argp2) {
29706 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29707 }
29708 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29709 {
29710 PyThreadState* __tstate = wxPyBeginAllowThreads();
29711 {
29712 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
29713 result = (wxDateSpan *) &_result_ref;
29714 }
29715 wxPyEndAllowThreads(__tstate);
29716 if (PyErr_Occurred()) SWIG_fail;
29717 }
29718 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29719 return resultobj;
29720 fail:
29721 return NULL;
29722 }
29723
29724
29725 SWIGINTERN PyObject *_wrap_DateSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29726 PyObject *resultobj = 0;
29727 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29728 wxDateSpan *arg2 = 0 ;
29729 wxDateSpan *result = 0 ;
29730 void *argp1 = 0 ;
29731 int res1 = 0 ;
29732 void *argp2 = 0 ;
29733 int res2 = 0 ;
29734 PyObject * obj0 = 0 ;
29735 PyObject * obj1 = 0 ;
29736 char * kwnames[] = {
29737 (char *) "self",(char *) "other", NULL
29738 };
29739
29740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
29741 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
29742 if (!SWIG_IsOK(res1)) {
29743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___isub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29744 }
29745 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29746 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29747 if (!SWIG_IsOK(res2)) {
29748 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29749 }
29750 if (!argp2) {
29751 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29752 }
29753 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29754 {
29755 PyThreadState* __tstate = wxPyBeginAllowThreads();
29756 {
29757 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
29758 result = (wxDateSpan *) &_result_ref;
29759 }
29760 wxPyEndAllowThreads(__tstate);
29761 if (PyErr_Occurred()) SWIG_fail;
29762 }
29763 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29764 return resultobj;
29765 fail:
29766 return NULL;
29767 }
29768
29769
29770 SWIGINTERN PyObject *_wrap_DateSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29771 PyObject *resultobj = 0;
29772 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29773 wxDateSpan *result = 0 ;
29774 void *argp1 = 0 ;
29775 int res1 = 0 ;
29776 PyObject *swig_obj[1] ;
29777
29778 if (!args) SWIG_fail;
29779 swig_obj[0] = args;
29780 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29781 if (!SWIG_IsOK(res1)) {
29782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___neg__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29783 }
29784 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29785 {
29786 PyThreadState* __tstate = wxPyBeginAllowThreads();
29787 {
29788 wxDateSpan &_result_ref = (arg1)->operator -();
29789 result = (wxDateSpan *) &_result_ref;
29790 }
29791 wxPyEndAllowThreads(__tstate);
29792 if (PyErr_Occurred()) SWIG_fail;
29793 }
29794 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29795 return resultobj;
29796 fail:
29797 return NULL;
29798 }
29799
29800
29801 SWIGINTERN PyObject *_wrap_DateSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29802 PyObject *resultobj = 0;
29803 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29804 int arg2 ;
29805 wxDateSpan *result = 0 ;
29806 void *argp1 = 0 ;
29807 int res1 = 0 ;
29808 int val2 ;
29809 int ecode2 = 0 ;
29810 PyObject * obj0 = 0 ;
29811 PyObject * obj1 = 0 ;
29812 char * kwnames[] = {
29813 (char *) "self",(char *) "factor", NULL
29814 };
29815
29816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
29817 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
29818 if (!SWIG_IsOK(res1)) {
29819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___imul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29820 }
29821 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29822 ecode2 = SWIG_AsVal_int(obj1, &val2);
29823 if (!SWIG_IsOK(ecode2)) {
29824 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___imul__" "', expected argument " "2"" of type '" "int""'");
29825 }
29826 arg2 = static_cast< int >(val2);
29827 {
29828 PyThreadState* __tstate = wxPyBeginAllowThreads();
29829 {
29830 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
29831 result = (wxDateSpan *) &_result_ref;
29832 }
29833 wxPyEndAllowThreads(__tstate);
29834 if (PyErr_Occurred()) SWIG_fail;
29835 }
29836 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29837 return resultobj;
29838 fail:
29839 return NULL;
29840 }
29841
29842
29843 SWIGINTERN PyObject *_wrap_DateSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29844 PyObject *resultobj = 0;
29845 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29846 wxDateSpan *arg2 = 0 ;
29847 wxDateSpan result;
29848 void *argp1 = 0 ;
29849 int res1 = 0 ;
29850 void *argp2 = 0 ;
29851 int res2 = 0 ;
29852 PyObject * obj0 = 0 ;
29853 PyObject * obj1 = 0 ;
29854 char * kwnames[] = {
29855 (char *) "self",(char *) "other", NULL
29856 };
29857
29858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
29859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29860 if (!SWIG_IsOK(res1)) {
29861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___add__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29862 }
29863 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29864 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29865 if (!SWIG_IsOK(res2)) {
29866 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29867 }
29868 if (!argp2) {
29869 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29870 }
29871 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29872 {
29873 PyThreadState* __tstate = wxPyBeginAllowThreads();
29874 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
29875 wxPyEndAllowThreads(__tstate);
29876 if (PyErr_Occurred()) SWIG_fail;
29877 }
29878 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29879 return resultobj;
29880 fail:
29881 return NULL;
29882 }
29883
29884
29885 SWIGINTERN PyObject *_wrap_DateSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29886 PyObject *resultobj = 0;
29887 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29888 wxDateSpan *arg2 = 0 ;
29889 wxDateSpan result;
29890 void *argp1 = 0 ;
29891 int res1 = 0 ;
29892 void *argp2 = 0 ;
29893 int res2 = 0 ;
29894 PyObject * obj0 = 0 ;
29895 PyObject * obj1 = 0 ;
29896 char * kwnames[] = {
29897 (char *) "self",(char *) "other", NULL
29898 };
29899
29900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
29901 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29902 if (!SWIG_IsOK(res1)) {
29903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___sub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29904 }
29905 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29906 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29907 if (!SWIG_IsOK(res2)) {
29908 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29909 }
29910 if (!argp2) {
29911 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29912 }
29913 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29914 {
29915 PyThreadState* __tstate = wxPyBeginAllowThreads();
29916 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
29917 wxPyEndAllowThreads(__tstate);
29918 if (PyErr_Occurred()) SWIG_fail;
29919 }
29920 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29921 return resultobj;
29922 fail:
29923 return NULL;
29924 }
29925
29926
29927 SWIGINTERN PyObject *_wrap_DateSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29928 PyObject *resultobj = 0;
29929 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29930 int arg2 ;
29931 wxDateSpan result;
29932 void *argp1 = 0 ;
29933 int res1 = 0 ;
29934 int val2 ;
29935 int ecode2 = 0 ;
29936 PyObject * obj0 = 0 ;
29937 PyObject * obj1 = 0 ;
29938 char * kwnames[] = {
29939 (char *) "self",(char *) "n", NULL
29940 };
29941
29942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
29943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29944 if (!SWIG_IsOK(res1)) {
29945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___mul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29946 }
29947 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29948 ecode2 = SWIG_AsVal_int(obj1, &val2);
29949 if (!SWIG_IsOK(ecode2)) {
29950 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___mul__" "', expected argument " "2"" of type '" "int""'");
29951 }
29952 arg2 = static_cast< int >(val2);
29953 {
29954 PyThreadState* __tstate = wxPyBeginAllowThreads();
29955 result = wxDateSpan___mul__(arg1,arg2);
29956 wxPyEndAllowThreads(__tstate);
29957 if (PyErr_Occurred()) SWIG_fail;
29958 }
29959 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29960 return resultobj;
29961 fail:
29962 return NULL;
29963 }
29964
29965
29966 SWIGINTERN PyObject *_wrap_DateSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29967 PyObject *resultobj = 0;
29968 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29969 int arg2 ;
29970 wxDateSpan result;
29971 void *argp1 = 0 ;
29972 int res1 = 0 ;
29973 int val2 ;
29974 int ecode2 = 0 ;
29975 PyObject * obj0 = 0 ;
29976 PyObject * obj1 = 0 ;
29977 char * kwnames[] = {
29978 (char *) "self",(char *) "n", NULL
29979 };
29980
29981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
29982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29983 if (!SWIG_IsOK(res1)) {
29984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___rmul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29985 }
29986 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29987 ecode2 = SWIG_AsVal_int(obj1, &val2);
29988 if (!SWIG_IsOK(ecode2)) {
29989 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
29990 }
29991 arg2 = static_cast< int >(val2);
29992 {
29993 PyThreadState* __tstate = wxPyBeginAllowThreads();
29994 result = wxDateSpan___rmul__(arg1,arg2);
29995 wxPyEndAllowThreads(__tstate);
29996 if (PyErr_Occurred()) SWIG_fail;
29997 }
29998 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29999 return resultobj;
30000 fail:
30001 return NULL;
30002 }
30003
30004
30005 SWIGINTERN PyObject *_wrap_DateSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30006 PyObject *resultobj = 0;
30007 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30008 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
30009 bool result;
30010 void *argp1 = 0 ;
30011 int res1 = 0 ;
30012 void *argp2 = 0 ;
30013 int res2 = 0 ;
30014 PyObject * obj0 = 0 ;
30015 PyObject * obj1 = 0 ;
30016 char * kwnames[] = {
30017 (char *) "self",(char *) "other", NULL
30018 };
30019
30020 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
30021 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30022 if (!SWIG_IsOK(res1)) {
30023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___eq__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30024 }
30025 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30026 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30027 if (!SWIG_IsOK(res2)) {
30028 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___eq__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
30029 }
30030 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30031 {
30032 PyThreadState* __tstate = wxPyBeginAllowThreads();
30033 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
30034 wxPyEndAllowThreads(__tstate);
30035 if (PyErr_Occurred()) SWIG_fail;
30036 }
30037 {
30038 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30039 }
30040 return resultobj;
30041 fail:
30042 return NULL;
30043 }
30044
30045
30046 SWIGINTERN PyObject *_wrap_DateSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30047 PyObject *resultobj = 0;
30048 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30049 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
30050 bool result;
30051 void *argp1 = 0 ;
30052 int res1 = 0 ;
30053 void *argp2 = 0 ;
30054 int res2 = 0 ;
30055 PyObject * obj0 = 0 ;
30056 PyObject * obj1 = 0 ;
30057 char * kwnames[] = {
30058 (char *) "self",(char *) "other", NULL
30059 };
30060
30061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
30062 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30063 if (!SWIG_IsOK(res1)) {
30064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___ne__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30065 }
30066 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30067 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30068 if (!SWIG_IsOK(res2)) {
30069 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___ne__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
30070 }
30071 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30072 {
30073 PyThreadState* __tstate = wxPyBeginAllowThreads();
30074 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
30075 wxPyEndAllowThreads(__tstate);
30076 if (PyErr_Occurred()) SWIG_fail;
30077 }
30078 {
30079 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30080 }
30081 return resultobj;
30082 fail:
30083 return NULL;
30084 }
30085
30086
30087 SWIGINTERN PyObject *DateSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30088 PyObject *obj;
30089 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30090 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateSpan, SWIG_NewClientData(obj));
30091 return SWIG_Py_Void();
30092 }
30093
30094 SWIGINTERN PyObject *DateSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30095 return SWIG_Python_InitShadowInstance(args);
30096 }
30097
30098 SWIGINTERN PyObject *_wrap_GetLocalTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30099 PyObject *resultobj = 0;
30100 long result;
30101
30102 if (!SWIG_Python_UnpackTuple(args,"GetLocalTime",0,0,0)) SWIG_fail;
30103 {
30104 PyThreadState* __tstate = wxPyBeginAllowThreads();
30105 result = (long)wxGetLocalTime();
30106 wxPyEndAllowThreads(__tstate);
30107 if (PyErr_Occurred()) SWIG_fail;
30108 }
30109 resultobj = SWIG_From_long(static_cast< long >(result));
30110 return resultobj;
30111 fail:
30112 return NULL;
30113 }
30114
30115
30116 SWIGINTERN PyObject *_wrap_GetUTCTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30117 PyObject *resultobj = 0;
30118 long result;
30119
30120 if (!SWIG_Python_UnpackTuple(args,"GetUTCTime",0,0,0)) SWIG_fail;
30121 {
30122 PyThreadState* __tstate = wxPyBeginAllowThreads();
30123 result = (long)wxGetUTCTime();
30124 wxPyEndAllowThreads(__tstate);
30125 if (PyErr_Occurred()) SWIG_fail;
30126 }
30127 resultobj = SWIG_From_long(static_cast< long >(result));
30128 return resultobj;
30129 fail:
30130 return NULL;
30131 }
30132
30133
30134 SWIGINTERN PyObject *_wrap_GetCurrentTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30135 PyObject *resultobj = 0;
30136 long result;
30137
30138 if (!SWIG_Python_UnpackTuple(args,"GetCurrentTime",0,0,0)) SWIG_fail;
30139 {
30140 PyThreadState* __tstate = wxPyBeginAllowThreads();
30141 result = (long)wxGetCurrentTime();
30142 wxPyEndAllowThreads(__tstate);
30143 if (PyErr_Occurred()) SWIG_fail;
30144 }
30145 resultobj = SWIG_From_long(static_cast< long >(result));
30146 return resultobj;
30147 fail:
30148 return NULL;
30149 }
30150
30151
30152 SWIGINTERN PyObject *_wrap_GetLocalTimeMillis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30153 PyObject *resultobj = 0;
30154 wxLongLong result;
30155
30156 if (!SWIG_Python_UnpackTuple(args,"GetLocalTimeMillis",0,0,0)) SWIG_fail;
30157 {
30158 PyThreadState* __tstate = wxPyBeginAllowThreads();
30159 result = wxGetLocalTimeMillis();
30160 wxPyEndAllowThreads(__tstate);
30161 if (PyErr_Occurred()) SWIG_fail;
30162 }
30163 {
30164 PyObject *hi, *lo, *shifter, *shifted;
30165 hi = PyLong_FromLong( (&result)->GetHi() );
30166 lo = PyLong_FromLong( (&result)->GetLo() );
30167 shifter = PyLong_FromLong(32);
30168 shifted = PyNumber_Lshift(hi, shifter);
30169 resultobj = PyNumber_Or(shifted, lo);
30170 Py_DECREF(hi);
30171 Py_DECREF(lo);
30172 Py_DECREF(shifter);
30173 Py_DECREF(shifted);
30174 }
30175 return resultobj;
30176 fail:
30177 return NULL;
30178 }
30179
30180
30181 SWIGINTERN int DefaultDateTime_set(PyObject *) {
30182 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTime is read-only.");
30183 return 1;
30184 }
30185
30186
30187 SWIGINTERN PyObject *DefaultDateTime_get(void) {
30188 PyObject *pyobj = 0;
30189
30190 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0 );
30191 return pyobj;
30192 }
30193
30194
30195 SWIGINTERN PyObject *_wrap_new_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30196 PyObject *resultobj = 0;
30197 wxDataFormatId arg1 ;
30198 wxDataFormat *result = 0 ;
30199 int val1 ;
30200 int ecode1 = 0 ;
30201 PyObject * obj0 = 0 ;
30202 char * kwnames[] = {
30203 (char *) "type", NULL
30204 };
30205
30206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) SWIG_fail;
30207 ecode1 = SWIG_AsVal_int(obj0, &val1);
30208 if (!SWIG_IsOK(ecode1)) {
30209 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DataFormat" "', expected argument " "1"" of type '" "wxDataFormatId""'");
30210 }
30211 arg1 = static_cast< wxDataFormatId >(val1);
30212 {
30213 PyThreadState* __tstate = wxPyBeginAllowThreads();
30214 result = (wxDataFormat *)new wxDataFormat(arg1);
30215 wxPyEndAllowThreads(__tstate);
30216 if (PyErr_Occurred()) SWIG_fail;
30217 }
30218 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_NEW | 0 );
30219 return resultobj;
30220 fail:
30221 return NULL;
30222 }
30223
30224
30225 SWIGINTERN PyObject *_wrap_new_CustomDataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30226 PyObject *resultobj = 0;
30227 wxString *arg1 = 0 ;
30228 wxDataFormat *result = 0 ;
30229 bool temp1 = false ;
30230 PyObject * obj0 = 0 ;
30231 char * kwnames[] = {
30232 (char *) "format", NULL
30233 };
30234
30235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) SWIG_fail;
30236 {
30237 arg1 = wxString_in_helper(obj0);
30238 if (arg1 == NULL) SWIG_fail;
30239 temp1 = true;
30240 }
30241 {
30242 PyThreadState* __tstate = wxPyBeginAllowThreads();
30243 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
30244 wxPyEndAllowThreads(__tstate);
30245 if (PyErr_Occurred()) SWIG_fail;
30246 }
30247 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
30248 {
30249 if (temp1)
30250 delete arg1;
30251 }
30252 return resultobj;
30253 fail:
30254 {
30255 if (temp1)
30256 delete arg1;
30257 }
30258 return NULL;
30259 }
30260
30261
30262 SWIGINTERN PyObject *_wrap_delete_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30263 PyObject *resultobj = 0;
30264 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30265 void *argp1 = 0 ;
30266 int res1 = 0 ;
30267 PyObject *swig_obj[1] ;
30268
30269 if (!args) SWIG_fail;
30270 swig_obj[0] = args;
30271 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, SWIG_POINTER_DISOWN | 0 );
30272 if (!SWIG_IsOK(res1)) {
30273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataFormat" "', expected argument " "1"" of type '" "wxDataFormat *""'");
30274 }
30275 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30276 {
30277 PyThreadState* __tstate = wxPyBeginAllowThreads();
30278 delete arg1;
30279
30280 wxPyEndAllowThreads(__tstate);
30281 if (PyErr_Occurred()) SWIG_fail;
30282 }
30283 resultobj = SWIG_Py_Void();
30284 return resultobj;
30285 fail:
30286 return NULL;
30287 }
30288
30289
30290 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
30291 PyObject *resultobj = 0;
30292 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30293 wxDataFormatId arg2 ;
30294 bool result;
30295 void *argp1 = 0 ;
30296 int res1 = 0 ;
30297 int val2 ;
30298 int ecode2 = 0 ;
30299
30300 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30301 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30302 if (!SWIG_IsOK(res1)) {
30303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30304 }
30305 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30306 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
30307 if (!SWIG_IsOK(ecode2)) {
30308 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
30309 }
30310 arg2 = static_cast< wxDataFormatId >(val2);
30311 {
30312 PyThreadState* __tstate = wxPyBeginAllowThreads();
30313 result = (bool)((wxDataFormat const *)arg1)->operator ==(arg2);
30314 wxPyEndAllowThreads(__tstate);
30315 if (PyErr_Occurred()) SWIG_fail;
30316 }
30317 {
30318 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30319 }
30320 return resultobj;
30321 fail:
30322 return NULL;
30323 }
30324
30325
30326 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
30327 PyObject *resultobj = 0;
30328 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30329 wxDataFormatId arg2 ;
30330 bool result;
30331 void *argp1 = 0 ;
30332 int res1 = 0 ;
30333 int val2 ;
30334 int ecode2 = 0 ;
30335
30336 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30338 if (!SWIG_IsOK(res1)) {
30339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30340 }
30341 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30342 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
30343 if (!SWIG_IsOK(ecode2)) {
30344 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
30345 }
30346 arg2 = static_cast< wxDataFormatId >(val2);
30347 {
30348 PyThreadState* __tstate = wxPyBeginAllowThreads();
30349 result = (bool)((wxDataFormat const *)arg1)->operator !=(arg2);
30350 wxPyEndAllowThreads(__tstate);
30351 if (PyErr_Occurred()) SWIG_fail;
30352 }
30353 {
30354 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30355 }
30356 return resultobj;
30357 fail:
30358 return NULL;
30359 }
30360
30361
30362 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
30363 PyObject *resultobj = 0;
30364 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30365 wxDataFormat *arg2 = 0 ;
30366 bool result;
30367 void *argp1 = 0 ;
30368 int res1 = 0 ;
30369 void *argp2 = 0 ;
30370 int res2 = 0 ;
30371
30372 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30373 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30374 if (!SWIG_IsOK(res1)) {
30375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30376 }
30377 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30378 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30379 if (!SWIG_IsOK(res2)) {
30380 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30381 }
30382 if (!argp2) {
30383 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30384 }
30385 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30386 {
30387 PyThreadState* __tstate = wxPyBeginAllowThreads();
30388 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
30389 wxPyEndAllowThreads(__tstate);
30390 if (PyErr_Occurred()) SWIG_fail;
30391 }
30392 {
30393 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30394 }
30395 return resultobj;
30396 fail:
30397 return NULL;
30398 }
30399
30400
30401 SWIGINTERN PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
30402 int argc;
30403 PyObject *argv[3];
30404
30405 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___eq__",0,2,argv))) SWIG_fail;
30406 --argc;
30407 if (argc == 2) {
30408 int _v = 0;
30409 {
30410 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
30411 _v = SWIG_CheckState(res);
30412 }
30413 if (!_v) goto check_1;
30414 return _wrap_DataFormat___eq____SWIG_1(self, argc, argv);
30415 }
30416 check_1:
30417
30418 if (argc == 2) {
30419 return _wrap_DataFormat___eq____SWIG_0(self, argc, argv);
30420 }
30421
30422 fail:
30423 Py_INCREF(Py_NotImplemented);
30424 return Py_NotImplemented;
30425 }
30426
30427
30428 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
30429 PyObject *resultobj = 0;
30430 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30431 wxDataFormat *arg2 = 0 ;
30432 bool result;
30433 void *argp1 = 0 ;
30434 int res1 = 0 ;
30435 void *argp2 = 0 ;
30436 int res2 = 0 ;
30437
30438 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30439 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30440 if (!SWIG_IsOK(res1)) {
30441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30442 }
30443 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30444 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30445 if (!SWIG_IsOK(res2)) {
30446 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30447 }
30448 if (!argp2) {
30449 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30450 }
30451 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30452 {
30453 PyThreadState* __tstate = wxPyBeginAllowThreads();
30454 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
30455 wxPyEndAllowThreads(__tstate);
30456 if (PyErr_Occurred()) SWIG_fail;
30457 }
30458 {
30459 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30460 }
30461 return resultobj;
30462 fail:
30463 return NULL;
30464 }
30465
30466
30467 SWIGINTERN PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
30468 int argc;
30469 PyObject *argv[3];
30470
30471 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___ne__",0,2,argv))) SWIG_fail;
30472 --argc;
30473 if (argc == 2) {
30474 int _v = 0;
30475 {
30476 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
30477 _v = SWIG_CheckState(res);
30478 }
30479 if (!_v) goto check_1;
30480 return _wrap_DataFormat___ne____SWIG_1(self, argc, argv);
30481 }
30482 check_1:
30483
30484 if (argc == 2) {
30485 return _wrap_DataFormat___ne____SWIG_0(self, argc, argv);
30486 }
30487
30488 fail:
30489 Py_INCREF(Py_NotImplemented);
30490 return Py_NotImplemented;
30491 }
30492
30493
30494 SWIGINTERN PyObject *_wrap_DataFormat_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30495 PyObject *resultobj = 0;
30496 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30497 wxDataFormatId arg2 ;
30498 void *argp1 = 0 ;
30499 int res1 = 0 ;
30500 int val2 ;
30501 int ecode2 = 0 ;
30502 PyObject * obj0 = 0 ;
30503 PyObject * obj1 = 0 ;
30504 char * kwnames[] = {
30505 (char *) "self",(char *) "format", NULL
30506 };
30507
30508 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
30509 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30510 if (!SWIG_IsOK(res1)) {
30511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetType" "', expected argument " "1"" of type '" "wxDataFormat *""'");
30512 }
30513 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30514 ecode2 = SWIG_AsVal_int(obj1, &val2);
30515 if (!SWIG_IsOK(ecode2)) {
30516 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat_SetType" "', expected argument " "2"" of type '" "wxDataFormatId""'");
30517 }
30518 arg2 = static_cast< wxDataFormatId >(val2);
30519 {
30520 PyThreadState* __tstate = wxPyBeginAllowThreads();
30521 (arg1)->SetType(arg2);
30522 wxPyEndAllowThreads(__tstate);
30523 if (PyErr_Occurred()) SWIG_fail;
30524 }
30525 resultobj = SWIG_Py_Void();
30526 return resultobj;
30527 fail:
30528 return NULL;
30529 }
30530
30531
30532 SWIGINTERN PyObject *_wrap_DataFormat_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30533 PyObject *resultobj = 0;
30534 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30535 wxDataFormatId result;
30536 void *argp1 = 0 ;
30537 int res1 = 0 ;
30538 PyObject *swig_obj[1] ;
30539
30540 if (!args) SWIG_fail;
30541 swig_obj[0] = args;
30542 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30543 if (!SWIG_IsOK(res1)) {
30544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetType" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30545 }
30546 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30547 {
30548 PyThreadState* __tstate = wxPyBeginAllowThreads();
30549 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
30550 wxPyEndAllowThreads(__tstate);
30551 if (PyErr_Occurred()) SWIG_fail;
30552 }
30553 resultobj = SWIG_From_int(static_cast< int >(result));
30554 return resultobj;
30555 fail:
30556 return NULL;
30557 }
30558
30559
30560 SWIGINTERN PyObject *_wrap_DataFormat_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30561 PyObject *resultobj = 0;
30562 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30563 wxString result;
30564 void *argp1 = 0 ;
30565 int res1 = 0 ;
30566 PyObject *swig_obj[1] ;
30567
30568 if (!args) SWIG_fail;
30569 swig_obj[0] = args;
30570 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30571 if (!SWIG_IsOK(res1)) {
30572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetId" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30573 }
30574 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30575 {
30576 PyThreadState* __tstate = wxPyBeginAllowThreads();
30577 result = ((wxDataFormat const *)arg1)->GetId();
30578 wxPyEndAllowThreads(__tstate);
30579 if (PyErr_Occurred()) SWIG_fail;
30580 }
30581 {
30582 #if wxUSE_UNICODE
30583 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30584 #else
30585 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30586 #endif
30587 }
30588 return resultobj;
30589 fail:
30590 return NULL;
30591 }
30592
30593
30594 SWIGINTERN PyObject *_wrap_DataFormat_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30595 PyObject *resultobj = 0;
30596 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30597 wxString *arg2 = 0 ;
30598 void *argp1 = 0 ;
30599 int res1 = 0 ;
30600 bool temp2 = false ;
30601 PyObject * obj0 = 0 ;
30602 PyObject * obj1 = 0 ;
30603 char * kwnames[] = {
30604 (char *) "self",(char *) "format", NULL
30605 };
30606
30607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
30608 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30609 if (!SWIG_IsOK(res1)) {
30610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetId" "', expected argument " "1"" of type '" "wxDataFormat *""'");
30611 }
30612 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30613 {
30614 arg2 = wxString_in_helper(obj1);
30615 if (arg2 == NULL) SWIG_fail;
30616 temp2 = true;
30617 }
30618 {
30619 PyThreadState* __tstate = wxPyBeginAllowThreads();
30620 (arg1)->SetId((wxString const &)*arg2);
30621 wxPyEndAllowThreads(__tstate);
30622 if (PyErr_Occurred()) SWIG_fail;
30623 }
30624 resultobj = SWIG_Py_Void();
30625 {
30626 if (temp2)
30627 delete arg2;
30628 }
30629 return resultobj;
30630 fail:
30631 {
30632 if (temp2)
30633 delete arg2;
30634 }
30635 return NULL;
30636 }
30637
30638
30639 SWIGINTERN PyObject *DataFormat_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30640 PyObject *obj;
30641 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30642 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataFormat, SWIG_NewClientData(obj));
30643 return SWIG_Py_Void();
30644 }
30645
30646 SWIGINTERN PyObject *DataFormat_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30647 return SWIG_Python_InitShadowInstance(args);
30648 }
30649
30650 SWIGINTERN int FormatInvalid_set(PyObject *) {
30651 SWIG_Error(SWIG_AttributeError,"Variable FormatInvalid is read-only.");
30652 return 1;
30653 }
30654
30655
30656 SWIGINTERN PyObject *FormatInvalid_get(void) {
30657 PyObject *pyobj = 0;
30658
30659 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0 );
30660 return pyobj;
30661 }
30662
30663
30664 SWIGINTERN PyObject *_wrap_delete_DataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30665 PyObject *resultobj = 0;
30666 wxDataObject *arg1 = (wxDataObject *) 0 ;
30667 void *argp1 = 0 ;
30668 int res1 = 0 ;
30669 PyObject *swig_obj[1] ;
30670
30671 if (!args) SWIG_fail;
30672 swig_obj[0] = args;
30673 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
30674 if (!SWIG_IsOK(res1)) {
30675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataObject" "', expected argument " "1"" of type '" "wxDataObject *""'");
30676 }
30677 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30678 {
30679 PyThreadState* __tstate = wxPyBeginAllowThreads();
30680 delete arg1;
30681
30682 wxPyEndAllowThreads(__tstate);
30683 if (PyErr_Occurred()) SWIG_fail;
30684 }
30685 resultobj = SWIG_Py_Void();
30686 return resultobj;
30687 fail:
30688 return NULL;
30689 }
30690
30691
30692 SWIGINTERN PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30693 PyObject *resultobj = 0;
30694 wxDataObject *arg1 = (wxDataObject *) 0 ;
30695 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
30696 SwigValueWrapper<wxDataFormat > result;
30697 void *argp1 = 0 ;
30698 int res1 = 0 ;
30699 int val2 ;
30700 int ecode2 = 0 ;
30701 PyObject * obj0 = 0 ;
30702 PyObject * obj1 = 0 ;
30703 char * kwnames[] = {
30704 (char *) "self",(char *) "dir", NULL
30705 };
30706
30707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) SWIG_fail;
30708 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30709 if (!SWIG_IsOK(res1)) {
30710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "1"" of type '" "wxDataObject const *""'");
30711 }
30712 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30713 if (obj1) {
30714 ecode2 = SWIG_AsVal_int(obj1, &val2);
30715 if (!SWIG_IsOK(ecode2)) {
30716 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
30717 }
30718 arg2 = static_cast< wxDataObject::Direction >(val2);
30719 }
30720 {
30721 PyThreadState* __tstate = wxPyBeginAllowThreads();
30722 result = ((wxDataObject const *)arg1)->GetPreferredFormat(arg2);
30723 wxPyEndAllowThreads(__tstate);
30724 if (PyErr_Occurred()) SWIG_fail;
30725 }
30726 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
30727 return resultobj;
30728 fail:
30729 return NULL;
30730 }
30731
30732
30733 SWIGINTERN PyObject *_wrap_DataObject_GetFormatCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30734 PyObject *resultobj = 0;
30735 wxDataObject *arg1 = (wxDataObject *) 0 ;
30736 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
30737 size_t result;
30738 void *argp1 = 0 ;
30739 int res1 = 0 ;
30740 int val2 ;
30741 int ecode2 = 0 ;
30742 PyObject * obj0 = 0 ;
30743 PyObject * obj1 = 0 ;
30744 char * kwnames[] = {
30745 (char *) "self",(char *) "dir", NULL
30746 };
30747
30748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) SWIG_fail;
30749 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30750 if (!SWIG_IsOK(res1)) {
30751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetFormatCount" "', expected argument " "1"" of type '" "wxDataObject const *""'");
30752 }
30753 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30754 if (obj1) {
30755 ecode2 = SWIG_AsVal_int(obj1, &val2);
30756 if (!SWIG_IsOK(ecode2)) {
30757 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetFormatCount" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
30758 }
30759 arg2 = static_cast< wxDataObject::Direction >(val2);
30760 }
30761 {
30762 PyThreadState* __tstate = wxPyBeginAllowThreads();
30763 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount(arg2);
30764 wxPyEndAllowThreads(__tstate);
30765 if (PyErr_Occurred()) SWIG_fail;
30766 }
30767 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
30768 return resultobj;
30769 fail:
30770 return NULL;
30771 }
30772
30773
30774 SWIGINTERN PyObject *_wrap_DataObject_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30775 PyObject *resultobj = 0;
30776 wxDataObject *arg1 = (wxDataObject *) 0 ;
30777 wxDataFormat *arg2 = 0 ;
30778 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
30779 bool result;
30780 void *argp1 = 0 ;
30781 int res1 = 0 ;
30782 void *argp2 = 0 ;
30783 int res2 = 0 ;
30784 int val3 ;
30785 int ecode3 = 0 ;
30786 PyObject * obj0 = 0 ;
30787 PyObject * obj1 = 0 ;
30788 PyObject * obj2 = 0 ;
30789 char * kwnames[] = {
30790 (char *) "self",(char *) "format",(char *) "dir", NULL
30791 };
30792
30793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30794 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30795 if (!SWIG_IsOK(res1)) {
30796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_IsSupported" "', expected argument " "1"" of type '" "wxDataObject const *""'");
30797 }
30798 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30799 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30800 if (!SWIG_IsOK(res2)) {
30801 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30802 }
30803 if (!argp2) {
30804 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30805 }
30806 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30807 if (obj2) {
30808 ecode3 = SWIG_AsVal_int(obj2, &val3);
30809 if (!SWIG_IsOK(ecode3)) {
30810 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObject_IsSupported" "', expected argument " "3"" of type '" "wxDataObject::Direction""'");
30811 }
30812 arg3 = static_cast< wxDataObject::Direction >(val3);
30813 }
30814 {
30815 PyThreadState* __tstate = wxPyBeginAllowThreads();
30816 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,arg3);
30817 wxPyEndAllowThreads(__tstate);
30818 if (PyErr_Occurred()) SWIG_fail;
30819 }
30820 {
30821 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30822 }
30823 return resultobj;
30824 fail:
30825 return NULL;
30826 }
30827
30828
30829 SWIGINTERN PyObject *_wrap_DataObject_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30830 PyObject *resultobj = 0;
30831 wxDataObject *arg1 = (wxDataObject *) 0 ;
30832 wxDataFormat *arg2 = 0 ;
30833 size_t result;
30834 void *argp1 = 0 ;
30835 int res1 = 0 ;
30836 void *argp2 = 0 ;
30837 int res2 = 0 ;
30838 PyObject * obj0 = 0 ;
30839 PyObject * obj1 = 0 ;
30840 char * kwnames[] = {
30841 (char *) "self",(char *) "format", NULL
30842 };
30843
30844 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) SWIG_fail;
30845 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30846 if (!SWIG_IsOK(res1)) {
30847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataSize" "', expected argument " "1"" of type '" "wxDataObject const *""'");
30848 }
30849 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30850 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30851 if (!SWIG_IsOK(res2)) {
30852 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30853 }
30854 if (!argp2) {
30855 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30856 }
30857 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30858 {
30859 PyThreadState* __tstate = wxPyBeginAllowThreads();
30860 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
30861 wxPyEndAllowThreads(__tstate);
30862 if (PyErr_Occurred()) SWIG_fail;
30863 }
30864 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
30865 return resultobj;
30866 fail:
30867 return NULL;
30868 }
30869
30870
30871 SWIGINTERN PyObject *_wrap_DataObject_GetAllFormats(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30872 PyObject *resultobj = 0;
30873 wxDataObject *arg1 = (wxDataObject *) 0 ;
30874 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
30875 PyObject *result = 0 ;
30876 void *argp1 = 0 ;
30877 int res1 = 0 ;
30878 int val2 ;
30879 int ecode2 = 0 ;
30880 PyObject * obj0 = 0 ;
30881 PyObject * obj1 = 0 ;
30882 char * kwnames[] = {
30883 (char *) "self",(char *) "dir", NULL
30884 };
30885
30886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) SWIG_fail;
30887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30888 if (!SWIG_IsOK(res1)) {
30889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetAllFormats" "', expected argument " "1"" of type '" "wxDataObject *""'");
30890 }
30891 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30892 if (obj1) {
30893 ecode2 = SWIG_AsVal_int(obj1, &val2);
30894 if (!SWIG_IsOK(ecode2)) {
30895 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetAllFormats" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
30896 }
30897 arg2 = static_cast< wxDataObject::Direction >(val2);
30898 }
30899 {
30900 PyThreadState* __tstate = wxPyBeginAllowThreads();
30901 result = (PyObject *)wxDataObject_GetAllFormats(arg1,arg2);
30902 wxPyEndAllowThreads(__tstate);
30903 if (PyErr_Occurred()) SWIG_fail;
30904 }
30905 resultobj = result;
30906 return resultobj;
30907 fail:
30908 return NULL;
30909 }
30910
30911
30912 SWIGINTERN PyObject *_wrap_DataObject_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30913 PyObject *resultobj = 0;
30914 wxDataObject *arg1 = (wxDataObject *) 0 ;
30915 wxDataFormat *arg2 = 0 ;
30916 PyObject *result = 0 ;
30917 void *argp1 = 0 ;
30918 int res1 = 0 ;
30919 void *argp2 = 0 ;
30920 int res2 = 0 ;
30921 PyObject * obj0 = 0 ;
30922 PyObject * obj1 = 0 ;
30923 char * kwnames[] = {
30924 (char *) "self",(char *) "format", NULL
30925 };
30926
30927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) SWIG_fail;
30928 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30929 if (!SWIG_IsOK(res1)) {
30930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataHere" "', expected argument " "1"" of type '" "wxDataObject *""'");
30931 }
30932 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30933 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30934 if (!SWIG_IsOK(res2)) {
30935 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30936 }
30937 if (!argp2) {
30938 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30939 }
30940 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30941 {
30942 PyThreadState* __tstate = wxPyBeginAllowThreads();
30943 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
30944 wxPyEndAllowThreads(__tstate);
30945 if (PyErr_Occurred()) SWIG_fail;
30946 }
30947 resultobj = result;
30948 return resultobj;
30949 fail:
30950 return NULL;
30951 }
30952
30953
30954 SWIGINTERN PyObject *_wrap_DataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30955 PyObject *resultobj = 0;
30956 wxDataObject *arg1 = (wxDataObject *) 0 ;
30957 wxDataFormat *arg2 = 0 ;
30958 PyObject *arg3 = (PyObject *) 0 ;
30959 bool result;
30960 void *argp1 = 0 ;
30961 int res1 = 0 ;
30962 void *argp2 = 0 ;
30963 int res2 = 0 ;
30964 PyObject * obj0 = 0 ;
30965 PyObject * obj1 = 0 ;
30966 PyObject * obj2 = 0 ;
30967 char * kwnames[] = {
30968 (char *) "self",(char *) "format",(char *) "data", NULL
30969 };
30970
30971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30972 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30973 if (!SWIG_IsOK(res1)) {
30974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_SetData" "', expected argument " "1"" of type '" "wxDataObject *""'");
30975 }
30976 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30977 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30978 if (!SWIG_IsOK(res2)) {
30979 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30980 }
30981 if (!argp2) {
30982 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30983 }
30984 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30985 arg3 = obj2;
30986 {
30987 PyThreadState* __tstate = wxPyBeginAllowThreads();
30988 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
30989 wxPyEndAllowThreads(__tstate);
30990 if (PyErr_Occurred()) SWIG_fail;
30991 }
30992 {
30993 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30994 }
30995 return resultobj;
30996 fail:
30997 return NULL;
30998 }
30999
31000
31001 SWIGINTERN PyObject *DataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31002 PyObject *obj;
31003 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31004 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObject, SWIG_NewClientData(obj));
31005 return SWIG_Py_Void();
31006 }
31007
31008 SWIGINTERN PyObject *_wrap_new_DataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31009 PyObject *resultobj = 0;
31010 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
31011 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
31012 wxDataObjectSimple *result = 0 ;
31013 void *argp1 = 0 ;
31014 int res1 = 0 ;
31015 PyObject * obj0 = 0 ;
31016 char * kwnames[] = {
31017 (char *) "format", NULL
31018 };
31019
31020 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) SWIG_fail;
31021 if (obj0) {
31022 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
31023 if (!SWIG_IsOK(res1)) {
31024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31025 }
31026 if (!argp1) {
31027 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31028 }
31029 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31030 }
31031 {
31032 PyThreadState* __tstate = wxPyBeginAllowThreads();
31033 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
31034 wxPyEndAllowThreads(__tstate);
31035 if (PyErr_Occurred()) SWIG_fail;
31036 }
31037 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_NEW | 0 );
31038 return resultobj;
31039 fail:
31040 return NULL;
31041 }
31042
31043
31044 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31045 PyObject *resultobj = 0;
31046 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31047 wxDataFormat *result = 0 ;
31048 void *argp1 = 0 ;
31049 int res1 = 0 ;
31050 PyObject *swig_obj[1] ;
31051
31052 if (!args) SWIG_fail;
31053 swig_obj[0] = args;
31054 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31055 if (!SWIG_IsOK(res1)) {
31056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
31057 }
31058 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31059 {
31060 PyThreadState* __tstate = wxPyBeginAllowThreads();
31061 {
31062 wxDataFormat const &_result_ref = (arg1)->GetFormat();
31063 result = (wxDataFormat *) &_result_ref;
31064 }
31065 wxPyEndAllowThreads(__tstate);
31066 if (PyErr_Occurred()) SWIG_fail;
31067 }
31068 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, 0 | 0 );
31069 return resultobj;
31070 fail:
31071 return NULL;
31072 }
31073
31074
31075 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31076 PyObject *resultobj = 0;
31077 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31078 wxDataFormat *arg2 = 0 ;
31079 void *argp1 = 0 ;
31080 int res1 = 0 ;
31081 void *argp2 = 0 ;
31082 int res2 = 0 ;
31083 PyObject * obj0 = 0 ;
31084 PyObject * obj1 = 0 ;
31085 char * kwnames[] = {
31086 (char *) "self",(char *) "format", NULL
31087 };
31088
31089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) SWIG_fail;
31090 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31091 if (!SWIG_IsOK(res1)) {
31092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
31093 }
31094 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31095 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31096 if (!SWIG_IsOK(res2)) {
31097 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31098 }
31099 if (!argp2) {
31100 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31101 }
31102 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31103 {
31104 PyThreadState* __tstate = wxPyBeginAllowThreads();
31105 (arg1)->SetFormat((wxDataFormat const &)*arg2);
31106 wxPyEndAllowThreads(__tstate);
31107 if (PyErr_Occurred()) SWIG_fail;
31108 }
31109 resultobj = SWIG_Py_Void();
31110 return resultobj;
31111 fail:
31112 return NULL;
31113 }
31114
31115
31116 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31117 PyObject *resultobj = 0;
31118 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31119 size_t result;
31120 void *argp1 = 0 ;
31121 int res1 = 0 ;
31122 PyObject *swig_obj[1] ;
31123
31124 if (!args) SWIG_fail;
31125 swig_obj[0] = args;
31126 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31127 if (!SWIG_IsOK(res1)) {
31128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataSize" "', expected argument " "1"" of type '" "wxDataObjectSimple const *""'");
31129 }
31130 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31131 {
31132 PyThreadState* __tstate = wxPyBeginAllowThreads();
31133 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
31134 wxPyEndAllowThreads(__tstate);
31135 if (PyErr_Occurred()) SWIG_fail;
31136 }
31137 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
31138 return resultobj;
31139 fail:
31140 return NULL;
31141 }
31142
31143
31144 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31145 PyObject *resultobj = 0;
31146 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31147 PyObject *result = 0 ;
31148 void *argp1 = 0 ;
31149 int res1 = 0 ;
31150 PyObject *swig_obj[1] ;
31151
31152 if (!args) SWIG_fail;
31153 swig_obj[0] = args;
31154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31155 if (!SWIG_IsOK(res1)) {
31156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataHere" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
31157 }
31158 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31159 {
31160 PyThreadState* __tstate = wxPyBeginAllowThreads();
31161 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
31162 wxPyEndAllowThreads(__tstate);
31163 if (PyErr_Occurred()) SWIG_fail;
31164 }
31165 resultobj = result;
31166 return resultobj;
31167 fail:
31168 return NULL;
31169 }
31170
31171
31172 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31173 PyObject *resultobj = 0;
31174 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31175 PyObject *arg2 = (PyObject *) 0 ;
31176 bool result;
31177 void *argp1 = 0 ;
31178 int res1 = 0 ;
31179 PyObject * obj0 = 0 ;
31180 PyObject * obj1 = 0 ;
31181 char * kwnames[] = {
31182 (char *) "self",(char *) "data", NULL
31183 };
31184
31185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
31186 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31187 if (!SWIG_IsOK(res1)) {
31188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetData" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
31189 }
31190 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31191 arg2 = obj1;
31192 {
31193 PyThreadState* __tstate = wxPyBeginAllowThreads();
31194 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
31195 wxPyEndAllowThreads(__tstate);
31196 if (PyErr_Occurred()) SWIG_fail;
31197 }
31198 {
31199 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31200 }
31201 return resultobj;
31202 fail:
31203 return NULL;
31204 }
31205
31206
31207 SWIGINTERN PyObject *DataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31208 PyObject *obj;
31209 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31210 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectSimple, SWIG_NewClientData(obj));
31211 return SWIG_Py_Void();
31212 }
31213
31214 SWIGINTERN PyObject *DataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31215 return SWIG_Python_InitShadowInstance(args);
31216 }
31217
31218 SWIGINTERN PyObject *_wrap_new_PyDataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31219 PyObject *resultobj = 0;
31220 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
31221 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
31222 wxPyDataObjectSimple *result = 0 ;
31223 void *argp1 = 0 ;
31224 int res1 = 0 ;
31225 PyObject * obj0 = 0 ;
31226 char * kwnames[] = {
31227 (char *) "format", NULL
31228 };
31229
31230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) SWIG_fail;
31231 if (obj0) {
31232 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
31233 if (!SWIG_IsOK(res1)) {
31234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31235 }
31236 if (!argp1) {
31237 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31238 }
31239 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31240 }
31241 {
31242 PyThreadState* __tstate = wxPyBeginAllowThreads();
31243 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
31244 wxPyEndAllowThreads(__tstate);
31245 if (PyErr_Occurred()) SWIG_fail;
31246 }
31247 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_NEW | 0 );
31248 return resultobj;
31249 fail:
31250 return NULL;
31251 }
31252
31253
31254 SWIGINTERN PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31255 PyObject *resultobj = 0;
31256 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
31257 PyObject *arg2 = (PyObject *) 0 ;
31258 PyObject *arg3 = (PyObject *) 0 ;
31259 void *argp1 = 0 ;
31260 int res1 = 0 ;
31261 PyObject * obj0 = 0 ;
31262 PyObject * obj1 = 0 ;
31263 PyObject * obj2 = 0 ;
31264 char * kwnames[] = {
31265 (char *) "self",(char *) "self",(char *) "_class", NULL
31266 };
31267
31268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31269 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDataObjectSimple, 0 | 0 );
31270 if (!SWIG_IsOK(res1)) {
31271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyDataObjectSimple__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDataObjectSimple *""'");
31272 }
31273 arg1 = reinterpret_cast< wxPyDataObjectSimple * >(argp1);
31274 arg2 = obj1;
31275 arg3 = obj2;
31276 {
31277 PyThreadState* __tstate = wxPyBeginAllowThreads();
31278 (arg1)->_setCallbackInfo(arg2,arg3);
31279 wxPyEndAllowThreads(__tstate);
31280 if (PyErr_Occurred()) SWIG_fail;
31281 }
31282 resultobj = SWIG_Py_Void();
31283 return resultobj;
31284 fail:
31285 return NULL;
31286 }
31287
31288
31289 SWIGINTERN PyObject *PyDataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31290 PyObject *obj;
31291 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31292 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDataObjectSimple, SWIG_NewClientData(obj));
31293 return SWIG_Py_Void();
31294 }
31295
31296 SWIGINTERN PyObject *PyDataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31297 return SWIG_Python_InitShadowInstance(args);
31298 }
31299
31300 SWIGINTERN PyObject *_wrap_new_DataObjectComposite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31301 PyObject *resultobj = 0;
31302 wxDataObjectComposite *result = 0 ;
31303
31304 if (!SWIG_Python_UnpackTuple(args,"new_DataObjectComposite",0,0,0)) SWIG_fail;
31305 {
31306 PyThreadState* __tstate = wxPyBeginAllowThreads();
31307 result = (wxDataObjectComposite *)new wxDataObjectComposite();
31308 wxPyEndAllowThreads(__tstate);
31309 if (PyErr_Occurred()) SWIG_fail;
31310 }
31311 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_NEW | 0 );
31312 return resultobj;
31313 fail:
31314 return NULL;
31315 }
31316
31317
31318 SWIGINTERN PyObject *_wrap_DataObjectComposite_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31319 PyObject *resultobj = 0;
31320 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
31321 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
31322 bool arg3 = (bool) false ;
31323 void *argp1 = 0 ;
31324 int res1 = 0 ;
31325 int res2 = 0 ;
31326 bool val3 ;
31327 int ecode3 = 0 ;
31328 PyObject * obj0 = 0 ;
31329 PyObject * obj1 = 0 ;
31330 PyObject * obj2 = 0 ;
31331 char * kwnames[] = {
31332 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
31333 };
31334
31335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31336 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
31337 if (!SWIG_IsOK(res1)) {
31338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_Add" "', expected argument " "1"" of type '" "wxDataObjectComposite *""'");
31339 }
31340 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
31341 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_DISOWN | 0 );
31342 if (!SWIG_IsOK(res2)) {
31343 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectComposite_Add" "', expected argument " "2"" of type '" "wxDataObjectSimple *""'");
31344 }
31345 if (obj2) {
31346 ecode3 = SWIG_AsVal_bool(obj2, &val3);
31347 if (!SWIG_IsOK(ecode3)) {
31348 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObjectComposite_Add" "', expected argument " "3"" of type '" "bool""'");
31349 }
31350 arg3 = static_cast< bool >(val3);
31351 }
31352 {
31353 PyThreadState* __tstate = wxPyBeginAllowThreads();
31354 (arg1)->Add(arg2,arg3);
31355 wxPyEndAllowThreads(__tstate);
31356 if (PyErr_Occurred()) SWIG_fail;
31357 }
31358 resultobj = SWIG_Py_Void();
31359 return resultobj;
31360 fail:
31361 return NULL;
31362 }
31363
31364
31365 SWIGINTERN PyObject *_wrap_DataObjectComposite_GetReceivedFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31366 PyObject *resultobj = 0;
31367 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
31368 SwigValueWrapper<wxDataFormat > result;
31369 void *argp1 = 0 ;
31370 int res1 = 0 ;
31371 PyObject *swig_obj[1] ;
31372
31373 if (!args) SWIG_fail;
31374 swig_obj[0] = args;
31375 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
31376 if (!SWIG_IsOK(res1)) {
31377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_GetReceivedFormat" "', expected argument " "1"" of type '" "wxDataObjectComposite const *""'");
31378 }
31379 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
31380 {
31381 PyThreadState* __tstate = wxPyBeginAllowThreads();
31382 result = ((wxDataObjectComposite const *)arg1)->GetReceivedFormat();
31383 wxPyEndAllowThreads(__tstate);
31384 if (PyErr_Occurred()) SWIG_fail;
31385 }
31386 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
31387 return resultobj;
31388 fail:
31389 return NULL;
31390 }
31391
31392
31393 SWIGINTERN PyObject *DataObjectComposite_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31394 PyObject *obj;
31395 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31396 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectComposite, SWIG_NewClientData(obj));
31397 return SWIG_Py_Void();
31398 }
31399
31400 SWIGINTERN PyObject *DataObjectComposite_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31401 return SWIG_Python_InitShadowInstance(args);
31402 }
31403
31404 SWIGINTERN PyObject *_wrap_new_TextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31405 PyObject *resultobj = 0;
31406 wxString const &arg1_defvalue = wxPyEmptyString ;
31407 wxString *arg1 = (wxString *) &arg1_defvalue ;
31408 wxTextDataObject *result = 0 ;
31409 bool temp1 = false ;
31410 PyObject * obj0 = 0 ;
31411 char * kwnames[] = {
31412 (char *) "text", NULL
31413 };
31414
31415 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) SWIG_fail;
31416 if (obj0) {
31417 {
31418 arg1 = wxString_in_helper(obj0);
31419 if (arg1 == NULL) SWIG_fail;
31420 temp1 = true;
31421 }
31422 }
31423 {
31424 PyThreadState* __tstate = wxPyBeginAllowThreads();
31425 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
31426 wxPyEndAllowThreads(__tstate);
31427 if (PyErr_Occurred()) SWIG_fail;
31428 }
31429 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_NEW | 0 );
31430 {
31431 if (temp1)
31432 delete arg1;
31433 }
31434 return resultobj;
31435 fail:
31436 {
31437 if (temp1)
31438 delete arg1;
31439 }
31440 return NULL;
31441 }
31442
31443
31444 SWIGINTERN PyObject *_wrap_TextDataObject_GetTextLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31445 PyObject *resultobj = 0;
31446 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
31447 size_t result;
31448 void *argp1 = 0 ;
31449 int res1 = 0 ;
31450 PyObject *swig_obj[1] ;
31451
31452 if (!args) SWIG_fail;
31453 swig_obj[0] = args;
31454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
31455 if (!SWIG_IsOK(res1)) {
31456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetTextLength" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
31457 }
31458 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
31459 {
31460 PyThreadState* __tstate = wxPyBeginAllowThreads();
31461 result = (size_t)(arg1)->GetTextLength();
31462 wxPyEndAllowThreads(__tstate);
31463 if (PyErr_Occurred()) SWIG_fail;
31464 }
31465 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
31466 return resultobj;
31467 fail:
31468 return NULL;
31469 }
31470
31471
31472 SWIGINTERN PyObject *_wrap_TextDataObject_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31473 PyObject *resultobj = 0;
31474 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
31475 wxString result;
31476 void *argp1 = 0 ;
31477 int res1 = 0 ;
31478 PyObject *swig_obj[1] ;
31479
31480 if (!args) SWIG_fail;
31481 swig_obj[0] = args;
31482 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
31483 if (!SWIG_IsOK(res1)) {
31484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
31485 }
31486 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
31487 {
31488 PyThreadState* __tstate = wxPyBeginAllowThreads();
31489 result = (arg1)->GetText();
31490 wxPyEndAllowThreads(__tstate);
31491 if (PyErr_Occurred()) SWIG_fail;
31492 }
31493 {
31494 #if wxUSE_UNICODE
31495 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31496 #else
31497 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31498 #endif
31499 }
31500 return resultobj;
31501 fail:
31502 return NULL;
31503 }
31504
31505
31506 SWIGINTERN PyObject *_wrap_TextDataObject_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31507 PyObject *resultobj = 0;
31508 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
31509 wxString *arg2 = 0 ;
31510 void *argp1 = 0 ;
31511 int res1 = 0 ;
31512 bool temp2 = false ;
31513 PyObject * obj0 = 0 ;
31514 PyObject * obj1 = 0 ;
31515 char * kwnames[] = {
31516 (char *) "self",(char *) "text", NULL
31517 };
31518
31519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
31520 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
31521 if (!SWIG_IsOK(res1)) {
31522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_SetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
31523 }
31524 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
31525 {
31526 arg2 = wxString_in_helper(obj1);
31527 if (arg2 == NULL) SWIG_fail;
31528 temp2 = true;
31529 }
31530 {
31531 PyThreadState* __tstate = wxPyBeginAllowThreads();
31532 (arg1)->SetText((wxString const &)*arg2);
31533 wxPyEndAllowThreads(__tstate);
31534 if (PyErr_Occurred()) SWIG_fail;
31535 }
31536 resultobj = SWIG_Py_Void();
31537 {
31538 if (temp2)
31539 delete arg2;
31540 }
31541 return resultobj;
31542 fail:
31543 {
31544 if (temp2)
31545 delete arg2;
31546 }
31547 return NULL;
31548 }
31549
31550
31551 SWIGINTERN PyObject *TextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31552 PyObject *obj;
31553 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31554 SWIG_TypeNewClientData(SWIGTYPE_p_wxTextDataObject, SWIG_NewClientData(obj));
31555 return SWIG_Py_Void();
31556 }
31557
31558 SWIGINTERN PyObject *TextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31559 return SWIG_Python_InitShadowInstance(args);
31560 }
31561
31562 SWIGINTERN PyObject *_wrap_new_PyTextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31563 PyObject *resultobj = 0;
31564 wxString const &arg1_defvalue = wxPyEmptyString ;
31565 wxString *arg1 = (wxString *) &arg1_defvalue ;
31566 wxPyTextDataObject *result = 0 ;
31567 bool temp1 = false ;
31568 PyObject * obj0 = 0 ;
31569 char * kwnames[] = {
31570 (char *) "text", NULL
31571 };
31572
31573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) SWIG_fail;
31574 if (obj0) {
31575 {
31576 arg1 = wxString_in_helper(obj0);
31577 if (arg1 == NULL) SWIG_fail;
31578 temp1 = true;
31579 }
31580 }
31581 {
31582 PyThreadState* __tstate = wxPyBeginAllowThreads();
31583 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
31584 wxPyEndAllowThreads(__tstate);
31585 if (PyErr_Occurred()) SWIG_fail;
31586 }
31587 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_NEW | 0 );
31588 {
31589 if (temp1)
31590 delete arg1;
31591 }
31592 return resultobj;
31593 fail:
31594 {
31595 if (temp1)
31596 delete arg1;
31597 }
31598 return NULL;
31599 }
31600
31601
31602 SWIGINTERN PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31603 PyObject *resultobj = 0;
31604 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
31605 PyObject *arg2 = (PyObject *) 0 ;
31606 PyObject *arg3 = (PyObject *) 0 ;
31607 void *argp1 = 0 ;
31608 int res1 = 0 ;
31609 PyObject * obj0 = 0 ;
31610 PyObject * obj1 = 0 ;
31611 PyObject * obj2 = 0 ;
31612 char * kwnames[] = {
31613 (char *) "self",(char *) "self",(char *) "_class", NULL
31614 };
31615
31616 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31617 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDataObject, 0 | 0 );
31618 if (!SWIG_IsOK(res1)) {
31619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTextDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDataObject *""'");
31620 }
31621 arg1 = reinterpret_cast< wxPyTextDataObject * >(argp1);
31622 arg2 = obj1;
31623 arg3 = obj2;
31624 {
31625 PyThreadState* __tstate = wxPyBeginAllowThreads();
31626 (arg1)->_setCallbackInfo(arg2,arg3);
31627 wxPyEndAllowThreads(__tstate);
31628 if (PyErr_Occurred()) SWIG_fail;
31629 }
31630 resultobj = SWIG_Py_Void();
31631 return resultobj;
31632 fail:
31633 return NULL;
31634 }
31635
31636
31637 SWIGINTERN PyObject *PyTextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31638 PyObject *obj;
31639 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31640 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDataObject, SWIG_NewClientData(obj));
31641 return SWIG_Py_Void();
31642 }
31643
31644 SWIGINTERN PyObject *PyTextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31645 return SWIG_Python_InitShadowInstance(args);
31646 }
31647
31648 SWIGINTERN PyObject *_wrap_new_BitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31649 PyObject *resultobj = 0;
31650 wxBitmap const &arg1_defvalue = wxNullBitmap ;
31651 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
31652 wxBitmapDataObject *result = 0 ;
31653 void *argp1 = 0 ;
31654 int res1 = 0 ;
31655 PyObject * obj0 = 0 ;
31656 char * kwnames[] = {
31657 (char *) "bitmap", NULL
31658 };
31659
31660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) SWIG_fail;
31661 if (obj0) {
31662 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
31663 if (!SWIG_IsOK(res1)) {
31664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
31665 }
31666 if (!argp1) {
31667 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
31668 }
31669 arg1 = reinterpret_cast< wxBitmap * >(argp1);
31670 }
31671 {
31672 PyThreadState* __tstate = wxPyBeginAllowThreads();
31673 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
31674 wxPyEndAllowThreads(__tstate);
31675 if (PyErr_Occurred()) SWIG_fail;
31676 }
31677 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_NEW | 0 );
31678 return resultobj;
31679 fail:
31680 return NULL;
31681 }
31682
31683
31684 SWIGINTERN PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31685 PyObject *resultobj = 0;
31686 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
31687 wxBitmap result;
31688 void *argp1 = 0 ;
31689 int res1 = 0 ;
31690 PyObject *swig_obj[1] ;
31691
31692 if (!args) SWIG_fail;
31693 swig_obj[0] = args;
31694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
31695 if (!SWIG_IsOK(res1)) {
31696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_GetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject const *""'");
31697 }
31698 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
31699 {
31700 PyThreadState* __tstate = wxPyBeginAllowThreads();
31701 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
31702 wxPyEndAllowThreads(__tstate);
31703 if (PyErr_Occurred()) SWIG_fail;
31704 }
31705 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
31706 return resultobj;
31707 fail:
31708 return NULL;
31709 }
31710
31711
31712 SWIGINTERN PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31713 PyObject *resultobj = 0;
31714 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
31715 wxBitmap *arg2 = 0 ;
31716 void *argp1 = 0 ;
31717 int res1 = 0 ;
31718 void *argp2 = 0 ;
31719 int res2 = 0 ;
31720 PyObject * obj0 = 0 ;
31721 PyObject * obj1 = 0 ;
31722 char * kwnames[] = {
31723 (char *) "self",(char *) "bitmap", NULL
31724 };
31725
31726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
31727 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
31728 if (!SWIG_IsOK(res1)) {
31729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject *""'");
31730 }
31731 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
31732 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
31733 if (!SWIG_IsOK(res2)) {
31734 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
31735 }
31736 if (!argp2) {
31737 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
31738 }
31739 arg2 = reinterpret_cast< wxBitmap * >(argp2);
31740 {
31741 PyThreadState* __tstate = wxPyBeginAllowThreads();
31742 (arg1)->SetBitmap((wxBitmap const &)*arg2);
31743 wxPyEndAllowThreads(__tstate);
31744 if (PyErr_Occurred()) SWIG_fail;
31745 }
31746 resultobj = SWIG_Py_Void();
31747 return resultobj;
31748 fail:
31749 return NULL;
31750 }
31751
31752
31753 SWIGINTERN PyObject *BitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31754 PyObject *obj;
31755 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31756 SWIG_TypeNewClientData(SWIGTYPE_p_wxBitmapDataObject, SWIG_NewClientData(obj));
31757 return SWIG_Py_Void();
31758 }
31759
31760 SWIGINTERN PyObject *BitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31761 return SWIG_Python_InitShadowInstance(args);
31762 }
31763
31764 SWIGINTERN PyObject *_wrap_new_PyBitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31765 PyObject *resultobj = 0;
31766 wxBitmap const &arg1_defvalue = wxNullBitmap ;
31767 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
31768 wxPyBitmapDataObject *result = 0 ;
31769 void *argp1 = 0 ;
31770 int res1 = 0 ;
31771 PyObject * obj0 = 0 ;
31772 char * kwnames[] = {
31773 (char *) "bitmap", NULL
31774 };
31775
31776 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) SWIG_fail;
31777 if (obj0) {
31778 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
31779 if (!SWIG_IsOK(res1)) {
31780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
31781 }
31782 if (!argp1) {
31783 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
31784 }
31785 arg1 = reinterpret_cast< wxBitmap * >(argp1);
31786 }
31787 {
31788 PyThreadState* __tstate = wxPyBeginAllowThreads();
31789 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
31790 wxPyEndAllowThreads(__tstate);
31791 if (PyErr_Occurred()) SWIG_fail;
31792 }
31793 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_NEW | 0 );
31794 return resultobj;
31795 fail:
31796 return NULL;
31797 }
31798
31799
31800 SWIGINTERN PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31801 PyObject *resultobj = 0;
31802 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
31803 PyObject *arg2 = (PyObject *) 0 ;
31804 PyObject *arg3 = (PyObject *) 0 ;
31805 void *argp1 = 0 ;
31806 int res1 = 0 ;
31807 PyObject * obj0 = 0 ;
31808 PyObject * obj1 = 0 ;
31809 PyObject * obj2 = 0 ;
31810 char * kwnames[] = {
31811 (char *) "self",(char *) "self",(char *) "_class", NULL
31812 };
31813
31814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyBitmapDataObject, 0 | 0 );
31816 if (!SWIG_IsOK(res1)) {
31817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyBitmapDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyBitmapDataObject *""'");
31818 }
31819 arg1 = reinterpret_cast< wxPyBitmapDataObject * >(argp1);
31820 arg2 = obj1;
31821 arg3 = obj2;
31822 {
31823 PyThreadState* __tstate = wxPyBeginAllowThreads();
31824 (arg1)->_setCallbackInfo(arg2,arg3);
31825 wxPyEndAllowThreads(__tstate);
31826 if (PyErr_Occurred()) SWIG_fail;
31827 }
31828 resultobj = SWIG_Py_Void();
31829 return resultobj;
31830 fail:
31831 return NULL;
31832 }
31833
31834
31835 SWIGINTERN PyObject *PyBitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31836 PyObject *obj;
31837 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31838 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyBitmapDataObject, SWIG_NewClientData(obj));
31839 return SWIG_Py_Void();
31840 }
31841
31842 SWIGINTERN PyObject *PyBitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31843 return SWIG_Python_InitShadowInstance(args);
31844 }
31845
31846 SWIGINTERN PyObject *_wrap_new_FileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31847 PyObject *resultobj = 0;
31848 wxFileDataObject *result = 0 ;
31849
31850 if (!SWIG_Python_UnpackTuple(args,"new_FileDataObject",0,0,0)) SWIG_fail;
31851 {
31852 PyThreadState* __tstate = wxPyBeginAllowThreads();
31853 result = (wxFileDataObject *)new wxFileDataObject();
31854 wxPyEndAllowThreads(__tstate);
31855 if (PyErr_Occurred()) SWIG_fail;
31856 }
31857 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_NEW | 0 );
31858 return resultobj;
31859 fail:
31860 return NULL;
31861 }
31862
31863
31864 SWIGINTERN PyObject *_wrap_FileDataObject_GetFilenames(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31865 PyObject *resultobj = 0;
31866 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
31867 wxArrayString *result = 0 ;
31868 void *argp1 = 0 ;
31869 int res1 = 0 ;
31870 PyObject *swig_obj[1] ;
31871
31872 if (!args) SWIG_fail;
31873 swig_obj[0] = args;
31874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
31875 if (!SWIG_IsOK(res1)) {
31876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_GetFilenames" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
31877 }
31878 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
31879 {
31880 PyThreadState* __tstate = wxPyBeginAllowThreads();
31881 {
31882 wxArrayString const &_result_ref = (arg1)->GetFilenames();
31883 result = (wxArrayString *) &_result_ref;
31884 }
31885 wxPyEndAllowThreads(__tstate);
31886 if (PyErr_Occurred()) SWIG_fail;
31887 }
31888 {
31889 resultobj = wxArrayString2PyList_helper(*result);
31890 }
31891 return resultobj;
31892 fail:
31893 return NULL;
31894 }
31895
31896
31897 SWIGINTERN PyObject *_wrap_FileDataObject_AddFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31898 PyObject *resultobj = 0;
31899 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
31900 wxString *arg2 = 0 ;
31901 void *argp1 = 0 ;
31902 int res1 = 0 ;
31903 bool temp2 = false ;
31904 PyObject * obj0 = 0 ;
31905 PyObject * obj1 = 0 ;
31906 char * kwnames[] = {
31907 (char *) "self",(char *) "filename", NULL
31908 };
31909
31910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) SWIG_fail;
31911 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
31912 if (!SWIG_IsOK(res1)) {
31913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_AddFile" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
31914 }
31915 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
31916 {
31917 arg2 = wxString_in_helper(obj1);
31918 if (arg2 == NULL) SWIG_fail;
31919 temp2 = true;
31920 }
31921 {
31922 PyThreadState* __tstate = wxPyBeginAllowThreads();
31923 (arg1)->AddFile((wxString const &)*arg2);
31924 wxPyEndAllowThreads(__tstate);
31925 if (PyErr_Occurred()) SWIG_fail;
31926 }
31927 resultobj = SWIG_Py_Void();
31928 {
31929 if (temp2)
31930 delete arg2;
31931 }
31932 return resultobj;
31933 fail:
31934 {
31935 if (temp2)
31936 delete arg2;
31937 }
31938 return NULL;
31939 }
31940
31941
31942 SWIGINTERN PyObject *FileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31943 PyObject *obj;
31944 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31945 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileDataObject, SWIG_NewClientData(obj));
31946 return SWIG_Py_Void();
31947 }
31948
31949 SWIGINTERN PyObject *FileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31950 return SWIG_Python_InitShadowInstance(args);
31951 }
31952
31953 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31954 PyObject *resultobj = 0;
31955 wxDataFormat *arg1 = 0 ;
31956 wxCustomDataObject *result = 0 ;
31957 void *argp1 = 0 ;
31958 int res1 = 0 ;
31959
31960 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
31961 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
31962 if (!SWIG_IsOK(res1)) {
31963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31964 }
31965 if (!argp1) {
31966 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31967 }
31968 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31969 {
31970 PyThreadState* __tstate = wxPyBeginAllowThreads();
31971 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
31972 wxPyEndAllowThreads(__tstate);
31973 if (PyErr_Occurred()) SWIG_fail;
31974 }
31975 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
31976 return resultobj;
31977 fail:
31978 return NULL;
31979 }
31980
31981
31982 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31983 PyObject *resultobj = 0;
31984 wxString *arg1 = 0 ;
31985 wxCustomDataObject *result = 0 ;
31986 bool temp1 = false ;
31987
31988 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
31989 {
31990 arg1 = wxString_in_helper(swig_obj[0]);
31991 if (arg1 == NULL) SWIG_fail;
31992 temp1 = true;
31993 }
31994 {
31995 PyThreadState* __tstate = wxPyBeginAllowThreads();
31996 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
31997 wxPyEndAllowThreads(__tstate);
31998 if (PyErr_Occurred()) SWIG_fail;
31999 }
32000 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
32001 {
32002 if (temp1)
32003 delete arg1;
32004 }
32005 return resultobj;
32006 fail:
32007 {
32008 if (temp1)
32009 delete arg1;
32010 }
32011 return NULL;
32012 }
32013
32014
32015 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
32016 PyObject *resultobj = 0;
32017 wxCustomDataObject *result = 0 ;
32018
32019 if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
32020 {
32021 PyThreadState* __tstate = wxPyBeginAllowThreads();
32022 result = (wxCustomDataObject *)new wxCustomDataObject();
32023 wxPyEndAllowThreads(__tstate);
32024 if (PyErr_Occurred()) SWIG_fail;
32025 }
32026 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
32027 return resultobj;
32028 fail:
32029 return NULL;
32030 }
32031
32032
32033 SWIGINTERN PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
32034 int argc;
32035 PyObject *argv[2];
32036
32037 if (!(argc = SWIG_Python_UnpackTuple(args,"new_CustomDataObject",0,1,argv))) SWIG_fail;
32038 --argc;
32039 if (argc == 0) {
32040 return _wrap_new_CustomDataObject__SWIG_2(self, argc, argv);
32041 }
32042 if (argc == 1) {
32043 int _v = 0;
32044 {
32045 {
32046 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
32047 }
32048 }
32049 if (!_v) goto check_2;
32050 return _wrap_new_CustomDataObject__SWIG_1(self, argc, argv);
32051 }
32052 check_2:
32053
32054 if (argc == 1) {
32055 return _wrap_new_CustomDataObject__SWIG_0(self, argc, argv);
32056 }
32057
32058 fail:
32059 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
32060 return NULL;
32061 }
32062
32063
32064 SWIGINTERN PyObject *_wrap_CustomDataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32065 PyObject *resultobj = 0;
32066 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
32067 PyObject *arg2 = (PyObject *) 0 ;
32068 bool result;
32069 void *argp1 = 0 ;
32070 int res1 = 0 ;
32071 PyObject * obj0 = 0 ;
32072 PyObject * obj1 = 0 ;
32073 char * kwnames[] = {
32074 (char *) "self",(char *) "data", NULL
32075 };
32076
32077 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
32078 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
32079 if (!SWIG_IsOK(res1)) {
32080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_SetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
32081 }
32082 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
32083 arg2 = obj1;
32084 {
32085 PyThreadState* __tstate = wxPyBeginAllowThreads();
32086 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
32087 wxPyEndAllowThreads(__tstate);
32088 if (PyErr_Occurred()) SWIG_fail;
32089 }
32090 {
32091 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32092 }
32093 return resultobj;
32094 fail:
32095 return NULL;
32096 }
32097
32098
32099 SWIGINTERN PyObject *_wrap_CustomDataObject_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32100 PyObject *resultobj = 0;
32101 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
32102 size_t result;
32103 void *argp1 = 0 ;
32104 int res1 = 0 ;
32105 PyObject *swig_obj[1] ;
32106
32107 if (!args) SWIG_fail;
32108 swig_obj[0] = args;
32109 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
32110 if (!SWIG_IsOK(res1)) {
32111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetSize" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
32112 }
32113 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
32114 {
32115 PyThreadState* __tstate = wxPyBeginAllowThreads();
32116 result = (size_t)(arg1)->GetSize();
32117 wxPyEndAllowThreads(__tstate);
32118 if (PyErr_Occurred()) SWIG_fail;
32119 }
32120 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32121 return resultobj;
32122 fail:
32123 return NULL;
32124 }
32125
32126
32127 SWIGINTERN PyObject *_wrap_CustomDataObject_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32128 PyObject *resultobj = 0;
32129 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
32130 PyObject *result = 0 ;
32131 void *argp1 = 0 ;
32132 int res1 = 0 ;
32133 PyObject *swig_obj[1] ;
32134
32135 if (!args) SWIG_fail;
32136 swig_obj[0] = args;
32137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
32138 if (!SWIG_IsOK(res1)) {
32139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
32140 }
32141 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
32142 {
32143 PyThreadState* __tstate = wxPyBeginAllowThreads();
32144 result = (PyObject *)wxCustomDataObject_GetData(arg1);
32145 wxPyEndAllowThreads(__tstate);
32146 if (PyErr_Occurred()) SWIG_fail;
32147 }
32148 resultobj = result;
32149 return resultobj;
32150 fail:
32151 return NULL;
32152 }
32153
32154
32155 SWIGINTERN PyObject *CustomDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32156 PyObject *obj;
32157 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32158 SWIG_TypeNewClientData(SWIGTYPE_p_wxCustomDataObject, SWIG_NewClientData(obj));
32159 return SWIG_Py_Void();
32160 }
32161
32162 SWIGINTERN PyObject *CustomDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32163 return SWIG_Python_InitShadowInstance(args);
32164 }
32165
32166 SWIGINTERN PyObject *_wrap_new_URLDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32167 PyObject *resultobj = 0;
32168 wxURLDataObject *result = 0 ;
32169
32170 if (!SWIG_Python_UnpackTuple(args,"new_URLDataObject",0,0,0)) SWIG_fail;
32171 {
32172 PyThreadState* __tstate = wxPyBeginAllowThreads();
32173 result = (wxURLDataObject *)new wxURLDataObject();
32174 wxPyEndAllowThreads(__tstate);
32175 if (PyErr_Occurred()) SWIG_fail;
32176 }
32177 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_NEW | 0 );
32178 return resultobj;
32179 fail:
32180 return NULL;
32181 }
32182
32183
32184 SWIGINTERN PyObject *_wrap_URLDataObject_GetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32185 PyObject *resultobj = 0;
32186 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
32187 wxString result;
32188 void *argp1 = 0 ;
32189 int res1 = 0 ;
32190 PyObject *swig_obj[1] ;
32191
32192 if (!args) SWIG_fail;
32193 swig_obj[0] = args;
32194 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
32195 if (!SWIG_IsOK(res1)) {
32196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_GetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
32197 }
32198 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
32199 {
32200 PyThreadState* __tstate = wxPyBeginAllowThreads();
32201 result = (arg1)->GetURL();
32202 wxPyEndAllowThreads(__tstate);
32203 if (PyErr_Occurred()) SWIG_fail;
32204 }
32205 {
32206 #if wxUSE_UNICODE
32207 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32208 #else
32209 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32210 #endif
32211 }
32212 return resultobj;
32213 fail:
32214 return NULL;
32215 }
32216
32217
32218 SWIGINTERN PyObject *_wrap_URLDataObject_SetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32219 PyObject *resultobj = 0;
32220 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
32221 wxString *arg2 = 0 ;
32222 void *argp1 = 0 ;
32223 int res1 = 0 ;
32224 bool temp2 = false ;
32225 PyObject * obj0 = 0 ;
32226 PyObject * obj1 = 0 ;
32227 char * kwnames[] = {
32228 (char *) "self",(char *) "url", NULL
32229 };
32230
32231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) SWIG_fail;
32232 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
32233 if (!SWIG_IsOK(res1)) {
32234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_SetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
32235 }
32236 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
32237 {
32238 arg2 = wxString_in_helper(obj1);
32239 if (arg2 == NULL) SWIG_fail;
32240 temp2 = true;
32241 }
32242 {
32243 PyThreadState* __tstate = wxPyBeginAllowThreads();
32244 (arg1)->SetURL((wxString const &)*arg2);
32245 wxPyEndAllowThreads(__tstate);
32246 if (PyErr_Occurred()) SWIG_fail;
32247 }
32248 resultobj = SWIG_Py_Void();
32249 {
32250 if (temp2)
32251 delete arg2;
32252 }
32253 return resultobj;
32254 fail:
32255 {
32256 if (temp2)
32257 delete arg2;
32258 }
32259 return NULL;
32260 }
32261
32262
32263 SWIGINTERN PyObject *URLDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32264 PyObject *obj;
32265 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32266 SWIG_TypeNewClientData(SWIGTYPE_p_wxURLDataObject, SWIG_NewClientData(obj));
32267 return SWIG_Py_Void();
32268 }
32269
32270 SWIGINTERN PyObject *URLDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32271 return SWIG_Python_InitShadowInstance(args);
32272 }
32273
32274 SWIGINTERN PyObject *_wrap_new_MetafileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32275 PyObject *resultobj = 0;
32276 wxMetafileDataObject *result = 0 ;
32277
32278 if (!SWIG_Python_UnpackTuple(args,"new_MetafileDataObject",0,0,0)) SWIG_fail;
32279 {
32280 PyThreadState* __tstate = wxPyBeginAllowThreads();
32281 result = (wxMetafileDataObject *)new wxMetafileDataObject();
32282 wxPyEndAllowThreads(__tstate);
32283 if (PyErr_Occurred()) SWIG_fail;
32284 }
32285 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_NEW | 0 );
32286 return resultobj;
32287 fail:
32288 return NULL;
32289 }
32290
32291
32292 SWIGINTERN PyObject *MetafileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32293 PyObject *obj;
32294 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32295 SWIG_TypeNewClientData(SWIGTYPE_p_wxMetafileDataObject, SWIG_NewClientData(obj));
32296 return SWIG_Py_Void();
32297 }
32298
32299 SWIGINTERN PyObject *MetafileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32300 return SWIG_Python_InitShadowInstance(args);
32301 }
32302
32303 SWIGINTERN PyObject *_wrap_IsDragResultOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32304 PyObject *resultobj = 0;
32305 wxDragResult arg1 ;
32306 bool result;
32307 int val1 ;
32308 int ecode1 = 0 ;
32309 PyObject * obj0 = 0 ;
32310 char * kwnames[] = {
32311 (char *) "res", NULL
32312 };
32313
32314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) SWIG_fail;
32315 ecode1 = SWIG_AsVal_int(obj0, &val1);
32316 if (!SWIG_IsOK(ecode1)) {
32317 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsDragResultOk" "', expected argument " "1"" of type '" "wxDragResult""'");
32318 }
32319 arg1 = static_cast< wxDragResult >(val1);
32320 {
32321 PyThreadState* __tstate = wxPyBeginAllowThreads();
32322 result = (bool)wxIsDragResultOk(arg1);
32323 wxPyEndAllowThreads(__tstate);
32324 if (PyErr_Occurred()) SWIG_fail;
32325 }
32326 {
32327 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32328 }
32329 return resultobj;
32330 fail:
32331 return NULL;
32332 }
32333
32334
32335 SWIGINTERN PyObject *_wrap_new_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32336 PyObject *resultobj = 0;
32337 wxWindow *arg1 = (wxWindow *) 0 ;
32338 wxIcon const &arg2_defvalue = wxNullIcon ;
32339 wxIcon *arg2 = (wxIcon *) &arg2_defvalue ;
32340 wxIcon const &arg3_defvalue = wxNullIcon ;
32341 wxIcon *arg3 = (wxIcon *) &arg3_defvalue ;
32342 wxIcon const &arg4_defvalue = wxNullIcon ;
32343 wxIcon *arg4 = (wxIcon *) &arg4_defvalue ;
32344 wxPyDropSource *result = 0 ;
32345 void *argp1 = 0 ;
32346 int res1 = 0 ;
32347 void *argp2 = 0 ;
32348 int res2 = 0 ;
32349 void *argp3 = 0 ;
32350 int res3 = 0 ;
32351 void *argp4 = 0 ;
32352 int res4 = 0 ;
32353 PyObject * obj0 = 0 ;
32354 PyObject * obj1 = 0 ;
32355 PyObject * obj2 = 0 ;
32356 PyObject * obj3 = 0 ;
32357 char * kwnames[] = {
32358 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
32359 };
32360
32361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32362 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32363 if (!SWIG_IsOK(res1)) {
32364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropSource" "', expected argument " "1"" of type '" "wxWindow *""'");
32365 }
32366 arg1 = reinterpret_cast< wxWindow * >(argp1);
32367 if (obj1) {
32368 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxIcon, 0 | 0);
32369 if (!SWIG_IsOK(res2)) {
32370 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxIcon const &""'");
32371 }
32372 if (!argp2) {
32373 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxIcon const &""'");
32374 }
32375 arg2 = reinterpret_cast< wxIcon * >(argp2);
32376 }
32377 if (obj2) {
32378 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIcon, 0 | 0);
32379 if (!SWIG_IsOK(res3)) {
32380 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxIcon const &""'");
32381 }
32382 if (!argp3) {
32383 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxIcon const &""'");
32384 }
32385 arg3 = reinterpret_cast< wxIcon * >(argp3);
32386 }
32387 if (obj3) {
32388 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxIcon, 0 | 0);
32389 if (!SWIG_IsOK(res4)) {
32390 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxIcon const &""'");
32391 }
32392 if (!argp4) {
32393 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxIcon const &""'");
32394 }
32395 arg4 = reinterpret_cast< wxIcon * >(argp4);
32396 }
32397 {
32398 PyThreadState* __tstate = wxPyBeginAllowThreads();
32399 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxIcon const &)*arg2,(wxIcon const &)*arg3,(wxIcon const &)*arg4);
32400 wxPyEndAllowThreads(__tstate);
32401 if (PyErr_Occurred()) SWIG_fail;
32402 }
32403 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_NEW | 0 );
32404 return resultobj;
32405 fail:
32406 return NULL;
32407 }
32408
32409
32410 SWIGINTERN PyObject *_wrap_DropSource__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32411 PyObject *resultobj = 0;
32412 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32413 PyObject *arg2 = (PyObject *) 0 ;
32414 PyObject *arg3 = (PyObject *) 0 ;
32415 int arg4 ;
32416 void *argp1 = 0 ;
32417 int res1 = 0 ;
32418 int val4 ;
32419 int ecode4 = 0 ;
32420 PyObject * obj0 = 0 ;
32421 PyObject * obj1 = 0 ;
32422 PyObject * obj2 = 0 ;
32423 PyObject * obj3 = 0 ;
32424 char * kwnames[] = {
32425 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
32426 };
32427
32428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32429 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32430 if (!SWIG_IsOK(res1)) {
32431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32432 }
32433 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32434 arg2 = obj1;
32435 arg3 = obj2;
32436 ecode4 = SWIG_AsVal_int(obj3, &val4);
32437 if (!SWIG_IsOK(ecode4)) {
32438 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropSource__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
32439 }
32440 arg4 = static_cast< int >(val4);
32441 {
32442 PyThreadState* __tstate = wxPyBeginAllowThreads();
32443 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
32444 wxPyEndAllowThreads(__tstate);
32445 if (PyErr_Occurred()) SWIG_fail;
32446 }
32447 resultobj = SWIG_Py_Void();
32448 return resultobj;
32449 fail:
32450 return NULL;
32451 }
32452
32453
32454 SWIGINTERN PyObject *_wrap_delete_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32455 PyObject *resultobj = 0;
32456 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32457 void *argp1 = 0 ;
32458 int res1 = 0 ;
32459 PyObject *swig_obj[1] ;
32460
32461 if (!args) SWIG_fail;
32462 swig_obj[0] = args;
32463 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_DISOWN | 0 );
32464 if (!SWIG_IsOK(res1)) {
32465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropSource" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32466 }
32467 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32468 {
32469 PyThreadState* __tstate = wxPyBeginAllowThreads();
32470 delete arg1;
32471
32472 wxPyEndAllowThreads(__tstate);
32473 if (PyErr_Occurred()) SWIG_fail;
32474 }
32475 resultobj = SWIG_Py_Void();
32476 return resultobj;
32477 fail:
32478 return NULL;
32479 }
32480
32481
32482 SWIGINTERN PyObject *_wrap_DropSource_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32483 PyObject *resultobj = 0;
32484 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32485 wxDataObject *arg2 = 0 ;
32486 void *argp1 = 0 ;
32487 int res1 = 0 ;
32488 void *argp2 = 0 ;
32489 int res2 = 0 ;
32490 PyObject * obj0 = 0 ;
32491 PyObject * obj1 = 0 ;
32492 char * kwnames[] = {
32493 (char *) "self",(char *) "data", NULL
32494 };
32495
32496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
32497 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32498 if (!SWIG_IsOK(res1)) {
32499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetData" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32500 }
32501 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32502 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
32503 if (!SWIG_IsOK(res2)) {
32504 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
32505 }
32506 if (!argp2) {
32507 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
32508 }
32509 arg2 = reinterpret_cast< wxDataObject * >(argp2);
32510 {
32511 PyThreadState* __tstate = wxPyBeginAllowThreads();
32512 (arg1)->SetData(*arg2);
32513 wxPyEndAllowThreads(__tstate);
32514 if (PyErr_Occurred()) SWIG_fail;
32515 }
32516 resultobj = SWIG_Py_Void();
32517 return resultobj;
32518 fail:
32519 return NULL;
32520 }
32521
32522
32523 SWIGINTERN PyObject *_wrap_DropSource_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32524 PyObject *resultobj = 0;
32525 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32526 wxDataObject *result = 0 ;
32527 void *argp1 = 0 ;
32528 int res1 = 0 ;
32529 PyObject *swig_obj[1] ;
32530
32531 if (!args) SWIG_fail;
32532 swig_obj[0] = args;
32533 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32534 if (!SWIG_IsOK(res1)) {
32535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32536 }
32537 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32538 {
32539 PyThreadState* __tstate = wxPyBeginAllowThreads();
32540 result = (wxDataObject *)(arg1)->GetDataObject();
32541 wxPyEndAllowThreads(__tstate);
32542 if (PyErr_Occurred()) SWIG_fail;
32543 }
32544 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
32545 return resultobj;
32546 fail:
32547 return NULL;
32548 }
32549
32550
32551 SWIGINTERN PyObject *_wrap_DropSource_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32552 PyObject *resultobj = 0;
32553 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32554 wxDragResult arg2 ;
32555 wxCursor *arg3 = 0 ;
32556 void *argp1 = 0 ;
32557 int res1 = 0 ;
32558 int val2 ;
32559 int ecode2 = 0 ;
32560 void *argp3 = 0 ;
32561 int res3 = 0 ;
32562 PyObject * obj0 = 0 ;
32563 PyObject * obj1 = 0 ;
32564 PyObject * obj2 = 0 ;
32565 char * kwnames[] = {
32566 (char *) "self",(char *) "res",(char *) "cursor", NULL
32567 };
32568
32569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32570 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32571 if (!SWIG_IsOK(res1)) {
32572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetCursor" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32573 }
32574 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32575 ecode2 = SWIG_AsVal_int(obj1, &val2);
32576 if (!SWIG_IsOK(ecode2)) {
32577 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_SetCursor" "', expected argument " "2"" of type '" "wxDragResult""'");
32578 }
32579 arg2 = static_cast< wxDragResult >(val2);
32580 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxCursor, 0 | 0);
32581 if (!SWIG_IsOK(res3)) {
32582 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
32583 }
32584 if (!argp3) {
32585 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
32586 }
32587 arg3 = reinterpret_cast< wxCursor * >(argp3);
32588 {
32589 PyThreadState* __tstate = wxPyBeginAllowThreads();
32590 (arg1)->SetCursor(arg2,(wxCursor const &)*arg3);
32591 wxPyEndAllowThreads(__tstate);
32592 if (PyErr_Occurred()) SWIG_fail;
32593 }
32594 resultobj = SWIG_Py_Void();
32595 return resultobj;
32596 fail:
32597 return NULL;
32598 }
32599
32600
32601 SWIGINTERN PyObject *_wrap_DropSource_DoDragDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32602 PyObject *resultobj = 0;
32603 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32604 int arg2 = (int) wxDrag_CopyOnly ;
32605 wxDragResult result;
32606 void *argp1 = 0 ;
32607 int res1 = 0 ;
32608 int val2 ;
32609 int ecode2 = 0 ;
32610 PyObject * obj0 = 0 ;
32611 PyObject * obj1 = 0 ;
32612 char * kwnames[] = {
32613 (char *) "self",(char *) "flags", NULL
32614 };
32615
32616 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) SWIG_fail;
32617 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32618 if (!SWIG_IsOK(res1)) {
32619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_DoDragDrop" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32620 }
32621 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32622 if (obj1) {
32623 ecode2 = SWIG_AsVal_int(obj1, &val2);
32624 if (!SWIG_IsOK(ecode2)) {
32625 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_DoDragDrop" "', expected argument " "2"" of type '" "int""'");
32626 }
32627 arg2 = static_cast< int >(val2);
32628 }
32629 {
32630 PyThreadState* __tstate = wxPyBeginAllowThreads();
32631 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
32632 wxPyEndAllowThreads(__tstate);
32633 if (PyErr_Occurred()) SWIG_fail;
32634 }
32635 resultobj = SWIG_From_int(static_cast< int >(result));
32636 return resultobj;
32637 fail:
32638 return NULL;
32639 }
32640
32641
32642 SWIGINTERN PyObject *_wrap_DropSource_GiveFeedback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32643 PyObject *resultobj = 0;
32644 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32645 wxDragResult arg2 ;
32646 bool result;
32647 void *argp1 = 0 ;
32648 int res1 = 0 ;
32649 int val2 ;
32650 int ecode2 = 0 ;
32651 PyObject * obj0 = 0 ;
32652 PyObject * obj1 = 0 ;
32653 char * kwnames[] = {
32654 (char *) "self",(char *) "effect", NULL
32655 };
32656
32657 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_GiveFeedback",kwnames,&obj0,&obj1)) SWIG_fail;
32658 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32659 if (!SWIG_IsOK(res1)) {
32660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GiveFeedback" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32661 }
32662 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32663 ecode2 = SWIG_AsVal_int(obj1, &val2);
32664 if (!SWIG_IsOK(ecode2)) {
32665 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_GiveFeedback" "', expected argument " "2"" of type '" "wxDragResult""'");
32666 }
32667 arg2 = static_cast< wxDragResult >(val2);
32668 {
32669 PyThreadState* __tstate = wxPyBeginAllowThreads();
32670 result = (bool)(arg1)->GiveFeedback(arg2);
32671 wxPyEndAllowThreads(__tstate);
32672 if (PyErr_Occurred()) SWIG_fail;
32673 }
32674 {
32675 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32676 }
32677 return resultobj;
32678 fail:
32679 return NULL;
32680 }
32681
32682
32683 SWIGINTERN PyObject *DropSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32684 PyObject *obj;
32685 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32686 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropSource, SWIG_NewClientData(obj));
32687 return SWIG_Py_Void();
32688 }
32689
32690 SWIGINTERN PyObject *DropSource_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32691 return SWIG_Python_InitShadowInstance(args);
32692 }
32693
32694 SWIGINTERN PyObject *_wrap_new_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32695 PyObject *resultobj = 0;
32696 wxDataObject *arg1 = (wxDataObject *) NULL ;
32697 wxPyDropTarget *result = 0 ;
32698 int res1 = 0 ;
32699 PyObject * obj0 = 0 ;
32700 char * kwnames[] = {
32701 (char *) "dataObject", NULL
32702 };
32703
32704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) SWIG_fail;
32705 if (obj0) {
32706 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
32707 if (!SWIG_IsOK(res1)) {
32708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropTarget" "', expected argument " "1"" of type '" "wxDataObject *""'");
32709 }
32710 }
32711 {
32712 PyThreadState* __tstate = wxPyBeginAllowThreads();
32713 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
32714 wxPyEndAllowThreads(__tstate);
32715 if (PyErr_Occurred()) SWIG_fail;
32716 }
32717 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_NEW | 0 );
32718 return resultobj;
32719 fail:
32720 return NULL;
32721 }
32722
32723
32724 SWIGINTERN PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32725 PyObject *resultobj = 0;
32726 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32727 PyObject *arg2 = (PyObject *) 0 ;
32728 PyObject *arg3 = (PyObject *) 0 ;
32729 void *argp1 = 0 ;
32730 int res1 = 0 ;
32731 PyObject * obj0 = 0 ;
32732 PyObject * obj1 = 0 ;
32733 PyObject * obj2 = 0 ;
32734 char * kwnames[] = {
32735 (char *) "self",(char *) "self",(char *) "_class", NULL
32736 };
32737
32738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32740 if (!SWIG_IsOK(res1)) {
32741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32742 }
32743 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32744 arg2 = obj1;
32745 arg3 = obj2;
32746 {
32747 PyThreadState* __tstate = wxPyBeginAllowThreads();
32748 (arg1)->_setCallbackInfo(arg2,arg3);
32749 wxPyEndAllowThreads(__tstate);
32750 if (PyErr_Occurred()) SWIG_fail;
32751 }
32752 resultobj = SWIG_Py_Void();
32753 return resultobj;
32754 fail:
32755 return NULL;
32756 }
32757
32758
32759 SWIGINTERN PyObject *_wrap_delete_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32760 PyObject *resultobj = 0;
32761 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32762 void *argp1 = 0 ;
32763 int res1 = 0 ;
32764 PyObject *swig_obj[1] ;
32765
32766 if (!args) SWIG_fail;
32767 swig_obj[0] = args;
32768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
32769 if (!SWIG_IsOK(res1)) {
32770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropTarget" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32771 }
32772 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32773 {
32774 PyThreadState* __tstate = wxPyBeginAllowThreads();
32775 delete arg1;
32776
32777 wxPyEndAllowThreads(__tstate);
32778 if (PyErr_Occurred()) SWIG_fail;
32779 }
32780 resultobj = SWIG_Py_Void();
32781 return resultobj;
32782 fail:
32783 return NULL;
32784 }
32785
32786
32787 SWIGINTERN PyObject *_wrap_DropTarget_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32788 PyObject *resultobj = 0;
32789 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32790 wxDataObject *result = 0 ;
32791 void *argp1 = 0 ;
32792 int res1 = 0 ;
32793 PyObject *swig_obj[1] ;
32794
32795 if (!args) SWIG_fail;
32796 swig_obj[0] = args;
32797 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32798 if (!SWIG_IsOK(res1)) {
32799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32800 }
32801 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32802 {
32803 PyThreadState* __tstate = wxPyBeginAllowThreads();
32804 result = (wxDataObject *)(arg1)->GetDataObject();
32805 wxPyEndAllowThreads(__tstate);
32806 if (PyErr_Occurred()) SWIG_fail;
32807 }
32808 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
32809 return resultobj;
32810 fail:
32811 return NULL;
32812 }
32813
32814
32815 SWIGINTERN PyObject *_wrap_DropTarget_SetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32816 PyObject *resultobj = 0;
32817 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32818 wxDataObject *arg2 = (wxDataObject *) 0 ;
32819 void *argp1 = 0 ;
32820 int res1 = 0 ;
32821 int res2 = 0 ;
32822 PyObject * obj0 = 0 ;
32823 PyObject * obj1 = 0 ;
32824 char * kwnames[] = {
32825 (char *) "self",(char *) "dataObject", NULL
32826 };
32827
32828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) SWIG_fail;
32829 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32830 if (!SWIG_IsOK(res1)) {
32831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32832 }
32833 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32834 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
32835 if (!SWIG_IsOK(res2)) {
32836 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropTarget_SetDataObject" "', expected argument " "2"" of type '" "wxDataObject *""'");
32837 }
32838 {
32839 PyThreadState* __tstate = wxPyBeginAllowThreads();
32840 (arg1)->SetDataObject(arg2);
32841 wxPyEndAllowThreads(__tstate);
32842 if (PyErr_Occurred()) SWIG_fail;
32843 }
32844 resultobj = SWIG_Py_Void();
32845 return resultobj;
32846 fail:
32847 return NULL;
32848 }
32849
32850
32851 SWIGINTERN PyObject *_wrap_DropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32852 PyObject *resultobj = 0;
32853 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32854 int arg2 ;
32855 int arg3 ;
32856 wxDragResult arg4 ;
32857 wxDragResult result;
32858 void *argp1 = 0 ;
32859 int res1 = 0 ;
32860 int val2 ;
32861 int ecode2 = 0 ;
32862 int val3 ;
32863 int ecode3 = 0 ;
32864 int val4 ;
32865 int ecode4 = 0 ;
32866 PyObject * obj0 = 0 ;
32867 PyObject * obj1 = 0 ;
32868 PyObject * obj2 = 0 ;
32869 PyObject * obj3 = 0 ;
32870 char * kwnames[] = {
32871 (char *) "self",(char *) "x",(char *) "y",(char *) "_def", NULL
32872 };
32873
32874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32875 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32876 if (!SWIG_IsOK(res1)) {
32877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32878 }
32879 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32880 ecode2 = SWIG_AsVal_int(obj1, &val2);
32881 if (!SWIG_IsOK(ecode2)) {
32882 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
32883 }
32884 arg2 = static_cast< int >(val2);
32885 ecode3 = SWIG_AsVal_int(obj2, &val3);
32886 if (!SWIG_IsOK(ecode3)) {
32887 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
32888 }
32889 arg3 = static_cast< int >(val3);
32890 ecode4 = SWIG_AsVal_int(obj3, &val4);
32891 if (!SWIG_IsOK(ecode4)) {
32892 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
32893 }
32894 arg4 = static_cast< wxDragResult >(val4);
32895 {
32896 PyThreadState* __tstate = wxPyBeginAllowThreads();
32897 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
32898 wxPyEndAllowThreads(__tstate);
32899 if (PyErr_Occurred()) SWIG_fail;
32900 }
32901 resultobj = SWIG_From_int(static_cast< int >(result));
32902 return resultobj;
32903 fail:
32904 return NULL;
32905 }
32906
32907
32908 SWIGINTERN PyObject *_wrap_DropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32909 PyObject *resultobj = 0;
32910 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32911 int arg2 ;
32912 int arg3 ;
32913 wxDragResult arg4 ;
32914 wxDragResult result;
32915 void *argp1 = 0 ;
32916 int res1 = 0 ;
32917 int val2 ;
32918 int ecode2 = 0 ;
32919 int val3 ;
32920 int ecode3 = 0 ;
32921 int val4 ;
32922 int ecode4 = 0 ;
32923 PyObject * obj0 = 0 ;
32924 PyObject * obj1 = 0 ;
32925 PyObject * obj2 = 0 ;
32926 PyObject * obj3 = 0 ;
32927 char * kwnames[] = {
32928 (char *) "self",(char *) "x",(char *) "y",(char *) "_def", NULL
32929 };
32930
32931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32933 if (!SWIG_IsOK(res1)) {
32934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32935 }
32936 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32937 ecode2 = SWIG_AsVal_int(obj1, &val2);
32938 if (!SWIG_IsOK(ecode2)) {
32939 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
32940 }
32941 arg2 = static_cast< int >(val2);
32942 ecode3 = SWIG_AsVal_int(obj2, &val3);
32943 if (!SWIG_IsOK(ecode3)) {
32944 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
32945 }
32946 arg3 = static_cast< int >(val3);
32947 ecode4 = SWIG_AsVal_int(obj3, &val4);
32948 if (!SWIG_IsOK(ecode4)) {
32949 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
32950 }
32951 arg4 = static_cast< wxDragResult >(val4);
32952 {
32953 PyThreadState* __tstate = wxPyBeginAllowThreads();
32954 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
32955 wxPyEndAllowThreads(__tstate);
32956 if (PyErr_Occurred()) SWIG_fail;
32957 }
32958 resultobj = SWIG_From_int(static_cast< int >(result));
32959 return resultobj;
32960 fail:
32961 return NULL;
32962 }
32963
32964
32965 SWIGINTERN PyObject *_wrap_DropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32966 PyObject *resultobj = 0;
32967 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32968 void *argp1 = 0 ;
32969 int res1 = 0 ;
32970 PyObject *swig_obj[1] ;
32971
32972 if (!args) SWIG_fail;
32973 swig_obj[0] = args;
32974 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32975 if (!SWIG_IsOK(res1)) {
32976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32977 }
32978 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32979 {
32980 PyThreadState* __tstate = wxPyBeginAllowThreads();
32981 (arg1)->OnLeave();
32982 wxPyEndAllowThreads(__tstate);
32983 if (PyErr_Occurred()) SWIG_fail;
32984 }
32985 resultobj = SWIG_Py_Void();
32986 return resultobj;
32987 fail:
32988 return NULL;
32989 }
32990
32991
32992 SWIGINTERN PyObject *_wrap_DropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32993 PyObject *resultobj = 0;
32994 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32995 int arg2 ;
32996 int arg3 ;
32997 bool result;
32998 void *argp1 = 0 ;
32999 int res1 = 0 ;
33000 int val2 ;
33001 int ecode2 = 0 ;
33002 int val3 ;
33003 int ecode3 = 0 ;
33004 PyObject * obj0 = 0 ;
33005 PyObject * obj1 = 0 ;
33006 PyObject * obj2 = 0 ;
33007 char * kwnames[] = {
33008 (char *) "self",(char *) "x",(char *) "y", NULL
33009 };
33010
33011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33013 if (!SWIG_IsOK(res1)) {
33014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33015 }
33016 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33017 ecode2 = SWIG_AsVal_int(obj1, &val2);
33018 if (!SWIG_IsOK(ecode2)) {
33019 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
33020 }
33021 arg2 = static_cast< int >(val2);
33022 ecode3 = SWIG_AsVal_int(obj2, &val3);
33023 if (!SWIG_IsOK(ecode3)) {
33024 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
33025 }
33026 arg3 = static_cast< int >(val3);
33027 {
33028 PyThreadState* __tstate = wxPyBeginAllowThreads();
33029 result = (bool)(arg1)->OnDrop(arg2,arg3);
33030 wxPyEndAllowThreads(__tstate);
33031 if (PyErr_Occurred()) SWIG_fail;
33032 }
33033 {
33034 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33035 }
33036 return resultobj;
33037 fail:
33038 return NULL;
33039 }
33040
33041
33042 SWIGINTERN PyObject *_wrap_DropTarget_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33043 PyObject *resultobj = 0;
33044 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33045 bool result;
33046 void *argp1 = 0 ;
33047 int res1 = 0 ;
33048 PyObject *swig_obj[1] ;
33049
33050 if (!args) SWIG_fail;
33051 swig_obj[0] = args;
33052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33053 if (!SWIG_IsOK(res1)) {
33054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetData" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33055 }
33056 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33057 {
33058 PyThreadState* __tstate = wxPyBeginAllowThreads();
33059 result = (bool)(arg1)->GetData();
33060 wxPyEndAllowThreads(__tstate);
33061 if (PyErr_Occurred()) SWIG_fail;
33062 }
33063 {
33064 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33065 }
33066 return resultobj;
33067 fail:
33068 return NULL;
33069 }
33070
33071
33072 SWIGINTERN PyObject *_wrap_DropTarget_SetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33073 PyObject *resultobj = 0;
33074 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33075 wxDragResult arg2 ;
33076 void *argp1 = 0 ;
33077 int res1 = 0 ;
33078 int val2 ;
33079 int ecode2 = 0 ;
33080 PyObject * obj0 = 0 ;
33081 PyObject * obj1 = 0 ;
33082 char * kwnames[] = {
33083 (char *) "self",(char *) "action", NULL
33084 };
33085
33086 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDefaultAction",kwnames,&obj0,&obj1)) SWIG_fail;
33087 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33088 if (!SWIG_IsOK(res1)) {
33089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33090 }
33091 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33092 ecode2 = SWIG_AsVal_int(obj1, &val2);
33093 if (!SWIG_IsOK(ecode2)) {
33094 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "2"" of type '" "wxDragResult""'");
33095 }
33096 arg2 = static_cast< wxDragResult >(val2);
33097 {
33098 PyThreadState* __tstate = wxPyBeginAllowThreads();
33099 (arg1)->SetDefaultAction(arg2);
33100 wxPyEndAllowThreads(__tstate);
33101 if (PyErr_Occurred()) SWIG_fail;
33102 }
33103 resultobj = SWIG_Py_Void();
33104 return resultobj;
33105 fail:
33106 return NULL;
33107 }
33108
33109
33110 SWIGINTERN PyObject *_wrap_DropTarget_GetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33111 PyObject *resultobj = 0;
33112 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33113 wxDragResult result;
33114 void *argp1 = 0 ;
33115 int res1 = 0 ;
33116 PyObject *swig_obj[1] ;
33117
33118 if (!args) SWIG_fail;
33119 swig_obj[0] = args;
33120 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33121 if (!SWIG_IsOK(res1)) {
33122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33123 }
33124 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33125 {
33126 PyThreadState* __tstate = wxPyBeginAllowThreads();
33127 result = (wxDragResult)(arg1)->GetDefaultAction();
33128 wxPyEndAllowThreads(__tstate);
33129 if (PyErr_Occurred()) SWIG_fail;
33130 }
33131 resultobj = SWIG_From_int(static_cast< int >(result));
33132 return resultobj;
33133 fail:
33134 return NULL;
33135 }
33136
33137
33138 SWIGINTERN PyObject *DropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33139 PyObject *obj;
33140 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33141 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropTarget, SWIG_NewClientData(obj));
33142 return SWIG_Py_Void();
33143 }
33144
33145 SWIGINTERN PyObject *DropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33146 return SWIG_Python_InitShadowInstance(args);
33147 }
33148
33149 SWIGINTERN PyObject *_wrap_new_TextDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33150 PyObject *resultobj = 0;
33151 wxPyTextDropTarget *result = 0 ;
33152
33153 if (!SWIG_Python_UnpackTuple(args,"new_TextDropTarget",0,0,0)) SWIG_fail;
33154 {
33155 PyThreadState* __tstate = wxPyBeginAllowThreads();
33156 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
33157 wxPyEndAllowThreads(__tstate);
33158 if (PyErr_Occurred()) SWIG_fail;
33159 }
33160 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_NEW | 0 );
33161 return resultobj;
33162 fail:
33163 return NULL;
33164 }
33165
33166
33167 SWIGINTERN PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33168 PyObject *resultobj = 0;
33169 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33170 PyObject *arg2 = (PyObject *) 0 ;
33171 PyObject *arg3 = (PyObject *) 0 ;
33172 void *argp1 = 0 ;
33173 int res1 = 0 ;
33174 PyObject * obj0 = 0 ;
33175 PyObject * obj1 = 0 ;
33176 PyObject * obj2 = 0 ;
33177 char * kwnames[] = {
33178 (char *) "self",(char *) "self",(char *) "_class", NULL
33179 };
33180
33181 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33182 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33183 if (!SWIG_IsOK(res1)) {
33184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33185 }
33186 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33187 arg2 = obj1;
33188 arg3 = obj2;
33189 {
33190 PyThreadState* __tstate = wxPyBeginAllowThreads();
33191 (arg1)->_setCallbackInfo(arg2,arg3);
33192 wxPyEndAllowThreads(__tstate);
33193 if (PyErr_Occurred()) SWIG_fail;
33194 }
33195 resultobj = SWIG_Py_Void();
33196 return resultobj;
33197 fail:
33198 return NULL;
33199 }
33200
33201
33202 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDropText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33203 PyObject *resultobj = 0;
33204 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33205 int arg2 ;
33206 int arg3 ;
33207 wxString *arg4 = 0 ;
33208 bool result;
33209 void *argp1 = 0 ;
33210 int res1 = 0 ;
33211 int val2 ;
33212 int ecode2 = 0 ;
33213 int val3 ;
33214 int ecode3 = 0 ;
33215 bool temp4 = false ;
33216 PyObject * obj0 = 0 ;
33217 PyObject * obj1 = 0 ;
33218 PyObject * obj2 = 0 ;
33219 PyObject * obj3 = 0 ;
33220 char * kwnames[] = {
33221 (char *) "self",(char *) "x",(char *) "y",(char *) "text", NULL
33222 };
33223
33224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDropText",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33225 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33226 if (!SWIG_IsOK(res1)) {
33227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDropText" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33228 }
33229 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33230 ecode2 = SWIG_AsVal_int(obj1, &val2);
33231 if (!SWIG_IsOK(ecode2)) {
33232 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDropText" "', expected argument " "2"" of type '" "int""'");
33233 }
33234 arg2 = static_cast< int >(val2);
33235 ecode3 = SWIG_AsVal_int(obj2, &val3);
33236 if (!SWIG_IsOK(ecode3)) {
33237 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDropText" "', expected argument " "3"" of type '" "int""'");
33238 }
33239 arg3 = static_cast< int >(val3);
33240 {
33241 arg4 = wxString_in_helper(obj3);
33242 if (arg4 == NULL) SWIG_fail;
33243 temp4 = true;
33244 }
33245 {
33246 PyThreadState* __tstate = wxPyBeginAllowThreads();
33247 result = (bool)(arg1)->OnDropText(arg2,arg3,(wxString const &)*arg4);
33248 wxPyEndAllowThreads(__tstate);
33249 if (PyErr_Occurred()) SWIG_fail;
33250 }
33251 {
33252 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33253 }
33254 {
33255 if (temp4)
33256 delete arg4;
33257 }
33258 return resultobj;
33259 fail:
33260 {
33261 if (temp4)
33262 delete arg4;
33263 }
33264 return NULL;
33265 }
33266
33267
33268 SWIGINTERN PyObject *_wrap_TextDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33269 PyObject *resultobj = 0;
33270 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33271 int arg2 ;
33272 int arg3 ;
33273 wxDragResult arg4 ;
33274 wxDragResult result;
33275 void *argp1 = 0 ;
33276 int res1 = 0 ;
33277 int val2 ;
33278 int ecode2 = 0 ;
33279 int val3 ;
33280 int ecode3 = 0 ;
33281 int val4 ;
33282 int ecode4 = 0 ;
33283 PyObject * obj0 = 0 ;
33284 PyObject * obj1 = 0 ;
33285 PyObject * obj2 = 0 ;
33286 PyObject * obj3 = 0 ;
33287 char * kwnames[] = {
33288 (char *) "self",(char *) "x",(char *) "y",(char *) "_def", NULL
33289 };
33290
33291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33293 if (!SWIG_IsOK(res1)) {
33294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33295 }
33296 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33297 ecode2 = SWIG_AsVal_int(obj1, &val2);
33298 if (!SWIG_IsOK(ecode2)) {
33299 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
33300 }
33301 arg2 = static_cast< int >(val2);
33302 ecode3 = SWIG_AsVal_int(obj2, &val3);
33303 if (!SWIG_IsOK(ecode3)) {
33304 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
33305 }
33306 arg3 = static_cast< int >(val3);
33307 ecode4 = SWIG_AsVal_int(obj3, &val4);
33308 if (!SWIG_IsOK(ecode4)) {
33309 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
33310 }
33311 arg4 = static_cast< wxDragResult >(val4);
33312 {
33313 PyThreadState* __tstate = wxPyBeginAllowThreads();
33314 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
33315 wxPyEndAllowThreads(__tstate);
33316 if (PyErr_Occurred()) SWIG_fail;
33317 }
33318 resultobj = SWIG_From_int(static_cast< int >(result));
33319 return resultobj;
33320 fail:
33321 return NULL;
33322 }
33323
33324
33325 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33326 PyObject *resultobj = 0;
33327 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33328 int arg2 ;
33329 int arg3 ;
33330 wxDragResult arg4 ;
33331 wxDragResult result;
33332 void *argp1 = 0 ;
33333 int res1 = 0 ;
33334 int val2 ;
33335 int ecode2 = 0 ;
33336 int val3 ;
33337 int ecode3 = 0 ;
33338 int val4 ;
33339 int ecode4 = 0 ;
33340 PyObject * obj0 = 0 ;
33341 PyObject * obj1 = 0 ;
33342 PyObject * obj2 = 0 ;
33343 PyObject * obj3 = 0 ;
33344 char * kwnames[] = {
33345 (char *) "self",(char *) "x",(char *) "y",(char *) "_def", NULL
33346 };
33347
33348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33349 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33350 if (!SWIG_IsOK(res1)) {
33351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33352 }
33353 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33354 ecode2 = SWIG_AsVal_int(obj1, &val2);
33355 if (!SWIG_IsOK(ecode2)) {
33356 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
33357 }
33358 arg2 = static_cast< int >(val2);
33359 ecode3 = SWIG_AsVal_int(obj2, &val3);
33360 if (!SWIG_IsOK(ecode3)) {
33361 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
33362 }
33363 arg3 = static_cast< int >(val3);
33364 ecode4 = SWIG_AsVal_int(obj3, &val4);
33365 if (!SWIG_IsOK(ecode4)) {
33366 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
33367 }
33368 arg4 = static_cast< wxDragResult >(val4);
33369 {
33370 PyThreadState* __tstate = wxPyBeginAllowThreads();
33371 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
33372 wxPyEndAllowThreads(__tstate);
33373 if (PyErr_Occurred()) SWIG_fail;
33374 }
33375 resultobj = SWIG_From_int(static_cast< int >(result));
33376 return resultobj;
33377 fail:
33378 return NULL;
33379 }
33380
33381
33382 SWIGINTERN PyObject *_wrap_TextDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33383 PyObject *resultobj = 0;
33384 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33385 void *argp1 = 0 ;
33386 int res1 = 0 ;
33387 PyObject *swig_obj[1] ;
33388
33389 if (!args) SWIG_fail;
33390 swig_obj[0] = args;
33391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33392 if (!SWIG_IsOK(res1)) {
33393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33394 }
33395 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33396 {
33397 PyThreadState* __tstate = wxPyBeginAllowThreads();
33398 (arg1)->OnLeave();
33399 wxPyEndAllowThreads(__tstate);
33400 if (PyErr_Occurred()) SWIG_fail;
33401 }
33402 resultobj = SWIG_Py_Void();
33403 return resultobj;
33404 fail:
33405 return NULL;
33406 }
33407
33408
33409 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33410 PyObject *resultobj = 0;
33411 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33412 int arg2 ;
33413 int arg3 ;
33414 bool result;
33415 void *argp1 = 0 ;
33416 int res1 = 0 ;
33417 int val2 ;
33418 int ecode2 = 0 ;
33419 int val3 ;
33420 int ecode3 = 0 ;
33421 PyObject * obj0 = 0 ;
33422 PyObject * obj1 = 0 ;
33423 PyObject * obj2 = 0 ;
33424 char * kwnames[] = {
33425 (char *) "self",(char *) "x",(char *) "y", NULL
33426 };
33427
33428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33429 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33430 if (!SWIG_IsOK(res1)) {
33431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33432 }
33433 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33434 ecode2 = SWIG_AsVal_int(obj1, &val2);
33435 if (!SWIG_IsOK(ecode2)) {
33436 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
33437 }
33438 arg2 = static_cast< int >(val2);
33439 ecode3 = SWIG_AsVal_int(obj2, &val3);
33440 if (!SWIG_IsOK(ecode3)) {
33441 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
33442 }
33443 arg3 = static_cast< int >(val3);
33444 {
33445 PyThreadState* __tstate = wxPyBeginAllowThreads();
33446 result = (bool)(arg1)->OnDrop(arg2,arg3);
33447 wxPyEndAllowThreads(__tstate);
33448 if (PyErr_Occurred()) SWIG_fail;
33449 }
33450 {
33451 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33452 }
33453 return resultobj;
33454 fail:
33455 return NULL;
33456 }
33457
33458
33459 SWIGINTERN PyObject *_wrap_TextDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33460 PyObject *resultobj = 0;
33461 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33462 int arg2 ;
33463 int arg3 ;
33464 wxDragResult arg4 ;
33465 wxDragResult result;
33466 void *argp1 = 0 ;
33467 int res1 = 0 ;
33468 int val2 ;
33469 int ecode2 = 0 ;
33470 int val3 ;
33471 int ecode3 = 0 ;
33472 int val4 ;
33473 int ecode4 = 0 ;
33474 PyObject * obj0 = 0 ;
33475 PyObject * obj1 = 0 ;
33476 PyObject * obj2 = 0 ;
33477 PyObject * obj3 = 0 ;
33478 char * kwnames[] = {
33479 (char *) "self",(char *) "x",(char *) "y",(char *) "_def", NULL
33480 };
33481
33482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33483 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33484 if (!SWIG_IsOK(res1)) {
33485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33486 }
33487 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33488 ecode2 = SWIG_AsVal_int(obj1, &val2);
33489 if (!SWIG_IsOK(ecode2)) {
33490 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
33491 }
33492 arg2 = static_cast< int >(val2);
33493 ecode3 = SWIG_AsVal_int(obj2, &val3);
33494 if (!SWIG_IsOK(ecode3)) {
33495 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
33496 }
33497 arg3 = static_cast< int >(val3);
33498 ecode4 = SWIG_AsVal_int(obj3, &val4);
33499 if (!SWIG_IsOK(ecode4)) {
33500 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
33501 }
33502 arg4 = static_cast< wxDragResult >(val4);
33503 {
33504 PyThreadState* __tstate = wxPyBeginAllowThreads();
33505 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
33506 wxPyEndAllowThreads(__tstate);
33507 if (PyErr_Occurred()) SWIG_fail;
33508 }
33509 resultobj = SWIG_From_int(static_cast< int >(result));
33510 return resultobj;
33511 fail:
33512 return NULL;
33513 }
33514
33515
33516 SWIGINTERN PyObject *TextDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33517 PyObject *obj;
33518 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33519 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDropTarget, SWIG_NewClientData(obj));
33520 return SWIG_Py_Void();
33521 }
33522
33523 SWIGINTERN PyObject *TextDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33524 return SWIG_Python_InitShadowInstance(args);
33525 }
33526
33527 SWIGINTERN PyObject *_wrap_new_FileDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33528 PyObject *resultobj = 0;
33529 wxPyFileDropTarget *result = 0 ;
33530
33531 if (!SWIG_Python_UnpackTuple(args,"new_FileDropTarget",0,0,0)) SWIG_fail;
33532 {
33533 PyThreadState* __tstate = wxPyBeginAllowThreads();
33534 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
33535 wxPyEndAllowThreads(__tstate);
33536 if (PyErr_Occurred()) SWIG_fail;
33537 }
33538 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_NEW | 0 );
33539 return resultobj;
33540 fail:
33541 return NULL;
33542 }
33543
33544
33545 SWIGINTERN PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33546 PyObject *resultobj = 0;
33547 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33548 PyObject *arg2 = (PyObject *) 0 ;
33549 PyObject *arg3 = (PyObject *) 0 ;
33550 void *argp1 = 0 ;
33551 int res1 = 0 ;
33552 PyObject * obj0 = 0 ;
33553 PyObject * obj1 = 0 ;
33554 PyObject * obj2 = 0 ;
33555 char * kwnames[] = {
33556 (char *) "self",(char *) "self",(char *) "_class", NULL
33557 };
33558
33559 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33560 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33561 if (!SWIG_IsOK(res1)) {
33562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33563 }
33564 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33565 arg2 = obj1;
33566 arg3 = obj2;
33567 {
33568 PyThreadState* __tstate = wxPyBeginAllowThreads();
33569 (arg1)->_setCallbackInfo(arg2,arg3);
33570 wxPyEndAllowThreads(__tstate);
33571 if (PyErr_Occurred()) SWIG_fail;
33572 }
33573 resultobj = SWIG_Py_Void();
33574 return resultobj;
33575 fail:
33576 return NULL;
33577 }
33578
33579
33580 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDropFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33581 PyObject *resultobj = 0;
33582 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33583 int arg2 ;
33584 int arg3 ;
33585 wxArrayString *arg4 = 0 ;
33586 bool result;
33587 void *argp1 = 0 ;
33588 int res1 = 0 ;
33589 int val2 ;
33590 int ecode2 = 0 ;
33591 int val3 ;
33592 int ecode3 = 0 ;
33593 bool temp4 = false ;
33594 PyObject * obj0 = 0 ;
33595 PyObject * obj1 = 0 ;
33596 PyObject * obj2 = 0 ;
33597 PyObject * obj3 = 0 ;
33598 char * kwnames[] = {
33599 (char *) "self",(char *) "x",(char *) "y",(char *) "filenames", NULL
33600 };
33601
33602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDropFiles",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33603 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33604 if (!SWIG_IsOK(res1)) {
33605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33606 }
33607 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33608 ecode2 = SWIG_AsVal_int(obj1, &val2);
33609 if (!SWIG_IsOK(ecode2)) {
33610 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "2"" of type '" "int""'");
33611 }
33612 arg2 = static_cast< int >(val2);
33613 ecode3 = SWIG_AsVal_int(obj2, &val3);
33614 if (!SWIG_IsOK(ecode3)) {
33615 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "3"" of type '" "int""'");
33616 }
33617 arg3 = static_cast< int >(val3);
33618 {
33619 if (! PySequence_Check(obj3)) {
33620 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
33621 SWIG_fail;
33622 }
33623 arg4 = new wxArrayString;
33624 temp4 = true;
33625 int i, len=PySequence_Length(obj3);
33626 for (i=0; i<len; i++) {
33627 PyObject* item = PySequence_GetItem(obj3, i);
33628 wxString* s = wxString_in_helper(item);
33629 if (PyErr_Occurred()) SWIG_fail;
33630 arg4->Add(*s);
33631 delete s;
33632 Py_DECREF(item);
33633 }
33634 }
33635 {
33636 PyThreadState* __tstate = wxPyBeginAllowThreads();
33637 result = (bool)(arg1)->OnDropFiles(arg2,arg3,(wxArrayString const &)*arg4);
33638 wxPyEndAllowThreads(__tstate);
33639 if (PyErr_Occurred()) SWIG_fail;
33640 }
33641 {
33642 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33643 }
33644 {
33645 if (temp4) delete arg4;
33646 }
33647 return resultobj;
33648 fail:
33649 {
33650 if (temp4) delete arg4;
33651 }
33652 return NULL;
33653 }
33654
33655
33656 SWIGINTERN PyObject *_wrap_FileDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33657 PyObject *resultobj = 0;
33658 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33659 int arg2 ;
33660 int arg3 ;
33661 wxDragResult arg4 ;
33662 wxDragResult result;
33663 void *argp1 = 0 ;
33664 int res1 = 0 ;
33665 int val2 ;
33666 int ecode2 = 0 ;
33667 int val3 ;
33668 int ecode3 = 0 ;
33669 int val4 ;
33670 int ecode4 = 0 ;
33671 PyObject * obj0 = 0 ;
33672 PyObject * obj1 = 0 ;
33673 PyObject * obj2 = 0 ;
33674 PyObject * obj3 = 0 ;
33675 char * kwnames[] = {
33676 (char *) "self",(char *) "x",(char *) "y",(char *) "_def", NULL
33677 };
33678
33679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33680 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33681 if (!SWIG_IsOK(res1)) {
33682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33683 }
33684 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33685 ecode2 = SWIG_AsVal_int(obj1, &val2);
33686 if (!SWIG_IsOK(ecode2)) {
33687 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
33688 }
33689 arg2 = static_cast< int >(val2);
33690 ecode3 = SWIG_AsVal_int(obj2, &val3);
33691 if (!SWIG_IsOK(ecode3)) {
33692 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
33693 }
33694 arg3 = static_cast< int >(val3);
33695 ecode4 = SWIG_AsVal_int(obj3, &val4);
33696 if (!SWIG_IsOK(ecode4)) {
33697 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
33698 }
33699 arg4 = static_cast< wxDragResult >(val4);
33700 {
33701 PyThreadState* __tstate = wxPyBeginAllowThreads();
33702 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
33703 wxPyEndAllowThreads(__tstate);
33704 if (PyErr_Occurred()) SWIG_fail;
33705 }
33706 resultobj = SWIG_From_int(static_cast< int >(result));
33707 return resultobj;
33708 fail:
33709 return NULL;
33710 }
33711
33712
33713 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33714 PyObject *resultobj = 0;
33715 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33716 int arg2 ;
33717 int arg3 ;
33718 wxDragResult arg4 ;
33719 wxDragResult result;
33720 void *argp1 = 0 ;
33721 int res1 = 0 ;
33722 int val2 ;
33723 int ecode2 = 0 ;
33724 int val3 ;
33725 int ecode3 = 0 ;
33726 int val4 ;
33727 int ecode4 = 0 ;
33728 PyObject * obj0 = 0 ;
33729 PyObject * obj1 = 0 ;
33730 PyObject * obj2 = 0 ;
33731 PyObject * obj3 = 0 ;
33732 char * kwnames[] = {
33733 (char *) "self",(char *) "x",(char *) "y",(char *) "_def", NULL
33734 };
33735
33736 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33737 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33738 if (!SWIG_IsOK(res1)) {
33739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33740 }
33741 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33742 ecode2 = SWIG_AsVal_int(obj1, &val2);
33743 if (!SWIG_IsOK(ecode2)) {
33744 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
33745 }
33746 arg2 = static_cast< int >(val2);
33747 ecode3 = SWIG_AsVal_int(obj2, &val3);
33748 if (!SWIG_IsOK(ecode3)) {
33749 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
33750 }
33751 arg3 = static_cast< int >(val3);
33752 ecode4 = SWIG_AsVal_int(obj3, &val4);
33753 if (!SWIG_IsOK(ecode4)) {
33754 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
33755 }
33756 arg4 = static_cast< wxDragResult >(val4);
33757 {
33758 PyThreadState* __tstate = wxPyBeginAllowThreads();
33759 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
33760 wxPyEndAllowThreads(__tstate);
33761 if (PyErr_Occurred()) SWIG_fail;
33762 }
33763 resultobj = SWIG_From_int(static_cast< int >(result));
33764 return resultobj;
33765 fail:
33766 return NULL;
33767 }
33768
33769
33770 SWIGINTERN PyObject *_wrap_FileDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33771 PyObject *resultobj = 0;
33772 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33773 void *argp1 = 0 ;
33774 int res1 = 0 ;
33775 PyObject *swig_obj[1] ;
33776
33777 if (!args) SWIG_fail;
33778 swig_obj[0] = args;
33779 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33780 if (!SWIG_IsOK(res1)) {
33781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33782 }
33783 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33784 {
33785 PyThreadState* __tstate = wxPyBeginAllowThreads();
33786 (arg1)->OnLeave();
33787 wxPyEndAllowThreads(__tstate);
33788 if (PyErr_Occurred()) SWIG_fail;
33789 }
33790 resultobj = SWIG_Py_Void();
33791 return resultobj;
33792 fail:
33793 return NULL;
33794 }
33795
33796
33797 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33798 PyObject *resultobj = 0;
33799 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33800 int arg2 ;
33801 int arg3 ;
33802 bool result;
33803 void *argp1 = 0 ;
33804 int res1 = 0 ;
33805 int val2 ;
33806 int ecode2 = 0 ;
33807 int val3 ;
33808 int ecode3 = 0 ;
33809 PyObject * obj0 = 0 ;
33810 PyObject * obj1 = 0 ;
33811 PyObject * obj2 = 0 ;
33812 char * kwnames[] = {
33813 (char *) "self",(char *) "x",(char *) "y", NULL
33814 };
33815
33816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33817 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33818 if (!SWIG_IsOK(res1)) {
33819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33820 }
33821 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33822 ecode2 = SWIG_AsVal_int(obj1, &val2);
33823 if (!SWIG_IsOK(ecode2)) {
33824 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
33825 }
33826 arg2 = static_cast< int >(val2);
33827 ecode3 = SWIG_AsVal_int(obj2, &val3);
33828 if (!SWIG_IsOK(ecode3)) {
33829 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
33830 }
33831 arg3 = static_cast< int >(val3);
33832 {
33833 PyThreadState* __tstate = wxPyBeginAllowThreads();
33834 result = (bool)(arg1)->OnDrop(arg2,arg3);
33835 wxPyEndAllowThreads(__tstate);
33836 if (PyErr_Occurred()) SWIG_fail;
33837 }
33838 {
33839 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33840 }
33841 return resultobj;
33842 fail:
33843 return NULL;
33844 }
33845
33846
33847 SWIGINTERN PyObject *_wrap_FileDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33848 PyObject *resultobj = 0;
33849 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33850 int arg2 ;
33851 int arg3 ;
33852 wxDragResult arg4 ;
33853 wxDragResult result;
33854 void *argp1 = 0 ;
33855 int res1 = 0 ;
33856 int val2 ;
33857 int ecode2 = 0 ;
33858 int val3 ;
33859 int ecode3 = 0 ;
33860 int val4 ;
33861 int ecode4 = 0 ;
33862 PyObject * obj0 = 0 ;
33863 PyObject * obj1 = 0 ;
33864 PyObject * obj2 = 0 ;
33865 PyObject * obj3 = 0 ;
33866 char * kwnames[] = {
33867 (char *) "self",(char *) "x",(char *) "y",(char *) "_def", NULL
33868 };
33869
33870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33871 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33872 if (!SWIG_IsOK(res1)) {
33873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33874 }
33875 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33876 ecode2 = SWIG_AsVal_int(obj1, &val2);
33877 if (!SWIG_IsOK(ecode2)) {
33878 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
33879 }
33880 arg2 = static_cast< int >(val2);
33881 ecode3 = SWIG_AsVal_int(obj2, &val3);
33882 if (!SWIG_IsOK(ecode3)) {
33883 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
33884 }
33885 arg3 = static_cast< int >(val3);
33886 ecode4 = SWIG_AsVal_int(obj3, &val4);
33887 if (!SWIG_IsOK(ecode4)) {
33888 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
33889 }
33890 arg4 = static_cast< wxDragResult >(val4);
33891 {
33892 PyThreadState* __tstate = wxPyBeginAllowThreads();
33893 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
33894 wxPyEndAllowThreads(__tstate);
33895 if (PyErr_Occurred()) SWIG_fail;
33896 }
33897 resultobj = SWIG_From_int(static_cast< int >(result));
33898 return resultobj;
33899 fail:
33900 return NULL;
33901 }
33902
33903
33904 SWIGINTERN PyObject *FileDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33905 PyObject *obj;
33906 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33907 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileDropTarget, SWIG_NewClientData(obj));
33908 return SWIG_Py_Void();
33909 }
33910
33911 SWIGINTERN PyObject *FileDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33912 return SWIG_Python_InitShadowInstance(args);
33913 }
33914
33915 SWIGINTERN PyObject *_wrap_new_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33916 PyObject *resultobj = 0;
33917 wxClipboard *result = 0 ;
33918
33919 if (!SWIG_Python_UnpackTuple(args,"new_Clipboard",0,0,0)) SWIG_fail;
33920 {
33921 PyThreadState* __tstate = wxPyBeginAllowThreads();
33922 result = (wxClipboard *)new wxClipboard();
33923 wxPyEndAllowThreads(__tstate);
33924 if (PyErr_Occurred()) SWIG_fail;
33925 }
33926 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, SWIG_POINTER_NEW | 0 );
33927 return resultobj;
33928 fail:
33929 return NULL;
33930 }
33931
33932
33933 SWIGINTERN PyObject *_wrap_delete_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33934 PyObject *resultobj = 0;
33935 wxClipboard *arg1 = (wxClipboard *) 0 ;
33936 void *argp1 = 0 ;
33937 int res1 = 0 ;
33938 PyObject *swig_obj[1] ;
33939
33940 if (!args) SWIG_fail;
33941 swig_obj[0] = args;
33942 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, SWIG_POINTER_DISOWN | 0 );
33943 if (!SWIG_IsOK(res1)) {
33944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Clipboard" "', expected argument " "1"" of type '" "wxClipboard *""'");
33945 }
33946 arg1 = reinterpret_cast< wxClipboard * >(argp1);
33947 {
33948 PyThreadState* __tstate = wxPyBeginAllowThreads();
33949 delete arg1;
33950
33951 wxPyEndAllowThreads(__tstate);
33952 if (PyErr_Occurred()) SWIG_fail;
33953 }
33954 resultobj = SWIG_Py_Void();
33955 return resultobj;
33956 fail:
33957 return NULL;
33958 }
33959
33960
33961 SWIGINTERN PyObject *_wrap_Clipboard_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33962 PyObject *resultobj = 0;
33963 wxClipboard *arg1 = (wxClipboard *) 0 ;
33964 bool result;
33965 void *argp1 = 0 ;
33966 int res1 = 0 ;
33967 PyObject *swig_obj[1] ;
33968
33969 if (!args) SWIG_fail;
33970 swig_obj[0] = args;
33971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
33972 if (!SWIG_IsOK(res1)) {
33973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Open" "', expected argument " "1"" of type '" "wxClipboard *""'");
33974 }
33975 arg1 = reinterpret_cast< wxClipboard * >(argp1);
33976 {
33977 PyThreadState* __tstate = wxPyBeginAllowThreads();
33978 result = (bool)(arg1)->Open();
33979 wxPyEndAllowThreads(__tstate);
33980 if (PyErr_Occurred()) SWIG_fail;
33981 }
33982 {
33983 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33984 }
33985 return resultobj;
33986 fail:
33987 return NULL;
33988 }
33989
33990
33991 SWIGINTERN PyObject *_wrap_Clipboard_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33992 PyObject *resultobj = 0;
33993 wxClipboard *arg1 = (wxClipboard *) 0 ;
33994 void *argp1 = 0 ;
33995 int res1 = 0 ;
33996 PyObject *swig_obj[1] ;
33997
33998 if (!args) SWIG_fail;
33999 swig_obj[0] = args;
34000 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34001 if (!SWIG_IsOK(res1)) {
34002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Close" "', expected argument " "1"" of type '" "wxClipboard *""'");
34003 }
34004 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34005 {
34006 PyThreadState* __tstate = wxPyBeginAllowThreads();
34007 (arg1)->Close();
34008 wxPyEndAllowThreads(__tstate);
34009 if (PyErr_Occurred()) SWIG_fail;
34010 }
34011 resultobj = SWIG_Py_Void();
34012 return resultobj;
34013 fail:
34014 return NULL;
34015 }
34016
34017
34018 SWIGINTERN PyObject *_wrap_Clipboard_IsOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34019 PyObject *resultobj = 0;
34020 wxClipboard *arg1 = (wxClipboard *) 0 ;
34021 bool result;
34022 void *argp1 = 0 ;
34023 int res1 = 0 ;
34024 PyObject *swig_obj[1] ;
34025
34026 if (!args) SWIG_fail;
34027 swig_obj[0] = args;
34028 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34029 if (!SWIG_IsOK(res1)) {
34030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsOpened" "', expected argument " "1"" of type '" "wxClipboard const *""'");
34031 }
34032 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34033 {
34034 PyThreadState* __tstate = wxPyBeginAllowThreads();
34035 result = (bool)((wxClipboard const *)arg1)->IsOpened();
34036 wxPyEndAllowThreads(__tstate);
34037 if (PyErr_Occurred()) SWIG_fail;
34038 }
34039 {
34040 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34041 }
34042 return resultobj;
34043 fail:
34044 return NULL;
34045 }
34046
34047
34048 SWIGINTERN PyObject *_wrap_Clipboard_AddData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34049 PyObject *resultobj = 0;
34050 wxClipboard *arg1 = (wxClipboard *) 0 ;
34051 wxDataObject *arg2 = (wxDataObject *) 0 ;
34052 bool result;
34053 void *argp1 = 0 ;
34054 int res1 = 0 ;
34055 int res2 = 0 ;
34056 PyObject * obj0 = 0 ;
34057 PyObject * obj1 = 0 ;
34058 char * kwnames[] = {
34059 (char *) "self",(char *) "data", NULL
34060 };
34061
34062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) SWIG_fail;
34063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34064 if (!SWIG_IsOK(res1)) {
34065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_AddData" "', expected argument " "1"" of type '" "wxClipboard *""'");
34066 }
34067 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34068 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34069 if (!SWIG_IsOK(res2)) {
34070 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_AddData" "', expected argument " "2"" of type '" "wxDataObject *""'");
34071 }
34072 {
34073 PyThreadState* __tstate = wxPyBeginAllowThreads();
34074 result = (bool)(arg1)->AddData(arg2);
34075 wxPyEndAllowThreads(__tstate);
34076 if (PyErr_Occurred()) SWIG_fail;
34077 }
34078 {
34079 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34080 }
34081 return resultobj;
34082 fail:
34083 return NULL;
34084 }
34085
34086
34087 SWIGINTERN PyObject *_wrap_Clipboard_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34088 PyObject *resultobj = 0;
34089 wxClipboard *arg1 = (wxClipboard *) 0 ;
34090 wxDataObject *arg2 = (wxDataObject *) 0 ;
34091 bool result;
34092 void *argp1 = 0 ;
34093 int res1 = 0 ;
34094 int res2 = 0 ;
34095 PyObject * obj0 = 0 ;
34096 PyObject * obj1 = 0 ;
34097 char * kwnames[] = {
34098 (char *) "self",(char *) "data", NULL
34099 };
34100
34101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
34102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34103 if (!SWIG_IsOK(res1)) {
34104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_SetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
34105 }
34106 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34107 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34108 if (!SWIG_IsOK(res2)) {
34109 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_SetData" "', expected argument " "2"" of type '" "wxDataObject *""'");
34110 }
34111 {
34112 PyThreadState* __tstate = wxPyBeginAllowThreads();
34113 result = (bool)(arg1)->SetData(arg2);
34114 wxPyEndAllowThreads(__tstate);
34115 if (PyErr_Occurred()) SWIG_fail;
34116 }
34117 {
34118 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34119 }
34120 return resultobj;
34121 fail:
34122 return NULL;
34123 }
34124
34125
34126 SWIGINTERN PyObject *_wrap_Clipboard_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34127 PyObject *resultobj = 0;
34128 wxClipboard *arg1 = (wxClipboard *) 0 ;
34129 wxDataFormat *arg2 = 0 ;
34130 bool result;
34131 void *argp1 = 0 ;
34132 int res1 = 0 ;
34133 void *argp2 = 0 ;
34134 int res2 = 0 ;
34135 PyObject * obj0 = 0 ;
34136 PyObject * obj1 = 0 ;
34137 char * kwnames[] = {
34138 (char *) "self",(char *) "format", NULL
34139 };
34140
34141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) SWIG_fail;
34142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34143 if (!SWIG_IsOK(res1)) {
34144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsSupported" "', expected argument " "1"" of type '" "wxClipboard *""'");
34145 }
34146 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34147 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
34148 if (!SWIG_IsOK(res2)) {
34149 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
34150 }
34151 if (!argp2) {
34152 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
34153 }
34154 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
34155 {
34156 PyThreadState* __tstate = wxPyBeginAllowThreads();
34157 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
34158 wxPyEndAllowThreads(__tstate);
34159 if (PyErr_Occurred()) SWIG_fail;
34160 }
34161 {
34162 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34163 }
34164 return resultobj;
34165 fail:
34166 return NULL;
34167 }
34168
34169
34170 SWIGINTERN PyObject *_wrap_Clipboard_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34171 PyObject *resultobj = 0;
34172 wxClipboard *arg1 = (wxClipboard *) 0 ;
34173 wxDataObject *arg2 = 0 ;
34174 bool result;
34175 void *argp1 = 0 ;
34176 int res1 = 0 ;
34177 void *argp2 = 0 ;
34178 int res2 = 0 ;
34179 PyObject * obj0 = 0 ;
34180 PyObject * obj1 = 0 ;
34181 char * kwnames[] = {
34182 (char *) "self",(char *) "data", NULL
34183 };
34184
34185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) SWIG_fail;
34186 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34187 if (!SWIG_IsOK(res1)) {
34188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_GetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
34189 }
34190 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34191 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
34192 if (!SWIG_IsOK(res2)) {
34193 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
34194 }
34195 if (!argp2) {
34196 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
34197 }
34198 arg2 = reinterpret_cast< wxDataObject * >(argp2);
34199 {
34200 PyThreadState* __tstate = wxPyBeginAllowThreads();
34201 result = (bool)(arg1)->GetData(*arg2);
34202 wxPyEndAllowThreads(__tstate);
34203 if (PyErr_Occurred()) SWIG_fail;
34204 }
34205 {
34206 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34207 }
34208 return resultobj;
34209 fail:
34210 return NULL;
34211 }
34212
34213
34214 SWIGINTERN PyObject *_wrap_Clipboard_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34215 PyObject *resultobj = 0;
34216 wxClipboard *arg1 = (wxClipboard *) 0 ;
34217 void *argp1 = 0 ;
34218 int res1 = 0 ;
34219 PyObject *swig_obj[1] ;
34220
34221 if (!args) SWIG_fail;
34222 swig_obj[0] = args;
34223 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34224 if (!SWIG_IsOK(res1)) {
34225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Clear" "', expected argument " "1"" of type '" "wxClipboard *""'");
34226 }
34227 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34228 {
34229 PyThreadState* __tstate = wxPyBeginAllowThreads();
34230 (arg1)->Clear();
34231 wxPyEndAllowThreads(__tstate);
34232 if (PyErr_Occurred()) SWIG_fail;
34233 }
34234 resultobj = SWIG_Py_Void();
34235 return resultobj;
34236 fail:
34237 return NULL;
34238 }
34239
34240
34241 SWIGINTERN PyObject *_wrap_Clipboard_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34242 PyObject *resultobj = 0;
34243 wxClipboard *arg1 = (wxClipboard *) 0 ;
34244 bool result;
34245 void *argp1 = 0 ;
34246 int res1 = 0 ;
34247 PyObject *swig_obj[1] ;
34248
34249 if (!args) SWIG_fail;
34250 swig_obj[0] = args;
34251 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34252 if (!SWIG_IsOK(res1)) {
34253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Flush" "', expected argument " "1"" of type '" "wxClipboard *""'");
34254 }
34255 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34256 {
34257 PyThreadState* __tstate = wxPyBeginAllowThreads();
34258 result = (bool)(arg1)->Flush();
34259 wxPyEndAllowThreads(__tstate);
34260 if (PyErr_Occurred()) SWIG_fail;
34261 }
34262 {
34263 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34264 }
34265 return resultobj;
34266 fail:
34267 return NULL;
34268 }
34269
34270
34271 SWIGINTERN PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34272 PyObject *resultobj = 0;
34273 wxClipboard *arg1 = (wxClipboard *) 0 ;
34274 bool arg2 = (bool) true ;
34275 void *argp1 = 0 ;
34276 int res1 = 0 ;
34277 bool val2 ;
34278 int ecode2 = 0 ;
34279 PyObject * obj0 = 0 ;
34280 PyObject * obj1 = 0 ;
34281 char * kwnames[] = {
34282 (char *) "self",(char *) "primary", NULL
34283 };
34284
34285 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) SWIG_fail;
34286 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34287 if (!SWIG_IsOK(res1)) {
34288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "1"" of type '" "wxClipboard *""'");
34289 }
34290 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34291 if (obj1) {
34292 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34293 if (!SWIG_IsOK(ecode2)) {
34294 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "2"" of type '" "bool""'");
34295 }
34296 arg2 = static_cast< bool >(val2);
34297 }
34298 {
34299 PyThreadState* __tstate = wxPyBeginAllowThreads();
34300 (arg1)->UsePrimarySelection(arg2);
34301 wxPyEndAllowThreads(__tstate);
34302 if (PyErr_Occurred()) SWIG_fail;
34303 }
34304 resultobj = SWIG_Py_Void();
34305 return resultobj;
34306 fail:
34307 return NULL;
34308 }
34309
34310
34311 SWIGINTERN PyObject *_wrap_Clipboard_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34312 PyObject *resultobj = 0;
34313 wxClipboard *result = 0 ;
34314
34315 if (!SWIG_Python_UnpackTuple(args,"Clipboard_Get",0,0,0)) SWIG_fail;
34316 {
34317 PyThreadState* __tstate = wxPyBeginAllowThreads();
34318 result = (wxClipboard *)wxClipboard::Get();
34319 wxPyEndAllowThreads(__tstate);
34320 if (PyErr_Occurred()) SWIG_fail;
34321 }
34322 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, 0 | 0 );
34323 return resultobj;
34324 fail:
34325 return NULL;
34326 }
34327
34328
34329 SWIGINTERN PyObject *Clipboard_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34330 PyObject *obj;
34331 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34332 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboard, SWIG_NewClientData(obj));
34333 return SWIG_Py_Void();
34334 }
34335
34336 SWIGINTERN PyObject *Clipboard_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34337 return SWIG_Python_InitShadowInstance(args);
34338 }
34339
34340 SWIGINTERN PyObject *_wrap_new_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34341 PyObject *resultobj = 0;
34342 wxClipboard *arg1 = (wxClipboard *) NULL ;
34343 wxClipboardLocker *result = 0 ;
34344 void *argp1 = 0 ;
34345 int res1 = 0 ;
34346 PyObject * obj0 = 0 ;
34347 char * kwnames[] = {
34348 (char *) "clipboard", NULL
34349 };
34350
34351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) SWIG_fail;
34352 if (obj0) {
34353 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34354 if (!SWIG_IsOK(res1)) {
34355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboard *""'");
34356 }
34357 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34358 }
34359 {
34360 PyThreadState* __tstate = wxPyBeginAllowThreads();
34361 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
34362 wxPyEndAllowThreads(__tstate);
34363 if (PyErr_Occurred()) SWIG_fail;
34364 }
34365 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_NEW | 0 );
34366 return resultobj;
34367 fail:
34368 return NULL;
34369 }
34370
34371
34372 SWIGINTERN PyObject *_wrap_delete_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34373 PyObject *resultobj = 0;
34374 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
34375 void *argp1 = 0 ;
34376 int res1 = 0 ;
34377 PyObject *swig_obj[1] ;
34378
34379 if (!args) SWIG_fail;
34380 swig_obj[0] = args;
34381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_DISOWN | 0 );
34382 if (!SWIG_IsOK(res1)) {
34383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
34384 }
34385 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
34386 {
34387 PyThreadState* __tstate = wxPyBeginAllowThreads();
34388 delete arg1;
34389
34390 wxPyEndAllowThreads(__tstate);
34391 if (PyErr_Occurred()) SWIG_fail;
34392 }
34393 resultobj = SWIG_Py_Void();
34394 return resultobj;
34395 fail:
34396 return NULL;
34397 }
34398
34399
34400 SWIGINTERN PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34401 PyObject *resultobj = 0;
34402 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
34403 bool result;
34404 void *argp1 = 0 ;
34405 int res1 = 0 ;
34406 PyObject *swig_obj[1] ;
34407
34408 if (!args) SWIG_fail;
34409 swig_obj[0] = args;
34410 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, 0 | 0 );
34411 if (!SWIG_IsOK(res1)) {
34412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClipboardLocker___nonzero__" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
34413 }
34414 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
34415 {
34416 PyThreadState* __tstate = wxPyBeginAllowThreads();
34417 result = (bool)wxClipboardLocker___nonzero__(arg1);
34418 wxPyEndAllowThreads(__tstate);
34419 if (PyErr_Occurred()) SWIG_fail;
34420 }
34421 {
34422 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34423 }
34424 return resultobj;
34425 fail:
34426 return NULL;
34427 }
34428
34429
34430 SWIGINTERN PyObject *ClipboardLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34431 PyObject *obj;
34432 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34433 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardLocker, SWIG_NewClientData(obj));
34434 return SWIG_Py_Void();
34435 }
34436
34437 SWIGINTERN PyObject *ClipboardLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34438 return SWIG_Python_InitShadowInstance(args);
34439 }
34440
34441 SWIGINTERN PyObject *_wrap_new_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34442 PyObject *resultobj = 0;
34443 int arg1 = (int) 0 ;
34444 int arg2 = (int) 0 ;
34445 int arg3 = (int) 0 ;
34446 int arg4 = (int) 0 ;
34447 wxVideoMode *result = 0 ;
34448 int val1 ;
34449 int ecode1 = 0 ;
34450 int val2 ;
34451 int ecode2 = 0 ;
34452 int val3 ;
34453 int ecode3 = 0 ;
34454 int val4 ;
34455 int ecode4 = 0 ;
34456 PyObject * obj0 = 0 ;
34457 PyObject * obj1 = 0 ;
34458 PyObject * obj2 = 0 ;
34459 PyObject * obj3 = 0 ;
34460 char * kwnames[] = {
34461 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
34462 };
34463
34464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34465 if (obj0) {
34466 ecode1 = SWIG_AsVal_int(obj0, &val1);
34467 if (!SWIG_IsOK(ecode1)) {
34468 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VideoMode" "', expected argument " "1"" of type '" "int""'");
34469 }
34470 arg1 = static_cast< int >(val1);
34471 }
34472 if (obj1) {
34473 ecode2 = SWIG_AsVal_int(obj1, &val2);
34474 if (!SWIG_IsOK(ecode2)) {
34475 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VideoMode" "', expected argument " "2"" of type '" "int""'");
34476 }
34477 arg2 = static_cast< int >(val2);
34478 }
34479 if (obj2) {
34480 ecode3 = SWIG_AsVal_int(obj2, &val3);
34481 if (!SWIG_IsOK(ecode3)) {
34482 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_VideoMode" "', expected argument " "3"" of type '" "int""'");
34483 }
34484 arg3 = static_cast< int >(val3);
34485 }
34486 if (obj3) {
34487 ecode4 = SWIG_AsVal_int(obj3, &val4);
34488 if (!SWIG_IsOK(ecode4)) {
34489 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_VideoMode" "', expected argument " "4"" of type '" "int""'");
34490 }
34491 arg4 = static_cast< int >(val4);
34492 }
34493 {
34494 PyThreadState* __tstate = wxPyBeginAllowThreads();
34495 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
34496 wxPyEndAllowThreads(__tstate);
34497 if (PyErr_Occurred()) SWIG_fail;
34498 }
34499 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_NEW | 0 );
34500 return resultobj;
34501 fail:
34502 return NULL;
34503 }
34504
34505
34506 SWIGINTERN PyObject *_wrap_delete_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34507 PyObject *resultobj = 0;
34508 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34509 void *argp1 = 0 ;
34510 int res1 = 0 ;
34511 PyObject *swig_obj[1] ;
34512
34513 if (!args) SWIG_fail;
34514 swig_obj[0] = args;
34515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, SWIG_POINTER_DISOWN | 0 );
34516 if (!SWIG_IsOK(res1)) {
34517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VideoMode" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34518 }
34519 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34520 {
34521 PyThreadState* __tstate = wxPyBeginAllowThreads();
34522 delete arg1;
34523
34524 wxPyEndAllowThreads(__tstate);
34525 if (PyErr_Occurred()) SWIG_fail;
34526 }
34527 resultobj = SWIG_Py_Void();
34528 return resultobj;
34529 fail:
34530 return NULL;
34531 }
34532
34533
34534 SWIGINTERN PyObject *_wrap_VideoMode_Matches(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34535 PyObject *resultobj = 0;
34536 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34537 wxVideoMode *arg2 = 0 ;
34538 bool result;
34539 void *argp1 = 0 ;
34540 int res1 = 0 ;
34541 void *argp2 = 0 ;
34542 int res2 = 0 ;
34543 PyObject * obj0 = 0 ;
34544 PyObject * obj1 = 0 ;
34545 char * kwnames[] = {
34546 (char *) "self",(char *) "other", NULL
34547 };
34548
34549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) SWIG_fail;
34550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34551 if (!SWIG_IsOK(res1)) {
34552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_Matches" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34553 }
34554 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34555 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
34556 if (!SWIG_IsOK(res2)) {
34557 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
34558 }
34559 if (!argp2) {
34560 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
34561 }
34562 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
34563 {
34564 PyThreadState* __tstate = wxPyBeginAllowThreads();
34565 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
34566 wxPyEndAllowThreads(__tstate);
34567 if (PyErr_Occurred()) SWIG_fail;
34568 }
34569 {
34570 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34571 }
34572 return resultobj;
34573 fail:
34574 return NULL;
34575 }
34576
34577
34578 SWIGINTERN PyObject *_wrap_VideoMode_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34579 PyObject *resultobj = 0;
34580 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34581 int result;
34582 void *argp1 = 0 ;
34583 int res1 = 0 ;
34584 PyObject *swig_obj[1] ;
34585
34586 if (!args) SWIG_fail;
34587 swig_obj[0] = args;
34588 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34589 if (!SWIG_IsOK(res1)) {
34590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetWidth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34591 }
34592 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34593 {
34594 PyThreadState* __tstate = wxPyBeginAllowThreads();
34595 result = (int)((wxVideoMode const *)arg1)->GetWidth();
34596 wxPyEndAllowThreads(__tstate);
34597 if (PyErr_Occurred()) SWIG_fail;
34598 }
34599 resultobj = SWIG_From_int(static_cast< int >(result));
34600 return resultobj;
34601 fail:
34602 return NULL;
34603 }
34604
34605
34606 SWIGINTERN PyObject *_wrap_VideoMode_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34607 PyObject *resultobj = 0;
34608 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34609 int result;
34610 void *argp1 = 0 ;
34611 int res1 = 0 ;
34612 PyObject *swig_obj[1] ;
34613
34614 if (!args) SWIG_fail;
34615 swig_obj[0] = args;
34616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34617 if (!SWIG_IsOK(res1)) {
34618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetHeight" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34619 }
34620 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34621 {
34622 PyThreadState* __tstate = wxPyBeginAllowThreads();
34623 result = (int)((wxVideoMode const *)arg1)->GetHeight();
34624 wxPyEndAllowThreads(__tstate);
34625 if (PyErr_Occurred()) SWIG_fail;
34626 }
34627 resultobj = SWIG_From_int(static_cast< int >(result));
34628 return resultobj;
34629 fail:
34630 return NULL;
34631 }
34632
34633
34634 SWIGINTERN PyObject *_wrap_VideoMode_GetDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34635 PyObject *resultobj = 0;
34636 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34637 int result;
34638 void *argp1 = 0 ;
34639 int res1 = 0 ;
34640 PyObject *swig_obj[1] ;
34641
34642 if (!args) SWIG_fail;
34643 swig_obj[0] = args;
34644 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34645 if (!SWIG_IsOK(res1)) {
34646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetDepth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34647 }
34648 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34649 {
34650 PyThreadState* __tstate = wxPyBeginAllowThreads();
34651 result = (int)((wxVideoMode const *)arg1)->GetDepth();
34652 wxPyEndAllowThreads(__tstate);
34653 if (PyErr_Occurred()) SWIG_fail;
34654 }
34655 resultobj = SWIG_From_int(static_cast< int >(result));
34656 return resultobj;
34657 fail:
34658 return NULL;
34659 }
34660
34661
34662 SWIGINTERN PyObject *_wrap_VideoMode_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34663 PyObject *resultobj = 0;
34664 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34665 bool result;
34666 void *argp1 = 0 ;
34667 int res1 = 0 ;
34668 PyObject *swig_obj[1] ;
34669
34670 if (!args) SWIG_fail;
34671 swig_obj[0] = args;
34672 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34673 if (!SWIG_IsOK(res1)) {
34674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_IsOk" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34675 }
34676 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34677 {
34678 PyThreadState* __tstate = wxPyBeginAllowThreads();
34679 result = (bool)((wxVideoMode const *)arg1)->IsOk();
34680 wxPyEndAllowThreads(__tstate);
34681 if (PyErr_Occurred()) SWIG_fail;
34682 }
34683 {
34684 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34685 }
34686 return resultobj;
34687 fail:
34688 return NULL;
34689 }
34690
34691
34692 SWIGINTERN PyObject *_wrap_VideoMode___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34693 PyObject *resultobj = 0;
34694 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34695 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
34696 bool result;
34697 void *argp1 = 0 ;
34698 int res1 = 0 ;
34699 void *argp2 = 0 ;
34700 int res2 = 0 ;
34701 PyObject * obj0 = 0 ;
34702 PyObject * obj1 = 0 ;
34703 char * kwnames[] = {
34704 (char *) "self",(char *) "other", NULL
34705 };
34706
34707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
34708 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34709 if (!SWIG_IsOK(res1)) {
34710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___eq__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34711 }
34712 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34713 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34714 if (!SWIG_IsOK(res2)) {
34715 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___eq__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
34716 }
34717 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
34718 {
34719 PyThreadState* __tstate = wxPyBeginAllowThreads();
34720 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
34721 wxPyEndAllowThreads(__tstate);
34722 if (PyErr_Occurred()) SWIG_fail;
34723 }
34724 {
34725 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34726 }
34727 return resultobj;
34728 fail:
34729 return NULL;
34730 }
34731
34732
34733 SWIGINTERN PyObject *_wrap_VideoMode___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34734 PyObject *resultobj = 0;
34735 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34736 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
34737 bool result;
34738 void *argp1 = 0 ;
34739 int res1 = 0 ;
34740 void *argp2 = 0 ;
34741 int res2 = 0 ;
34742 PyObject * obj0 = 0 ;
34743 PyObject * obj1 = 0 ;
34744 char * kwnames[] = {
34745 (char *) "self",(char *) "other", NULL
34746 };
34747
34748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
34749 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34750 if (!SWIG_IsOK(res1)) {
34751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___ne__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34752 }
34753 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34754 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34755 if (!SWIG_IsOK(res2)) {
34756 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___ne__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
34757 }
34758 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
34759 {
34760 PyThreadState* __tstate = wxPyBeginAllowThreads();
34761 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
34762 wxPyEndAllowThreads(__tstate);
34763 if (PyErr_Occurred()) SWIG_fail;
34764 }
34765 {
34766 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34767 }
34768 return resultobj;
34769 fail:
34770 return NULL;
34771 }
34772
34773
34774 SWIGINTERN PyObject *_wrap_VideoMode_w_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34775 PyObject *resultobj = 0;
34776 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34777 int arg2 ;
34778 void *argp1 = 0 ;
34779 int res1 = 0 ;
34780 int val2 ;
34781 int ecode2 = 0 ;
34782 PyObject *swig_obj[2] ;
34783
34784 if (!SWIG_Python_UnpackTuple(args,"VideoMode_w_set",2,2,swig_obj)) SWIG_fail;
34785 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34786 if (!SWIG_IsOK(res1)) {
34787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34788 }
34789 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34790 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
34791 if (!SWIG_IsOK(ecode2)) {
34792 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_w_set" "', expected argument " "2"" of type '" "int""'");
34793 }
34794 arg2 = static_cast< int >(val2);
34795 if (arg1) (arg1)->w = arg2;
34796
34797 resultobj = SWIG_Py_Void();
34798 return resultobj;
34799 fail:
34800 return NULL;
34801 }
34802
34803
34804 SWIGINTERN PyObject *_wrap_VideoMode_w_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34805 PyObject *resultobj = 0;
34806 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34807 int result;
34808 void *argp1 = 0 ;
34809 int res1 = 0 ;
34810 PyObject *swig_obj[1] ;
34811
34812 if (!args) SWIG_fail;
34813 swig_obj[0] = args;
34814 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34815 if (!SWIG_IsOK(res1)) {
34816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34817 }
34818 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34819 result = (int) ((arg1)->w);
34820 resultobj = SWIG_From_int(static_cast< int >(result));
34821 return resultobj;
34822 fail:
34823 return NULL;
34824 }
34825
34826
34827 SWIGINTERN PyObject *_wrap_VideoMode_h_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34828 PyObject *resultobj = 0;
34829 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34830 int arg2 ;
34831 void *argp1 = 0 ;
34832 int res1 = 0 ;
34833 int val2 ;
34834 int ecode2 = 0 ;
34835 PyObject *swig_obj[2] ;
34836
34837 if (!SWIG_Python_UnpackTuple(args,"VideoMode_h_set",2,2,swig_obj)) SWIG_fail;
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_h_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34841 }
34842 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34843 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
34844 if (!SWIG_IsOK(ecode2)) {
34845 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_h_set" "', expected argument " "2"" of type '" "int""'");
34846 }
34847 arg2 = static_cast< int >(val2);
34848 if (arg1) (arg1)->h = arg2;
34849
34850 resultobj = SWIG_Py_Void();
34851 return resultobj;
34852 fail:
34853 return NULL;
34854 }
34855
34856
34857 SWIGINTERN PyObject *_wrap_VideoMode_h_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34858 PyObject *resultobj = 0;
34859 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34860 int result;
34861 void *argp1 = 0 ;
34862 int res1 = 0 ;
34863 PyObject *swig_obj[1] ;
34864
34865 if (!args) SWIG_fail;
34866 swig_obj[0] = args;
34867 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34868 if (!SWIG_IsOK(res1)) {
34869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34870 }
34871 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34872 result = (int) ((arg1)->h);
34873 resultobj = SWIG_From_int(static_cast< int >(result));
34874 return resultobj;
34875 fail:
34876 return NULL;
34877 }
34878
34879
34880 SWIGINTERN PyObject *_wrap_VideoMode_bpp_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34881 PyObject *resultobj = 0;
34882 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34883 int arg2 ;
34884 void *argp1 = 0 ;
34885 int res1 = 0 ;
34886 int val2 ;
34887 int ecode2 = 0 ;
34888 PyObject *swig_obj[2] ;
34889
34890 if (!SWIG_Python_UnpackTuple(args,"VideoMode_bpp_set",2,2,swig_obj)) SWIG_fail;
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_bpp_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34894 }
34895 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34896 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
34897 if (!SWIG_IsOK(ecode2)) {
34898 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_bpp_set" "', expected argument " "2"" of type '" "int""'");
34899 }
34900 arg2 = static_cast< int >(val2);
34901 if (arg1) (arg1)->bpp = arg2;
34902
34903 resultobj = SWIG_Py_Void();
34904 return resultobj;
34905 fail:
34906 return NULL;
34907 }
34908
34909
34910 SWIGINTERN PyObject *_wrap_VideoMode_bpp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34911 PyObject *resultobj = 0;
34912 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34913 int result;
34914 void *argp1 = 0 ;
34915 int res1 = 0 ;
34916 PyObject *swig_obj[1] ;
34917
34918 if (!args) SWIG_fail;
34919 swig_obj[0] = args;
34920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34921 if (!SWIG_IsOK(res1)) {
34922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34923 }
34924 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34925 result = (int) ((arg1)->bpp);
34926 resultobj = SWIG_From_int(static_cast< int >(result));
34927 return resultobj;
34928 fail:
34929 return NULL;
34930 }
34931
34932
34933 SWIGINTERN PyObject *_wrap_VideoMode_refresh_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34934 PyObject *resultobj = 0;
34935 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34936 int arg2 ;
34937 void *argp1 = 0 ;
34938 int res1 = 0 ;
34939 int val2 ;
34940 int ecode2 = 0 ;
34941 PyObject *swig_obj[2] ;
34942
34943 if (!SWIG_Python_UnpackTuple(args,"VideoMode_refresh_set",2,2,swig_obj)) SWIG_fail;
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_refresh_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34947 }
34948 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34949 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
34950 if (!SWIG_IsOK(ecode2)) {
34951 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_refresh_set" "', expected argument " "2"" of type '" "int""'");
34952 }
34953 arg2 = static_cast< int >(val2);
34954 if (arg1) (arg1)->refresh = arg2;
34955
34956 resultobj = SWIG_Py_Void();
34957 return resultobj;
34958 fail:
34959 return NULL;
34960 }
34961
34962
34963 SWIGINTERN PyObject *_wrap_VideoMode_refresh_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34964 PyObject *resultobj = 0;
34965 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34966 int result;
34967 void *argp1 = 0 ;
34968 int res1 = 0 ;
34969 PyObject *swig_obj[1] ;
34970
34971 if (!args) SWIG_fail;
34972 swig_obj[0] = args;
34973 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34974 if (!SWIG_IsOK(res1)) {
34975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34976 }
34977 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34978 result = (int) ((arg1)->refresh);
34979 resultobj = SWIG_From_int(static_cast< int >(result));
34980 return resultobj;
34981 fail:
34982 return NULL;
34983 }
34984
34985
34986 SWIGINTERN PyObject *VideoMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34987 PyObject *obj;
34988 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34989 SWIG_TypeNewClientData(SWIGTYPE_p_wxVideoMode, SWIG_NewClientData(obj));
34990 return SWIG_Py_Void();
34991 }
34992
34993 SWIGINTERN PyObject *VideoMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34994 return SWIG_Python_InitShadowInstance(args);
34995 }
34996
34997 SWIGINTERN int DefaultVideoMode_set(PyObject *) {
34998 SWIG_Error(SWIG_AttributeError,"Variable DefaultVideoMode is read-only.");
34999 return 1;
35000 }
35001
35002
35003 SWIGINTERN PyObject *DefaultVideoMode_get(void) {
35004 PyObject *pyobj = 0;
35005
35006 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0 );
35007 return pyobj;
35008 }
35009
35010
35011 SWIGINTERN PyObject *_wrap_new_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35012 PyObject *resultobj = 0;
35013 size_t arg1 = (size_t) 0 ;
35014 wxDisplay *result = 0 ;
35015 size_t val1 ;
35016 int ecode1 = 0 ;
35017 PyObject * obj0 = 0 ;
35018 char * kwnames[] = {
35019 (char *) "index", NULL
35020 };
35021
35022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) SWIG_fail;
35023 if (obj0) {
35024 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
35025 if (!SWIG_IsOK(ecode1)) {
35026 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Display" "', expected argument " "1"" of type '" "size_t""'");
35027 }
35028 arg1 = static_cast< size_t >(val1);
35029 }
35030 {
35031 PyThreadState* __tstate = wxPyBeginAllowThreads();
35032 result = (wxDisplay *)new wxDisplay(arg1);
35033 wxPyEndAllowThreads(__tstate);
35034 if (PyErr_Occurred()) SWIG_fail;
35035 }
35036 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplay, SWIG_POINTER_NEW | 0 );
35037 return resultobj;
35038 fail:
35039 return NULL;
35040 }
35041
35042
35043 SWIGINTERN PyObject *_wrap_delete_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35044 PyObject *resultobj = 0;
35045 wxDisplay *arg1 = (wxDisplay *) 0 ;
35046 void *argp1 = 0 ;
35047 int res1 = 0 ;
35048 PyObject *swig_obj[1] ;
35049
35050 if (!args) SWIG_fail;
35051 swig_obj[0] = args;
35052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, SWIG_POINTER_DISOWN | 0 );
35053 if (!SWIG_IsOK(res1)) {
35054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Display" "', expected argument " "1"" of type '" "wxDisplay *""'");
35055 }
35056 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35057 {
35058 PyThreadState* __tstate = wxPyBeginAllowThreads();
35059 delete arg1;
35060
35061 wxPyEndAllowThreads(__tstate);
35062 if (PyErr_Occurred()) SWIG_fail;
35063 }
35064 resultobj = SWIG_Py_Void();
35065 return resultobj;
35066 fail:
35067 return NULL;
35068 }
35069
35070
35071 SWIGINTERN PyObject *_wrap_Display_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35072 PyObject *resultobj = 0;
35073 size_t result;
35074
35075 if (!SWIG_Python_UnpackTuple(args,"Display_GetCount",0,0,0)) SWIG_fail;
35076 {
35077 PyThreadState* __tstate = wxPyBeginAllowThreads();
35078 result = (size_t)wxDisplay::GetCount();
35079 wxPyEndAllowThreads(__tstate);
35080 if (PyErr_Occurred()) SWIG_fail;
35081 }
35082 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
35083 return resultobj;
35084 fail:
35085 return NULL;
35086 }
35087
35088
35089 SWIGINTERN PyObject *_wrap_Display_GetFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35090 PyObject *resultobj = 0;
35091 wxPoint *arg1 = 0 ;
35092 int result;
35093 wxPoint temp1 ;
35094 PyObject * obj0 = 0 ;
35095 char * kwnames[] = {
35096 (char *) "pt", NULL
35097 };
35098
35099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) SWIG_fail;
35100 {
35101 arg1 = &temp1;
35102 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
35103 }
35104 {
35105 PyThreadState* __tstate = wxPyBeginAllowThreads();
35106 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
35107 wxPyEndAllowThreads(__tstate);
35108 if (PyErr_Occurred()) SWIG_fail;
35109 }
35110 resultobj = SWIG_From_int(static_cast< int >(result));
35111 return resultobj;
35112 fail:
35113 return NULL;
35114 }
35115
35116
35117 SWIGINTERN PyObject *_wrap_Display_GetFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35118 PyObject *resultobj = 0;
35119 wxWindow *arg1 = (wxWindow *) 0 ;
35120 int result;
35121 void *argp1 = 0 ;
35122 int res1 = 0 ;
35123 PyObject * obj0 = 0 ;
35124 char * kwnames[] = {
35125 (char *) "window", NULL
35126 };
35127
35128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) SWIG_fail;
35129 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35130 if (!SWIG_IsOK(res1)) {
35131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
35132 }
35133 arg1 = reinterpret_cast< wxWindow * >(argp1);
35134 {
35135 PyThreadState* __tstate = wxPyBeginAllowThreads();
35136 result = (int)wxDisplay::GetFromWindow(arg1);
35137 wxPyEndAllowThreads(__tstate);
35138 if (PyErr_Occurred()) SWIG_fail;
35139 }
35140 resultobj = SWIG_From_int(static_cast< int >(result));
35141 return resultobj;
35142 fail:
35143 return NULL;
35144 }
35145
35146
35147 SWIGINTERN PyObject *_wrap_Display_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35148 PyObject *resultobj = 0;
35149 wxDisplay *arg1 = (wxDisplay *) 0 ;
35150 bool result;
35151 void *argp1 = 0 ;
35152 int res1 = 0 ;
35153 PyObject *swig_obj[1] ;
35154
35155 if (!args) SWIG_fail;
35156 swig_obj[0] = args;
35157 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35158 if (!SWIG_IsOK(res1)) {
35159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsOk" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35160 }
35161 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35162 {
35163 PyThreadState* __tstate = wxPyBeginAllowThreads();
35164 result = (bool)((wxDisplay const *)arg1)->IsOk();
35165 wxPyEndAllowThreads(__tstate);
35166 if (PyErr_Occurred()) SWIG_fail;
35167 }
35168 {
35169 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35170 }
35171 return resultobj;
35172 fail:
35173 return NULL;
35174 }
35175
35176
35177 SWIGINTERN PyObject *_wrap_Display_GetGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35178 PyObject *resultobj = 0;
35179 wxDisplay *arg1 = (wxDisplay *) 0 ;
35180 wxRect result;
35181 void *argp1 = 0 ;
35182 int res1 = 0 ;
35183 PyObject *swig_obj[1] ;
35184
35185 if (!args) SWIG_fail;
35186 swig_obj[0] = args;
35187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35188 if (!SWIG_IsOK(res1)) {
35189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetGeometry" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35190 }
35191 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35192 {
35193 PyThreadState* __tstate = wxPyBeginAllowThreads();
35194 result = ((wxDisplay const *)arg1)->GetGeometry();
35195 wxPyEndAllowThreads(__tstate);
35196 if (PyErr_Occurred()) SWIG_fail;
35197 }
35198 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
35199 return resultobj;
35200 fail:
35201 return NULL;
35202 }
35203
35204
35205 SWIGINTERN PyObject *_wrap_Display_GetClientArea(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35206 PyObject *resultobj = 0;
35207 wxDisplay *arg1 = (wxDisplay *) 0 ;
35208 wxRect result;
35209 void *argp1 = 0 ;
35210 int res1 = 0 ;
35211 PyObject *swig_obj[1] ;
35212
35213 if (!args) SWIG_fail;
35214 swig_obj[0] = args;
35215 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35216 if (!SWIG_IsOK(res1)) {
35217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetClientArea" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35218 }
35219 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35220 {
35221 PyThreadState* __tstate = wxPyBeginAllowThreads();
35222 result = ((wxDisplay const *)arg1)->GetClientArea();
35223 wxPyEndAllowThreads(__tstate);
35224 if (PyErr_Occurred()) SWIG_fail;
35225 }
35226 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
35227 return resultobj;
35228 fail:
35229 return NULL;
35230 }
35231
35232
35233 SWIGINTERN PyObject *_wrap_Display_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35234 PyObject *resultobj = 0;
35235 wxDisplay *arg1 = (wxDisplay *) 0 ;
35236 wxString result;
35237 void *argp1 = 0 ;
35238 int res1 = 0 ;
35239 PyObject *swig_obj[1] ;
35240
35241 if (!args) SWIG_fail;
35242 swig_obj[0] = args;
35243 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35244 if (!SWIG_IsOK(res1)) {
35245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetName" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35246 }
35247 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35248 {
35249 PyThreadState* __tstate = wxPyBeginAllowThreads();
35250 result = ((wxDisplay const *)arg1)->GetName();
35251 wxPyEndAllowThreads(__tstate);
35252 if (PyErr_Occurred()) SWIG_fail;
35253 }
35254 {
35255 #if wxUSE_UNICODE
35256 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35257 #else
35258 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35259 #endif
35260 }
35261 return resultobj;
35262 fail:
35263 return NULL;
35264 }
35265
35266
35267 SWIGINTERN PyObject *_wrap_Display_IsPrimary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35268 PyObject *resultobj = 0;
35269 wxDisplay *arg1 = (wxDisplay *) 0 ;
35270 bool result;
35271 void *argp1 = 0 ;
35272 int res1 = 0 ;
35273 PyObject *swig_obj[1] ;
35274
35275 if (!args) SWIG_fail;
35276 swig_obj[0] = args;
35277 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35278 if (!SWIG_IsOK(res1)) {
35279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsPrimary" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35280 }
35281 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35282 {
35283 PyThreadState* __tstate = wxPyBeginAllowThreads();
35284 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
35285 wxPyEndAllowThreads(__tstate);
35286 if (PyErr_Occurred()) SWIG_fail;
35287 }
35288 {
35289 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35290 }
35291 return resultobj;
35292 fail:
35293 return NULL;
35294 }
35295
35296
35297 SWIGINTERN PyObject *_wrap_Display_GetModes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35298 PyObject *resultobj = 0;
35299 wxDisplay *arg1 = (wxDisplay *) 0 ;
35300 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
35301 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
35302 PyObject *result = 0 ;
35303 void *argp1 = 0 ;
35304 int res1 = 0 ;
35305 void *argp2 = 0 ;
35306 int res2 = 0 ;
35307 PyObject * obj0 = 0 ;
35308 PyObject * obj1 = 0 ;
35309 char * kwnames[] = {
35310 (char *) "self",(char *) "mode", NULL
35311 };
35312
35313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) SWIG_fail;
35314 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35315 if (!SWIG_IsOK(res1)) {
35316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetModes" "', expected argument " "1"" of type '" "wxDisplay *""'");
35317 }
35318 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35319 if (obj1) {
35320 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
35321 if (!SWIG_IsOK(res2)) {
35322 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35323 }
35324 if (!argp2) {
35325 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35326 }
35327 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
35328 }
35329 {
35330 PyThreadState* __tstate = wxPyBeginAllowThreads();
35331 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
35332 wxPyEndAllowThreads(__tstate);
35333 if (PyErr_Occurred()) SWIG_fail;
35334 }
35335 resultobj = result;
35336 return resultobj;
35337 fail:
35338 return NULL;
35339 }
35340
35341
35342 SWIGINTERN PyObject *_wrap_Display_GetCurrentMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35343 PyObject *resultobj = 0;
35344 wxDisplay *arg1 = (wxDisplay *) 0 ;
35345 wxVideoMode result;
35346 void *argp1 = 0 ;
35347 int res1 = 0 ;
35348 PyObject *swig_obj[1] ;
35349
35350 if (!args) SWIG_fail;
35351 swig_obj[0] = args;
35352 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35353 if (!SWIG_IsOK(res1)) {
35354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetCurrentMode" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35355 }
35356 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35357 {
35358 PyThreadState* __tstate = wxPyBeginAllowThreads();
35359 result = wxDisplay_GetCurrentMode((wxDisplay const *)arg1);
35360 wxPyEndAllowThreads(__tstate);
35361 if (PyErr_Occurred()) SWIG_fail;
35362 }
35363 resultobj = SWIG_NewPointerObj((new wxVideoMode(static_cast< const wxVideoMode& >(result))), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_OWN | 0 );
35364 return resultobj;
35365 fail:
35366 return NULL;
35367 }
35368
35369
35370 SWIGINTERN PyObject *_wrap_Display_ChangeMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35371 PyObject *resultobj = 0;
35372 wxDisplay *arg1 = (wxDisplay *) 0 ;
35373 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
35374 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
35375 bool result;
35376 void *argp1 = 0 ;
35377 int res1 = 0 ;
35378 void *argp2 = 0 ;
35379 int res2 = 0 ;
35380 PyObject * obj0 = 0 ;
35381 PyObject * obj1 = 0 ;
35382 char * kwnames[] = {
35383 (char *) "self",(char *) "mode", NULL
35384 };
35385
35386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) SWIG_fail;
35387 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35388 if (!SWIG_IsOK(res1)) {
35389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ChangeMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
35390 }
35391 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35392 if (obj1) {
35393 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
35394 if (!SWIG_IsOK(res2)) {
35395 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35396 }
35397 if (!argp2) {
35398 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35399 }
35400 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
35401 }
35402 {
35403 PyThreadState* __tstate = wxPyBeginAllowThreads();
35404 result = (bool)wxDisplay_ChangeMode(arg1,(wxVideoMode const &)*arg2);
35405 wxPyEndAllowThreads(__tstate);
35406 if (PyErr_Occurred()) SWIG_fail;
35407 }
35408 {
35409 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35410 }
35411 return resultobj;
35412 fail:
35413 return NULL;
35414 }
35415
35416
35417 SWIGINTERN PyObject *_wrap_Display_ResetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35418 PyObject *resultobj = 0;
35419 wxDisplay *arg1 = (wxDisplay *) 0 ;
35420 void *argp1 = 0 ;
35421 int res1 = 0 ;
35422 PyObject *swig_obj[1] ;
35423
35424 if (!args) SWIG_fail;
35425 swig_obj[0] = args;
35426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35427 if (!SWIG_IsOK(res1)) {
35428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ResetMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
35429 }
35430 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35431 {
35432 PyThreadState* __tstate = wxPyBeginAllowThreads();
35433 wxDisplay_ResetMode(arg1);
35434 wxPyEndAllowThreads(__tstate);
35435 if (PyErr_Occurred()) SWIG_fail;
35436 }
35437 resultobj = SWIG_Py_Void();
35438 return resultobj;
35439 fail:
35440 return NULL;
35441 }
35442
35443
35444 SWIGINTERN PyObject *Display_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35445 PyObject *obj;
35446 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35447 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplay, SWIG_NewClientData(obj));
35448 return SWIG_Py_Void();
35449 }
35450
35451 SWIGINTERN PyObject *Display_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35452 return SWIG_Python_InitShadowInstance(args);
35453 }
35454
35455 SWIGINTERN PyObject *_wrap_StandardPaths_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35456 PyObject *resultobj = 0;
35457 wxStandardPaths *result = 0 ;
35458
35459 if (!SWIG_Python_UnpackTuple(args,"StandardPaths_Get",0,0,0)) SWIG_fail;
35460 {
35461 PyThreadState* __tstate = wxPyBeginAllowThreads();
35462 result = (wxStandardPaths *)wxStandardPaths_Get();
35463 wxPyEndAllowThreads(__tstate);
35464 if (PyErr_Occurred()) SWIG_fail;
35465 }
35466 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35467 return resultobj;
35468 fail:
35469 return NULL;
35470 }
35471
35472
35473 SWIGINTERN PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35474 PyObject *resultobj = 0;
35475 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35476 wxString result;
35477 void *argp1 = 0 ;
35478 int res1 = 0 ;
35479 PyObject *swig_obj[1] ;
35480
35481 if (!args) SWIG_fail;
35482 swig_obj[0] = args;
35483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35484 if (!SWIG_IsOK(res1)) {
35485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35486 }
35487 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35488 {
35489 PyThreadState* __tstate = wxPyBeginAllowThreads();
35490 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
35491 wxPyEndAllowThreads(__tstate);
35492 if (PyErr_Occurred()) SWIG_fail;
35493 }
35494 {
35495 #if wxUSE_UNICODE
35496 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35497 #else
35498 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35499 #endif
35500 }
35501 return resultobj;
35502 fail:
35503 return NULL;
35504 }
35505
35506
35507 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35508 PyObject *resultobj = 0;
35509 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35510 wxString result;
35511 void *argp1 = 0 ;
35512 int res1 = 0 ;
35513 PyObject *swig_obj[1] ;
35514
35515 if (!args) SWIG_fail;
35516 swig_obj[0] = args;
35517 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35518 if (!SWIG_IsOK(res1)) {
35519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35520 }
35521 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35522 {
35523 PyThreadState* __tstate = wxPyBeginAllowThreads();
35524 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
35525 wxPyEndAllowThreads(__tstate);
35526 if (PyErr_Occurred()) SWIG_fail;
35527 }
35528 {
35529 #if wxUSE_UNICODE
35530 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35531 #else
35532 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35533 #endif
35534 }
35535 return resultobj;
35536 fail:
35537 return NULL;
35538 }
35539
35540
35541 SWIGINTERN PyObject *_wrap_StandardPaths_GetDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35542 PyObject *resultobj = 0;
35543 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35544 wxString result;
35545 void *argp1 = 0 ;
35546 int res1 = 0 ;
35547 PyObject *swig_obj[1] ;
35548
35549 if (!args) SWIG_fail;
35550 swig_obj[0] = args;
35551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35552 if (!SWIG_IsOK(res1)) {
35553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35554 }
35555 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35556 {
35557 PyThreadState* __tstate = wxPyBeginAllowThreads();
35558 result = ((wxStandardPaths const *)arg1)->GetDataDir();
35559 wxPyEndAllowThreads(__tstate);
35560 if (PyErr_Occurred()) SWIG_fail;
35561 }
35562 {
35563 #if wxUSE_UNICODE
35564 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35565 #else
35566 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35567 #endif
35568 }
35569 return resultobj;
35570 fail:
35571 return NULL;
35572 }
35573
35574
35575 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35576 PyObject *resultobj = 0;
35577 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35578 wxString result;
35579 void *argp1 = 0 ;
35580 int res1 = 0 ;
35581 PyObject *swig_obj[1] ;
35582
35583 if (!args) SWIG_fail;
35584 swig_obj[0] = args;
35585 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35586 if (!SWIG_IsOK(res1)) {
35587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35588 }
35589 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35590 {
35591 PyThreadState* __tstate = wxPyBeginAllowThreads();
35592 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
35593 wxPyEndAllowThreads(__tstate);
35594 if (PyErr_Occurred()) SWIG_fail;
35595 }
35596 {
35597 #if wxUSE_UNICODE
35598 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35599 #else
35600 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35601 #endif
35602 }
35603 return resultobj;
35604 fail:
35605 return NULL;
35606 }
35607
35608
35609 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35610 PyObject *resultobj = 0;
35611 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35612 wxString result;
35613 void *argp1 = 0 ;
35614 int res1 = 0 ;
35615 PyObject *swig_obj[1] ;
35616
35617 if (!args) SWIG_fail;
35618 swig_obj[0] = args;
35619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35620 if (!SWIG_IsOK(res1)) {
35621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35622 }
35623 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35624 {
35625 PyThreadState* __tstate = wxPyBeginAllowThreads();
35626 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
35627 wxPyEndAllowThreads(__tstate);
35628 if (PyErr_Occurred()) SWIG_fail;
35629 }
35630 {
35631 #if wxUSE_UNICODE
35632 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35633 #else
35634 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35635 #endif
35636 }
35637 return resultobj;
35638 fail:
35639 return NULL;
35640 }
35641
35642
35643 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35644 PyObject *resultobj = 0;
35645 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35646 wxString result;
35647 void *argp1 = 0 ;
35648 int res1 = 0 ;
35649 PyObject *swig_obj[1] ;
35650
35651 if (!args) SWIG_fail;
35652 swig_obj[0] = args;
35653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35654 if (!SWIG_IsOK(res1)) {
35655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35656 }
35657 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35658 {
35659 PyThreadState* __tstate = wxPyBeginAllowThreads();
35660 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
35661 wxPyEndAllowThreads(__tstate);
35662 if (PyErr_Occurred()) SWIG_fail;
35663 }
35664 {
35665 #if wxUSE_UNICODE
35666 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35667 #else
35668 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35669 #endif
35670 }
35671 return resultobj;
35672 fail:
35673 return NULL;
35674 }
35675
35676
35677 SWIGINTERN PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35678 PyObject *resultobj = 0;
35679 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35680 wxString result;
35681 void *argp1 = 0 ;
35682 int res1 = 0 ;
35683 PyObject *swig_obj[1] ;
35684
35685 if (!args) SWIG_fail;
35686 swig_obj[0] = args;
35687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35688 if (!SWIG_IsOK(res1)) {
35689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetPluginsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35690 }
35691 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35692 {
35693 PyThreadState* __tstate = wxPyBeginAllowThreads();
35694 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
35695 wxPyEndAllowThreads(__tstate);
35696 if (PyErr_Occurred()) SWIG_fail;
35697 }
35698 {
35699 #if wxUSE_UNICODE
35700 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35701 #else
35702 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35703 #endif
35704 }
35705 return resultobj;
35706 fail:
35707 return NULL;
35708 }
35709
35710
35711 SWIGINTERN PyObject *_wrap_StandardPaths_GetResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35712 PyObject *resultobj = 0;
35713 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35714 wxString result;
35715 void *argp1 = 0 ;
35716 int res1 = 0 ;
35717 PyObject *swig_obj[1] ;
35718
35719 if (!args) SWIG_fail;
35720 swig_obj[0] = args;
35721 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35722 if (!SWIG_IsOK(res1)) {
35723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35724 }
35725 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35726 {
35727 PyThreadState* __tstate = wxPyBeginAllowThreads();
35728 result = ((wxStandardPaths const *)arg1)->GetResourcesDir();
35729 wxPyEndAllowThreads(__tstate);
35730 if (PyErr_Occurred()) SWIG_fail;
35731 }
35732 {
35733 #if wxUSE_UNICODE
35734 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35735 #else
35736 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35737 #endif
35738 }
35739 return resultobj;
35740 fail:
35741 return NULL;
35742 }
35743
35744
35745 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalizedResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35746 PyObject *resultobj = 0;
35747 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35748 wxString *arg2 = 0 ;
35749 wxStandardPaths::ResourceCat arg3 = (wxStandardPaths::ResourceCat) wxStandardPaths::ResourceCat_None ;
35750 wxString result;
35751 void *argp1 = 0 ;
35752 int res1 = 0 ;
35753 bool temp2 = false ;
35754 int val3 ;
35755 int ecode3 = 0 ;
35756 PyObject * obj0 = 0 ;
35757 PyObject * obj1 = 0 ;
35758 PyObject * obj2 = 0 ;
35759 char * kwnames[] = {
35760 (char *) "self",(char *) "lang",(char *) "category", NULL
35761 };
35762
35763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:StandardPaths_GetLocalizedResourcesDir",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35765 if (!SWIG_IsOK(res1)) {
35766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35767 }
35768 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35769 {
35770 arg2 = wxString_in_helper(obj1);
35771 if (arg2 == NULL) SWIG_fail;
35772 temp2 = true;
35773 }
35774 if (obj2) {
35775 ecode3 = SWIG_AsVal_int(obj2, &val3);
35776 if (!SWIG_IsOK(ecode3)) {
35777 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "3"" of type '" "wxStandardPaths::ResourceCat""'");
35778 }
35779 arg3 = static_cast< wxStandardPaths::ResourceCat >(val3);
35780 }
35781 {
35782 PyThreadState* __tstate = wxPyBeginAllowThreads();
35783 result = ((wxStandardPaths const *)arg1)->GetLocalizedResourcesDir((wxString const &)*arg2,arg3);
35784 wxPyEndAllowThreads(__tstate);
35785 if (PyErr_Occurred()) SWIG_fail;
35786 }
35787 {
35788 #if wxUSE_UNICODE
35789 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35790 #else
35791 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35792 #endif
35793 }
35794 {
35795 if (temp2)
35796 delete arg2;
35797 }
35798 return resultobj;
35799 fail:
35800 {
35801 if (temp2)
35802 delete arg2;
35803 }
35804 return NULL;
35805 }
35806
35807
35808 SWIGINTERN PyObject *_wrap_StandardPaths_GetDocumentsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35809 PyObject *resultobj = 0;
35810 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35811 wxString result;
35812 void *argp1 = 0 ;
35813 int res1 = 0 ;
35814 PyObject *swig_obj[1] ;
35815
35816 if (!args) SWIG_fail;
35817 swig_obj[0] = args;
35818 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35819 if (!SWIG_IsOK(res1)) {
35820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDocumentsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35821 }
35822 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35823 {
35824 PyThreadState* __tstate = wxPyBeginAllowThreads();
35825 result = ((wxStandardPaths const *)arg1)->GetDocumentsDir();
35826 wxPyEndAllowThreads(__tstate);
35827 if (PyErr_Occurred()) SWIG_fail;
35828 }
35829 {
35830 #if wxUSE_UNICODE
35831 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35832 #else
35833 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35834 #endif
35835 }
35836 return resultobj;
35837 fail:
35838 return NULL;
35839 }
35840
35841
35842 SWIGINTERN PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35843 PyObject *resultobj = 0;
35844 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35845 wxString *arg2 = 0 ;
35846 void *argp1 = 0 ;
35847 int res1 = 0 ;
35848 bool temp2 = false ;
35849 PyObject * obj0 = 0 ;
35850 PyObject * obj1 = 0 ;
35851 char * kwnames[] = {
35852 (char *) "self",(char *) "prefix", NULL
35853 };
35854
35855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) SWIG_fail;
35856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35857 if (!SWIG_IsOK(res1)) {
35858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_SetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths *""'");
35859 }
35860 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35861 {
35862 arg2 = wxString_in_helper(obj1);
35863 if (arg2 == NULL) SWIG_fail;
35864 temp2 = true;
35865 }
35866 {
35867 PyThreadState* __tstate = wxPyBeginAllowThreads();
35868 (arg1)->SetInstallPrefix((wxString const &)*arg2);
35869 wxPyEndAllowThreads(__tstate);
35870 if (PyErr_Occurred()) SWIG_fail;
35871 }
35872 resultobj = SWIG_Py_Void();
35873 {
35874 if (temp2)
35875 delete arg2;
35876 }
35877 return resultobj;
35878 fail:
35879 {
35880 if (temp2)
35881 delete arg2;
35882 }
35883 return NULL;
35884 }
35885
35886
35887 SWIGINTERN PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35888 PyObject *resultobj = 0;
35889 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35890 wxString result;
35891 void *argp1 = 0 ;
35892 int res1 = 0 ;
35893 PyObject *swig_obj[1] ;
35894
35895 if (!args) SWIG_fail;
35896 swig_obj[0] = args;
35897 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35898 if (!SWIG_IsOK(res1)) {
35899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35900 }
35901 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35902 {
35903 PyThreadState* __tstate = wxPyBeginAllowThreads();
35904 result = ((wxStandardPaths const *)arg1)->GetInstallPrefix();
35905 wxPyEndAllowThreads(__tstate);
35906 if (PyErr_Occurred()) SWIG_fail;
35907 }
35908 {
35909 #if wxUSE_UNICODE
35910 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35911 #else
35912 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35913 #endif
35914 }
35915 return resultobj;
35916 fail:
35917 return NULL;
35918 }
35919
35920
35921 SWIGINTERN PyObject *StandardPaths_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35922 PyObject *obj;
35923 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35924 SWIG_TypeNewClientData(SWIGTYPE_p_wxStandardPaths, SWIG_NewClientData(obj));
35925 return SWIG_Py_Void();
35926 }
35927
35928 static PyMethodDef SwigMethods[] = {
35929 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
35930 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
35931 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
35932 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
35933 { (char *)"SystemSettings_GetScreenType", (PyCFunction)_wrap_SystemSettings_GetScreenType, METH_NOARGS, NULL},
35934 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
35935 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
35936 { (char *)"new_SystemOptions", (PyCFunction)_wrap_new_SystemOptions, METH_NOARGS, NULL},
35937 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
35938 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
35939 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
35940 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
35941 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
35942 { (char *)"SystemOptions_IsFalse", (PyCFunction) _wrap_SystemOptions_IsFalse, METH_VARARGS | METH_KEYWORDS, NULL},
35943 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
35944 { (char *)"SystemOptions_swiginit", SystemOptions_swiginit, METH_VARARGS, NULL},
35945 { (char *)"NewId", (PyCFunction)_wrap_NewId, METH_NOARGS, NULL},
35946 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
35947 { (char *)"GetCurrentId", (PyCFunction)_wrap_GetCurrentId, METH_NOARGS, NULL},
35948 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
35949 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
35950 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
35951 { (char *)"Bell", (PyCFunction)_wrap_Bell, METH_NOARGS, NULL},
35952 { (char *)"EndBusyCursor", (PyCFunction)_wrap_EndBusyCursor, METH_NOARGS, NULL},
35953 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
35954 { (char *)"IsBusy", (PyCFunction)_wrap_IsBusy, METH_NOARGS, NULL},
35955 { (char *)"Now", (PyCFunction)_wrap_Now, METH_NOARGS, NULL},
35956 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
35957 { (char *)"StartTimer", (PyCFunction)_wrap_StartTimer, METH_NOARGS, NULL},
35958 { (char *)"GetOsVersion", (PyCFunction)_wrap_GetOsVersion, METH_NOARGS, NULL},
35959 { (char *)"GetOsDescription", (PyCFunction)_wrap_GetOsDescription, METH_NOARGS, NULL},
35960 { (char *)"GetFreeMemory", (PyCFunction)_wrap_GetFreeMemory, METH_NOARGS, NULL},
35961 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
35962 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
35963 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
35964 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
35965 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
35966 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
35967 { (char *)"GetEmailAddress", (PyCFunction)_wrap_GetEmailAddress, METH_NOARGS, NULL},
35968 { (char *)"GetHostName", (PyCFunction)_wrap_GetHostName, METH_NOARGS, NULL},
35969 { (char *)"GetFullHostName", (PyCFunction)_wrap_GetFullHostName, METH_NOARGS, NULL},
35970 { (char *)"GetUserId", (PyCFunction)_wrap_GetUserId, METH_NOARGS, NULL},
35971 { (char *)"GetUserName", (PyCFunction)_wrap_GetUserName, METH_NOARGS, NULL},
35972 { (char *)"GetHomeDir", (PyCFunction)_wrap_GetHomeDir, METH_NOARGS, NULL},
35973 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
35974 { (char *)"GetProcessId", (PyCFunction)_wrap_GetProcessId, METH_NOARGS, NULL},
35975 { (char *)"Trap", (PyCFunction)_wrap_Trap, METH_NOARGS, NULL},
35976 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
35977 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
35978 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
35979 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
35980 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
35981 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
35982 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
35983 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
35984 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
35985 { (char *)"ColourDisplay", (PyCFunction)_wrap_ColourDisplay, METH_NOARGS, NULL},
35986 { (char *)"DisplayDepth", (PyCFunction)_wrap_DisplayDepth, METH_NOARGS, NULL},
35987 { (char *)"GetDisplayDepth", (PyCFunction)_wrap_GetDisplayDepth, METH_NOARGS, NULL},
35988 { (char *)"DisplaySize", (PyCFunction)_wrap_DisplaySize, METH_NOARGS, NULL},
35989 { (char *)"GetDisplaySize", (PyCFunction)_wrap_GetDisplaySize, METH_NOARGS, NULL},
35990 { (char *)"DisplaySizeMM", (PyCFunction)_wrap_DisplaySizeMM, METH_NOARGS, NULL},
35991 { (char *)"GetDisplaySizeMM", (PyCFunction)_wrap_GetDisplaySizeMM, METH_NOARGS, NULL},
35992 { (char *)"ClientDisplayRect", (PyCFunction)_wrap_ClientDisplayRect, METH_NOARGS, NULL},
35993 { (char *)"GetClientDisplayRect", (PyCFunction)_wrap_GetClientDisplayRect, METH_NOARGS, NULL},
35994 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
35995 { (char *)"GetXDisplay", (PyCFunction)_wrap_GetXDisplay, METH_NOARGS, NULL},
35996 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
35997 { (char *)"GetMousePosition", (PyCFunction)_wrap_GetMousePosition, METH_NOARGS, NULL},
35998 { (char *)"FindWindowAtPointer", (PyCFunction)_wrap_FindWindowAtPointer, METH_NOARGS, NULL},
35999 { (char *)"GetActiveWindow", (PyCFunction)_wrap_GetActiveWindow, METH_NOARGS, NULL},
36000 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
36001 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
36002 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
36003 { (char *)"LaunchDefaultBrowser", (PyCFunction) _wrap_LaunchDefaultBrowser, METH_VARARGS | METH_KEYWORDS, NULL},
36004 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
36005 { (char *)"new_MouseState", (PyCFunction)_wrap_new_MouseState, METH_NOARGS, NULL},
36006 { (char *)"delete_MouseState", (PyCFunction)_wrap_delete_MouseState, METH_O, NULL},
36007 { (char *)"MouseState_GetX", (PyCFunction)_wrap_MouseState_GetX, METH_O, NULL},
36008 { (char *)"MouseState_GetY", (PyCFunction)_wrap_MouseState_GetY, METH_O, NULL},
36009 { (char *)"MouseState_LeftDown", (PyCFunction)_wrap_MouseState_LeftDown, METH_O, NULL},
36010 { (char *)"MouseState_MiddleDown", (PyCFunction)_wrap_MouseState_MiddleDown, METH_O, NULL},
36011 { (char *)"MouseState_RightDown", (PyCFunction)_wrap_MouseState_RightDown, METH_O, NULL},
36012 { (char *)"MouseState_ControlDown", (PyCFunction)_wrap_MouseState_ControlDown, METH_O, NULL},
36013 { (char *)"MouseState_ShiftDown", (PyCFunction)_wrap_MouseState_ShiftDown, METH_O, NULL},
36014 { (char *)"MouseState_AltDown", (PyCFunction)_wrap_MouseState_AltDown, METH_O, NULL},
36015 { (char *)"MouseState_MetaDown", (PyCFunction)_wrap_MouseState_MetaDown, METH_O, NULL},
36016 { (char *)"MouseState_CmdDown", (PyCFunction)_wrap_MouseState_CmdDown, METH_O, NULL},
36017 { (char *)"MouseState_SetX", (PyCFunction) _wrap_MouseState_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
36018 { (char *)"MouseState_SetY", (PyCFunction) _wrap_MouseState_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
36019 { (char *)"MouseState_SetLeftDown", (PyCFunction) _wrap_MouseState_SetLeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
36020 { (char *)"MouseState_SetMiddleDown", (PyCFunction) _wrap_MouseState_SetMiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
36021 { (char *)"MouseState_SetRightDown", (PyCFunction) _wrap_MouseState_SetRightDown, METH_VARARGS | METH_KEYWORDS, NULL},
36022 { (char *)"MouseState_SetControlDown", (PyCFunction) _wrap_MouseState_SetControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
36023 { (char *)"MouseState_SetShiftDown", (PyCFunction) _wrap_MouseState_SetShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
36024 { (char *)"MouseState_SetAltDown", (PyCFunction) _wrap_MouseState_SetAltDown, METH_VARARGS | METH_KEYWORDS, NULL},
36025 { (char *)"MouseState_SetMetaDown", (PyCFunction) _wrap_MouseState_SetMetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
36026 { (char *)"MouseState_swigregister", MouseState_swigregister, METH_VARARGS, NULL},
36027 { (char *)"MouseState_swiginit", MouseState_swiginit, METH_VARARGS, NULL},
36028 { (char *)"GetMouseState", (PyCFunction)_wrap_GetMouseState, METH_NOARGS, NULL},
36029 { (char *)"WakeUpMainThread", (PyCFunction)_wrap_WakeUpMainThread, METH_NOARGS, NULL},
36030 { (char *)"MutexGuiEnter", (PyCFunction)_wrap_MutexGuiEnter, METH_NOARGS, NULL},
36031 { (char *)"MutexGuiLeave", (PyCFunction)_wrap_MutexGuiLeave, METH_NOARGS, NULL},
36032 { (char *)"new_MutexGuiLocker", (PyCFunction)_wrap_new_MutexGuiLocker, METH_NOARGS, NULL},
36033 { (char *)"delete_MutexGuiLocker", (PyCFunction)_wrap_delete_MutexGuiLocker, METH_O, NULL},
36034 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
36035 { (char *)"MutexGuiLocker_swiginit", MutexGuiLocker_swiginit, METH_VARARGS, NULL},
36036 { (char *)"Thread_IsMain", (PyCFunction)_wrap_Thread_IsMain, METH_NOARGS, NULL},
36037 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
36038 { (char *)"delete_ToolTip", (PyCFunction)_wrap_delete_ToolTip, METH_O, NULL},
36039 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
36040 { (char *)"ToolTip_GetTip", (PyCFunction)_wrap_ToolTip_GetTip, METH_O, NULL},
36041 { (char *)"ToolTip_GetWindow", (PyCFunction)_wrap_ToolTip_GetWindow, METH_O, NULL},
36042 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
36043 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
36044 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
36045 { (char *)"ToolTip_swiginit", ToolTip_swiginit, METH_VARARGS, NULL},
36046 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
36047 { (char *)"delete_Caret", (PyCFunction)_wrap_delete_Caret, METH_O, NULL},
36048 { (char *)"Caret_Destroy", (PyCFunction)_wrap_Caret_Destroy, METH_O, NULL},
36049 { (char *)"Caret_IsOk", (PyCFunction)_wrap_Caret_IsOk, METH_O, NULL},
36050 { (char *)"Caret_IsVisible", (PyCFunction)_wrap_Caret_IsVisible, METH_O, NULL},
36051 { (char *)"Caret_GetPosition", (PyCFunction)_wrap_Caret_GetPosition, METH_O, NULL},
36052 { (char *)"Caret_GetPositionTuple", (PyCFunction)_wrap_Caret_GetPositionTuple, METH_O, NULL},
36053 { (char *)"Caret_GetSize", (PyCFunction)_wrap_Caret_GetSize, METH_O, NULL},
36054 { (char *)"Caret_GetSizeTuple", (PyCFunction)_wrap_Caret_GetSizeTuple, METH_O, NULL},
36055 { (char *)"Caret_GetWindow", (PyCFunction)_wrap_Caret_GetWindow, METH_O, NULL},
36056 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
36057 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
36058 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
36059 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
36060 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
36061 { (char *)"Caret_Hide", (PyCFunction)_wrap_Caret_Hide, METH_O, NULL},
36062 { (char *)"Caret_GetBlinkTime", (PyCFunction)_wrap_Caret_GetBlinkTime, METH_NOARGS, NULL},
36063 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
36064 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
36065 { (char *)"Caret_swiginit", Caret_swiginit, METH_VARARGS, NULL},
36066 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
36067 { (char *)"delete_BusyCursor", (PyCFunction)_wrap_delete_BusyCursor, METH_O, NULL},
36068 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
36069 { (char *)"BusyCursor_swiginit", BusyCursor_swiginit, METH_VARARGS, NULL},
36070 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
36071 { (char *)"delete_WindowDisabler", (PyCFunction)_wrap_delete_WindowDisabler, METH_O, NULL},
36072 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
36073 { (char *)"WindowDisabler_swiginit", WindowDisabler_swiginit, METH_VARARGS, NULL},
36074 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36075 { (char *)"delete_BusyInfo", (PyCFunction)_wrap_delete_BusyInfo, METH_O, NULL},
36076 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
36077 { (char *)"BusyInfo_swiginit", BusyInfo_swiginit, METH_VARARGS, NULL},
36078 { (char *)"new_StopWatch", (PyCFunction)_wrap_new_StopWatch, METH_NOARGS, NULL},
36079 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
36080 { (char *)"StopWatch_Pause", (PyCFunction)_wrap_StopWatch_Pause, METH_O, NULL},
36081 { (char *)"StopWatch_Resume", (PyCFunction)_wrap_StopWatch_Resume, METH_O, NULL},
36082 { (char *)"StopWatch_Time", (PyCFunction)_wrap_StopWatch_Time, METH_O, NULL},
36083 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
36084 { (char *)"StopWatch_swiginit", StopWatch_swiginit, METH_VARARGS, NULL},
36085 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
36086 { (char *)"delete_FileHistory", (PyCFunction)_wrap_delete_FileHistory, METH_O, NULL},
36087 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
36088 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
36089 { (char *)"FileHistory_GetMaxFiles", (PyCFunction)_wrap_FileHistory_GetMaxFiles, METH_O, NULL},
36090 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
36091 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
36092 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
36093 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
36094 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction)_wrap_FileHistory_AddFilesToMenu, METH_O, NULL},
36095 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
36096 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
36097 { (char *)"FileHistory_GetCount", (PyCFunction)_wrap_FileHistory_GetCount, METH_O, NULL},
36098 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
36099 { (char *)"FileHistory_swiginit", FileHistory_swiginit, METH_VARARGS, NULL},
36100 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
36101 { (char *)"new_PreSingleInstanceChecker", (PyCFunction)_wrap_new_PreSingleInstanceChecker, METH_NOARGS, NULL},
36102 { (char *)"delete_SingleInstanceChecker", (PyCFunction)_wrap_delete_SingleInstanceChecker, METH_O, NULL},
36103 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
36104 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction)_wrap_SingleInstanceChecker_IsAnotherRunning, METH_O, NULL},
36105 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
36106 { (char *)"SingleInstanceChecker_swiginit", SingleInstanceChecker_swiginit, METH_VARARGS, NULL},
36107 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
36108 { (char *)"delete_TipProvider", (PyCFunction)_wrap_delete_TipProvider, METH_O, NULL},
36109 { (char *)"TipProvider_GetTip", (PyCFunction)_wrap_TipProvider_GetTip, METH_O, NULL},
36110 { (char *)"TipProvider_GetCurrentTip", (PyCFunction)_wrap_TipProvider_GetCurrentTip, METH_O, NULL},
36111 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
36112 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
36113 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
36114 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36115 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
36116 { (char *)"PyTipProvider_swiginit", PyTipProvider_swiginit, METH_VARARGS, NULL},
36117 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
36118 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
36119 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
36120 { (char *)"delete_Timer", (PyCFunction)_wrap_delete_Timer, METH_O, NULL},
36121 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36122 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
36123 { (char *)"Timer_GetOwner", (PyCFunction)_wrap_Timer_GetOwner, METH_O, NULL},
36124 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
36125 { (char *)"Timer_Stop", (PyCFunction)_wrap_Timer_Stop, METH_O, NULL},
36126 { (char *)"Timer_Notify", (PyCFunction)_wrap_Timer_Notify, METH_O, NULL},
36127 { (char *)"Timer_IsRunning", (PyCFunction)_wrap_Timer_IsRunning, METH_O, NULL},
36128 { (char *)"Timer_GetInterval", (PyCFunction)_wrap_Timer_GetInterval, METH_O, NULL},
36129 { (char *)"Timer_GetId", (PyCFunction)_wrap_Timer_GetId, METH_O, NULL},
36130 { (char *)"Timer_IsOneShot", (PyCFunction)_wrap_Timer_IsOneShot, METH_O, NULL},
36131 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
36132 { (char *)"Timer_swiginit", Timer_swiginit, METH_VARARGS, NULL},
36133 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
36134 { (char *)"TimerEvent_GetInterval", (PyCFunction)_wrap_TimerEvent_GetInterval, METH_O, NULL},
36135 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
36136 { (char *)"TimerEvent_swiginit", TimerEvent_swiginit, METH_VARARGS, NULL},
36137 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
36138 { (char *)"delete_TimerRunner", (PyCFunction)_wrap_delete_TimerRunner, METH_O, NULL},
36139 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
36140 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
36141 { (char *)"TimerRunner_swiginit", TimerRunner_swiginit, METH_VARARGS, NULL},
36142 { (char *)"new_Log", (PyCFunction)_wrap_new_Log, METH_NOARGS, NULL},
36143 { (char *)"delete_Log", (PyCFunction)_wrap_delete_Log, METH_O, NULL},
36144 { (char *)"Log_IsEnabled", (PyCFunction)_wrap_Log_IsEnabled, METH_NOARGS, NULL},
36145 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
36146 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
36147 { (char *)"Log_Flush", (PyCFunction)_wrap_Log_Flush, METH_O, NULL},
36148 { (char *)"Log_FlushActive", (PyCFunction)_wrap_Log_FlushActive, METH_NOARGS, NULL},
36149 { (char *)"Log_GetActiveTarget", (PyCFunction)_wrap_Log_GetActiveTarget, METH_NOARGS, NULL},
36150 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
36151 { (char *)"Log_Suspend", (PyCFunction)_wrap_Log_Suspend, METH_NOARGS, NULL},
36152 { (char *)"Log_Resume", (PyCFunction)_wrap_Log_Resume, METH_NOARGS, NULL},
36153 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
36154 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
36155 { (char *)"Log_DontCreateOnDemand", (PyCFunction)_wrap_Log_DontCreateOnDemand, METH_NOARGS, NULL},
36156 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
36157 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
36158 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
36159 { (char *)"Log_ClearTraceMasks", (PyCFunction)_wrap_Log_ClearTraceMasks, METH_NOARGS, NULL},
36160 { (char *)"Log_GetTraceMasks", (PyCFunction)_wrap_Log_GetTraceMasks, METH_NOARGS, NULL},
36161 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
36162 { (char *)"Log_GetVerbose", (PyCFunction)_wrap_Log_GetVerbose, METH_NOARGS, NULL},
36163 { (char *)"Log_GetTraceMask", (PyCFunction)_wrap_Log_GetTraceMask, METH_NOARGS, NULL},
36164 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
36165 { (char *)"Log_GetLogLevel", (PyCFunction)_wrap_Log_GetLogLevel, METH_NOARGS, NULL},
36166 { (char *)"Log_GetTimestamp", (PyCFunction)_wrap_Log_GetTimestamp, METH_NOARGS, NULL},
36167 { (char *)"Log_TimeStamp", (PyCFunction)_wrap_Log_TimeStamp, METH_NOARGS, NULL},
36168 { (char *)"Log_Destroy", (PyCFunction)_wrap_Log_Destroy, METH_O, NULL},
36169 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
36170 { (char *)"Log_swiginit", Log_swiginit, METH_VARARGS, NULL},
36171 { (char *)"new_LogStderr", (PyCFunction)_wrap_new_LogStderr, METH_NOARGS, NULL},
36172 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
36173 { (char *)"LogStderr_swiginit", LogStderr_swiginit, METH_VARARGS, NULL},
36174 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
36175 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
36176 { (char *)"LogTextCtrl_swiginit", LogTextCtrl_swiginit, METH_VARARGS, NULL},
36177 { (char *)"new_LogGui", (PyCFunction)_wrap_new_LogGui, METH_NOARGS, NULL},
36178 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
36179 { (char *)"LogGui_swiginit", LogGui_swiginit, METH_VARARGS, NULL},
36180 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
36181 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
36182 { (char *)"LogWindow_GetFrame", (PyCFunction)_wrap_LogWindow_GetFrame, METH_O, NULL},
36183 { (char *)"LogWindow_GetOldLog", (PyCFunction)_wrap_LogWindow_GetOldLog, METH_O, NULL},
36184 { (char *)"LogWindow_IsPassingMessages", (PyCFunction)_wrap_LogWindow_IsPassingMessages, METH_O, NULL},
36185 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
36186 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
36187 { (char *)"LogWindow_swiginit", LogWindow_swiginit, METH_VARARGS, NULL},
36188 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
36189 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
36190 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
36191 { (char *)"LogChain_IsPassingMessages", (PyCFunction)_wrap_LogChain_IsPassingMessages, METH_O, NULL},
36192 { (char *)"LogChain_GetOldLog", (PyCFunction)_wrap_LogChain_GetOldLog, METH_O, NULL},
36193 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
36194 { (char *)"LogChain_swiginit", LogChain_swiginit, METH_VARARGS, NULL},
36195 { (char *)"new_LogBuffer", (PyCFunction)_wrap_new_LogBuffer, METH_NOARGS, NULL},
36196 { (char *)"LogBuffer_GetBuffer", (PyCFunction)_wrap_LogBuffer_GetBuffer, METH_O, NULL},
36197 { (char *)"LogBuffer_swigregister", LogBuffer_swigregister, METH_VARARGS, NULL},
36198 { (char *)"LogBuffer_swiginit", LogBuffer_swiginit, METH_VARARGS, NULL},
36199 { (char *)"SysErrorCode", (PyCFunction)_wrap_SysErrorCode, METH_NOARGS, NULL},
36200 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
36201 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
36202 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
36203 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
36204 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
36205 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36206 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
36207 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
36208 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
36209 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
36210 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
36211 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
36212 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
36213 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
36214 { (char *)"new_LogNull", (PyCFunction)_wrap_new_LogNull, METH_NOARGS, NULL},
36215 { (char *)"delete_LogNull", (PyCFunction)_wrap_delete_LogNull, METH_O, NULL},
36216 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
36217 { (char *)"LogNull_swiginit", LogNull_swiginit, METH_VARARGS, NULL},
36218 { (char *)"new_PyLog", (PyCFunction)_wrap_new_PyLog, METH_NOARGS, NULL},
36219 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36220 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
36221 { (char *)"PyLog_swiginit", PyLog_swiginit, METH_VARARGS, NULL},
36222 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
36223 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
36224 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
36225 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
36226 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36227 { (char *)"Process_OnTerminate", (PyCFunction) _wrap_Process_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
36228 { (char *)"Process_Redirect", (PyCFunction)_wrap_Process_Redirect, METH_O, NULL},
36229 { (char *)"Process_IsRedirected", (PyCFunction)_wrap_Process_IsRedirected, METH_O, NULL},
36230 { (char *)"Process_Detach", (PyCFunction)_wrap_Process_Detach, METH_O, NULL},
36231 { (char *)"Process_GetInputStream", (PyCFunction)_wrap_Process_GetInputStream, METH_O, NULL},
36232 { (char *)"Process_GetErrorStream", (PyCFunction)_wrap_Process_GetErrorStream, METH_O, NULL},
36233 { (char *)"Process_GetOutputStream", (PyCFunction)_wrap_Process_GetOutputStream, METH_O, NULL},
36234 { (char *)"Process_CloseOutput", (PyCFunction)_wrap_Process_CloseOutput, METH_O, NULL},
36235 { (char *)"Process_IsInputOpened", (PyCFunction)_wrap_Process_IsInputOpened, METH_O, NULL},
36236 { (char *)"Process_IsInputAvailable", (PyCFunction)_wrap_Process_IsInputAvailable, METH_O, NULL},
36237 { (char *)"Process_IsErrorAvailable", (PyCFunction)_wrap_Process_IsErrorAvailable, METH_O, NULL},
36238 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
36239 { (char *)"Process_swiginit", Process_swiginit, METH_VARARGS, NULL},
36240 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
36241 { (char *)"ProcessEvent_GetPid", (PyCFunction)_wrap_ProcessEvent_GetPid, METH_O, NULL},
36242 { (char *)"ProcessEvent_GetExitCode", (PyCFunction)_wrap_ProcessEvent_GetExitCode, METH_O, NULL},
36243 { (char *)"ProcessEvent_m_pid_set", _wrap_ProcessEvent_m_pid_set, METH_VARARGS, NULL},
36244 { (char *)"ProcessEvent_m_pid_get", (PyCFunction)_wrap_ProcessEvent_m_pid_get, METH_O, NULL},
36245 { (char *)"ProcessEvent_m_exitcode_set", _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS, NULL},
36246 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction)_wrap_ProcessEvent_m_exitcode_get, METH_O, NULL},
36247 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
36248 { (char *)"ProcessEvent_swiginit", ProcessEvent_swiginit, METH_VARARGS, NULL},
36249 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
36250 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
36251 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
36252 { (char *)"delete_Joystick", (PyCFunction)_wrap_delete_Joystick, METH_O, NULL},
36253 { (char *)"Joystick_GetPosition", (PyCFunction)_wrap_Joystick_GetPosition, METH_O, NULL},
36254 { (char *)"Joystick_GetZPosition", (PyCFunction)_wrap_Joystick_GetZPosition, METH_O, NULL},
36255 { (char *)"Joystick_GetButtonState", (PyCFunction)_wrap_Joystick_GetButtonState, METH_O, NULL},
36256 { (char *)"Joystick_GetPOVPosition", (PyCFunction)_wrap_Joystick_GetPOVPosition, METH_O, NULL},
36257 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction)_wrap_Joystick_GetPOVCTSPosition, METH_O, NULL},
36258 { (char *)"Joystick_GetRudderPosition", (PyCFunction)_wrap_Joystick_GetRudderPosition, METH_O, NULL},
36259 { (char *)"Joystick_GetUPosition", (PyCFunction)_wrap_Joystick_GetUPosition, METH_O, NULL},
36260 { (char *)"Joystick_GetVPosition", (PyCFunction)_wrap_Joystick_GetVPosition, METH_O, NULL},
36261 { (char *)"Joystick_GetMovementThreshold", (PyCFunction)_wrap_Joystick_GetMovementThreshold, METH_O, NULL},
36262 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
36263 { (char *)"Joystick_IsOk", (PyCFunction)_wrap_Joystick_IsOk, METH_O, NULL},
36264 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction)_wrap_Joystick_GetNumberJoysticks, METH_O, NULL},
36265 { (char *)"Joystick_GetManufacturerId", (PyCFunction)_wrap_Joystick_GetManufacturerId, METH_O, NULL},
36266 { (char *)"Joystick_GetProductId", (PyCFunction)_wrap_Joystick_GetProductId, METH_O, NULL},
36267 { (char *)"Joystick_GetProductName", (PyCFunction)_wrap_Joystick_GetProductName, METH_O, NULL},
36268 { (char *)"Joystick_GetXMin", (PyCFunction)_wrap_Joystick_GetXMin, METH_O, NULL},
36269 { (char *)"Joystick_GetYMin", (PyCFunction)_wrap_Joystick_GetYMin, METH_O, NULL},
36270 { (char *)"Joystick_GetZMin", (PyCFunction)_wrap_Joystick_GetZMin, METH_O, NULL},
36271 { (char *)"Joystick_GetXMax", (PyCFunction)_wrap_Joystick_GetXMax, METH_O, NULL},
36272 { (char *)"Joystick_GetYMax", (PyCFunction)_wrap_Joystick_GetYMax, METH_O, NULL},
36273 { (char *)"Joystick_GetZMax", (PyCFunction)_wrap_Joystick_GetZMax, METH_O, NULL},
36274 { (char *)"Joystick_GetNumberButtons", (PyCFunction)_wrap_Joystick_GetNumberButtons, METH_O, NULL},
36275 { (char *)"Joystick_GetNumberAxes", (PyCFunction)_wrap_Joystick_GetNumberAxes, METH_O, NULL},
36276 { (char *)"Joystick_GetMaxButtons", (PyCFunction)_wrap_Joystick_GetMaxButtons, METH_O, NULL},
36277 { (char *)"Joystick_GetMaxAxes", (PyCFunction)_wrap_Joystick_GetMaxAxes, METH_O, NULL},
36278 { (char *)"Joystick_GetPollingMin", (PyCFunction)_wrap_Joystick_GetPollingMin, METH_O, NULL},
36279 { (char *)"Joystick_GetPollingMax", (PyCFunction)_wrap_Joystick_GetPollingMax, METH_O, NULL},
36280 { (char *)"Joystick_GetRudderMin", (PyCFunction)_wrap_Joystick_GetRudderMin, METH_O, NULL},
36281 { (char *)"Joystick_GetRudderMax", (PyCFunction)_wrap_Joystick_GetRudderMax, METH_O, NULL},
36282 { (char *)"Joystick_GetUMin", (PyCFunction)_wrap_Joystick_GetUMin, METH_O, NULL},
36283 { (char *)"Joystick_GetUMax", (PyCFunction)_wrap_Joystick_GetUMax, METH_O, NULL},
36284 { (char *)"Joystick_GetVMin", (PyCFunction)_wrap_Joystick_GetVMin, METH_O, NULL},
36285 { (char *)"Joystick_GetVMax", (PyCFunction)_wrap_Joystick_GetVMax, METH_O, NULL},
36286 { (char *)"Joystick_HasRudder", (PyCFunction)_wrap_Joystick_HasRudder, METH_O, NULL},
36287 { (char *)"Joystick_HasZ", (PyCFunction)_wrap_Joystick_HasZ, METH_O, NULL},
36288 { (char *)"Joystick_HasU", (PyCFunction)_wrap_Joystick_HasU, METH_O, NULL},
36289 { (char *)"Joystick_HasV", (PyCFunction)_wrap_Joystick_HasV, METH_O, NULL},
36290 { (char *)"Joystick_HasPOV", (PyCFunction)_wrap_Joystick_HasPOV, METH_O, NULL},
36291 { (char *)"Joystick_HasPOV4Dir", (PyCFunction)_wrap_Joystick_HasPOV4Dir, METH_O, NULL},
36292 { (char *)"Joystick_HasPOVCTS", (PyCFunction)_wrap_Joystick_HasPOVCTS, METH_O, NULL},
36293 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
36294 { (char *)"Joystick_ReleaseCapture", (PyCFunction)_wrap_Joystick_ReleaseCapture, METH_O, NULL},
36295 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
36296 { (char *)"Joystick_swiginit", Joystick_swiginit, METH_VARARGS, NULL},
36297 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
36298 { (char *)"JoystickEvent_GetPosition", (PyCFunction)_wrap_JoystickEvent_GetPosition, METH_O, NULL},
36299 { (char *)"JoystickEvent_GetZPosition", (PyCFunction)_wrap_JoystickEvent_GetZPosition, METH_O, NULL},
36300 { (char *)"JoystickEvent_GetButtonState", (PyCFunction)_wrap_JoystickEvent_GetButtonState, METH_O, NULL},
36301 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction)_wrap_JoystickEvent_GetButtonChange, METH_O, NULL},
36302 { (char *)"JoystickEvent_GetJoystick", (PyCFunction)_wrap_JoystickEvent_GetJoystick, METH_O, NULL},
36303 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
36304 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
36305 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
36306 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
36307 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
36308 { (char *)"JoystickEvent_IsButton", (PyCFunction)_wrap_JoystickEvent_IsButton, METH_O, NULL},
36309 { (char *)"JoystickEvent_IsMove", (PyCFunction)_wrap_JoystickEvent_IsMove, METH_O, NULL},
36310 { (char *)"JoystickEvent_IsZMove", (PyCFunction)_wrap_JoystickEvent_IsZMove, METH_O, NULL},
36311 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
36312 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
36313 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
36314 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
36315 { (char *)"JoystickEvent_swiginit", JoystickEvent_swiginit, METH_VARARGS, NULL},
36316 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
36317 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
36318 { (char *)"delete_Sound", (PyCFunction)_wrap_delete_Sound, METH_O, NULL},
36319 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
36320 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
36321 { (char *)"Sound_IsOk", (PyCFunction)_wrap_Sound_IsOk, METH_O, NULL},
36322 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
36323 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
36324 { (char *)"Sound_Stop", (PyCFunction)_wrap_Sound_Stop, METH_NOARGS, NULL},
36325 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
36326 { (char *)"Sound_swiginit", Sound_swiginit, METH_VARARGS, NULL},
36327 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36328 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
36329 { (char *)"new_NullFileTypeInfo", (PyCFunction)_wrap_new_NullFileTypeInfo, METH_NOARGS, NULL},
36330 { (char *)"FileTypeInfo_IsValid", (PyCFunction)_wrap_FileTypeInfo_IsValid, METH_O, NULL},
36331 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
36332 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
36333 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction)_wrap_FileTypeInfo_GetMimeType, METH_O, NULL},
36334 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction)_wrap_FileTypeInfo_GetOpenCommand, METH_O, NULL},
36335 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction)_wrap_FileTypeInfo_GetPrintCommand, METH_O, NULL},
36336 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction)_wrap_FileTypeInfo_GetShortDesc, METH_O, NULL},
36337 { (char *)"FileTypeInfo_GetDescription", (PyCFunction)_wrap_FileTypeInfo_GetDescription, METH_O, NULL},
36338 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction)_wrap_FileTypeInfo_GetExtensions, METH_O, NULL},
36339 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction)_wrap_FileTypeInfo_GetExtensionsCount, METH_O, NULL},
36340 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction)_wrap_FileTypeInfo_GetIconFile, METH_O, NULL},
36341 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction)_wrap_FileTypeInfo_GetIconIndex, METH_O, NULL},
36342 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
36343 { (char *)"FileTypeInfo_swiginit", FileTypeInfo_swiginit, METH_VARARGS, NULL},
36344 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
36345 { (char *)"delete_FileType", (PyCFunction)_wrap_delete_FileType, METH_O, NULL},
36346 { (char *)"FileType_GetMimeType", (PyCFunction)_wrap_FileType_GetMimeType, METH_O, NULL},
36347 { (char *)"FileType_GetMimeTypes", (PyCFunction)_wrap_FileType_GetMimeTypes, METH_O, NULL},
36348 { (char *)"FileType_GetExtensions", (PyCFunction)_wrap_FileType_GetExtensions, METH_O, NULL},
36349 { (char *)"FileType_GetIcon", (PyCFunction)_wrap_FileType_GetIcon, METH_O, NULL},
36350 { (char *)"FileType_GetIconInfo", (PyCFunction)_wrap_FileType_GetIconInfo, METH_O, NULL},
36351 { (char *)"FileType_GetDescription", (PyCFunction)_wrap_FileType_GetDescription, METH_O, NULL},
36352 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
36353 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
36354 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
36355 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
36356 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
36357 { (char *)"FileType_Unassociate", (PyCFunction)_wrap_FileType_Unassociate, METH_O, NULL},
36358 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
36359 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
36360 { (char *)"FileType_swiginit", FileType_swiginit, METH_VARARGS, NULL},
36361 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
36362 { (char *)"new_MimeTypesManager", (PyCFunction)_wrap_new_MimeTypesManager, METH_NOARGS, NULL},
36363 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
36364 { (char *)"MimeTypesManager_ClearData", (PyCFunction)_wrap_MimeTypesManager_ClearData, METH_O, NULL},
36365 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
36366 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
36367 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
36368 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
36369 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction)_wrap_MimeTypesManager_EnumAllFileTypes, METH_O, NULL},
36370 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
36371 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
36372 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
36373 { (char *)"delete_MimeTypesManager", (PyCFunction)_wrap_delete_MimeTypesManager, METH_O, NULL},
36374 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
36375 { (char *)"MimeTypesManager_swiginit", MimeTypesManager_swiginit, METH_VARARGS, NULL},
36376 { (char *)"new_ArtProvider", (PyCFunction)_wrap_new_ArtProvider, METH_NOARGS, NULL},
36377 { (char *)"delete_ArtProvider", (PyCFunction)_wrap_delete_ArtProvider, METH_O, NULL},
36378 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36379 { (char *)"ArtProvider_PushProvider", (PyCFunction) _wrap_ArtProvider_PushProvider, METH_VARARGS | METH_KEYWORDS, NULL},
36380 { (char *)"ArtProvider_PopProvider", (PyCFunction)_wrap_ArtProvider_PopProvider, METH_NOARGS, NULL},
36381 { (char *)"ArtProvider_RemoveProvider", (PyCFunction) _wrap_ArtProvider_RemoveProvider, METH_VARARGS | METH_KEYWORDS, NULL},
36382 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
36383 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
36384 { (char *)"ArtProvider_GetSizeHint", (PyCFunction) _wrap_ArtProvider_GetSizeHint, METH_VARARGS | METH_KEYWORDS, NULL},
36385 { (char *)"ArtProvider_Destroy", (PyCFunction)_wrap_ArtProvider_Destroy, METH_O, NULL},
36386 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
36387 { (char *)"ArtProvider_swiginit", ArtProvider_swiginit, METH_VARARGS, NULL},
36388 { (char *)"delete_ConfigBase", (PyCFunction)_wrap_delete_ConfigBase, METH_O, NULL},
36389 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
36390 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
36391 { (char *)"ConfigBase_Create", (PyCFunction)_wrap_ConfigBase_Create, METH_NOARGS, NULL},
36392 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction)_wrap_ConfigBase_DontCreateOnDemand, METH_NOARGS, NULL},
36393 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
36394 { (char *)"ConfigBase_GetPath", (PyCFunction)_wrap_ConfigBase_GetPath, METH_O, NULL},
36395 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction)_wrap_ConfigBase_GetFirstGroup, METH_O, NULL},
36396 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
36397 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction)_wrap_ConfigBase_GetFirstEntry, METH_O, NULL},
36398 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
36399 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
36400 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
36401 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
36402 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
36403 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
36404 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
36405 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
36406 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
36407 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
36408 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
36409 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
36410 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
36411 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
36412 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
36413 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
36414 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
36415 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
36416 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
36417 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
36418 { (char *)"ConfigBase_DeleteAll", (PyCFunction)_wrap_ConfigBase_DeleteAll, METH_O, NULL},
36419 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
36420 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction)_wrap_ConfigBase_IsExpandingEnvVars, METH_O, NULL},
36421 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
36422 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction)_wrap_ConfigBase_IsRecordingDefaults, METH_O, NULL},
36423 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
36424 { (char *)"ConfigBase_GetAppName", (PyCFunction)_wrap_ConfigBase_GetAppName, METH_O, NULL},
36425 { (char *)"ConfigBase_GetVendorName", (PyCFunction)_wrap_ConfigBase_GetVendorName, METH_O, NULL},
36426 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
36427 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
36428 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
36429 { (char *)"ConfigBase_GetStyle", (PyCFunction)_wrap_ConfigBase_GetStyle, METH_O, NULL},
36430 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
36431 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
36432 { (char *)"delete_Config", (PyCFunction)_wrap_delete_Config, METH_O, NULL},
36433 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
36434 { (char *)"Config_swiginit", Config_swiginit, METH_VARARGS, NULL},
36435 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
36436 { (char *)"delete_FileConfig", (PyCFunction)_wrap_delete_FileConfig, METH_O, NULL},
36437 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
36438 { (char *)"FileConfig_swiginit", FileConfig_swiginit, METH_VARARGS, NULL},
36439 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
36440 { (char *)"delete_ConfigPathChanger", (PyCFunction)_wrap_delete_ConfigPathChanger, METH_O, NULL},
36441 { (char *)"ConfigPathChanger_Name", (PyCFunction)_wrap_ConfigPathChanger_Name, METH_O, NULL},
36442 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
36443 { (char *)"ConfigPathChanger_swiginit", ConfigPathChanger_swiginit, METH_VARARGS, NULL},
36444 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
36445 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
36446 { (char *)"DateTime_GetCountry", (PyCFunction)_wrap_DateTime_GetCountry, METH_NOARGS, NULL},
36447 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
36448 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
36449 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
36450 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36451 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
36452 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
36453 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
36454 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36455 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
36456 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
36457 { (char *)"DateTime_GetAmPmStrings", (PyCFunction)_wrap_DateTime_GetAmPmStrings, METH_NOARGS, NULL},
36458 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
36459 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
36460 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
36461 { (char *)"DateTime_Now", (PyCFunction)_wrap_DateTime_Now, METH_NOARGS, NULL},
36462 { (char *)"DateTime_UNow", (PyCFunction)_wrap_DateTime_UNow, METH_NOARGS, NULL},
36463 { (char *)"DateTime_Today", (PyCFunction)_wrap_DateTime_Today, METH_NOARGS, NULL},
36464 { (char *)"new_DateTime", (PyCFunction)_wrap_new_DateTime, METH_NOARGS, NULL},
36465 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
36466 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
36467 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
36468 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
36469 { (char *)"new_DateTimeFromDateTime", (PyCFunction) _wrap_new_DateTimeFromDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
36470 { (char *)"delete_DateTime", (PyCFunction)_wrap_delete_DateTime, METH_O, NULL},
36471 { (char *)"DateTime_SetToCurrent", (PyCFunction)_wrap_DateTime_SetToCurrent, METH_O, NULL},
36472 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
36473 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
36474 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
36475 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
36476 { (char *)"DateTime_ResetTime", (PyCFunction)_wrap_DateTime_ResetTime, METH_O, NULL},
36477 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
36478 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36479 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
36480 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
36481 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
36482 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
36483 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
36484 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
36485 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
36486 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36487 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36488 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36489 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36490 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36491 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36492 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36493 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
36494 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
36495 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
36496 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
36497 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
36498 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
36499 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
36500 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction)_wrap_DateTime_GetJulianDayNumber, METH_O, NULL},
36501 { (char *)"DateTime_GetJDN", (PyCFunction)_wrap_DateTime_GetJDN, METH_O, NULL},
36502 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction)_wrap_DateTime_GetModifiedJulianDayNumber, METH_O, NULL},
36503 { (char *)"DateTime_GetMJD", (PyCFunction)_wrap_DateTime_GetMJD, METH_O, NULL},
36504 { (char *)"DateTime_GetRataDie", (PyCFunction)_wrap_DateTime_GetRataDie, METH_O, NULL},
36505 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
36506 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
36507 { (char *)"DateTime_FromTimezone", (PyCFunction) _wrap_DateTime_FromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
36508 { (char *)"DateTime_MakeFromTimezone", (PyCFunction) _wrap_DateTime_MakeFromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
36509 { (char *)"DateTime_ToUTC", (PyCFunction) _wrap_DateTime_ToUTC, METH_VARARGS | METH_KEYWORDS, NULL},
36510 { (char *)"DateTime_MakeUTC", (PyCFunction) _wrap_DateTime_MakeUTC, METH_VARARGS | METH_KEYWORDS, NULL},
36511 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
36512 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
36513 { (char *)"DateTime_FromUTC", (PyCFunction) _wrap_DateTime_FromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
36514 { (char *)"DateTime_MakeFromUTC", (PyCFunction) _wrap_DateTime_MakeFromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
36515 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
36516 { (char *)"DateTime_IsValid", (PyCFunction)_wrap_DateTime_IsValid, METH_O, NULL},
36517 { (char *)"DateTime_GetTicks", (PyCFunction)_wrap_DateTime_GetTicks, METH_O, NULL},
36518 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
36519 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36520 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
36521 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36522 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
36523 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
36524 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
36525 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
36526 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
36527 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
36528 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36529 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
36530 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
36531 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
36532 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
36533 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
36534 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
36535 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
36536 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
36537 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
36538 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
36539 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
36540 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
36541 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
36542 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
36543 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
36544 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
36545 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
36546 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
36547 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
36548 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
36549 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
36550 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
36551 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
36552 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
36553 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
36554 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36555 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
36556 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
36557 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
36558 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
36559 { (char *)"DateTime_FormatDate", (PyCFunction)_wrap_DateTime_FormatDate, METH_O, NULL},
36560 { (char *)"DateTime_FormatTime", (PyCFunction)_wrap_DateTime_FormatTime, METH_O, NULL},
36561 { (char *)"DateTime_FormatISODate", (PyCFunction)_wrap_DateTime_FormatISODate, METH_O, NULL},
36562 { (char *)"DateTime_FormatISOTime", (PyCFunction)_wrap_DateTime_FormatISOTime, METH_O, NULL},
36563 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
36564 { (char *)"DateTime_swiginit", DateTime_swiginit, METH_VARARGS, NULL},
36565 { (char *)"TimeSpan_Milliseconds", (PyCFunction) _wrap_TimeSpan_Milliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
36566 { (char *)"TimeSpan_Millisecond", (PyCFunction)_wrap_TimeSpan_Millisecond, METH_NOARGS, NULL},
36567 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
36568 { (char *)"TimeSpan_Second", (PyCFunction)_wrap_TimeSpan_Second, METH_NOARGS, NULL},
36569 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
36570 { (char *)"TimeSpan_Minute", (PyCFunction)_wrap_TimeSpan_Minute, METH_NOARGS, NULL},
36571 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
36572 { (char *)"TimeSpan_Hour", (PyCFunction)_wrap_TimeSpan_Hour, METH_NOARGS, NULL},
36573 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
36574 { (char *)"TimeSpan_Day", (PyCFunction)_wrap_TimeSpan_Day, METH_NOARGS, NULL},
36575 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
36576 { (char *)"TimeSpan_Week", (PyCFunction)_wrap_TimeSpan_Week, METH_NOARGS, NULL},
36577 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
36578 { (char *)"delete_TimeSpan", (PyCFunction)_wrap_delete_TimeSpan, METH_O, NULL},
36579 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
36580 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
36581 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
36582 { (char *)"TimeSpan_Neg", (PyCFunction)_wrap_TimeSpan_Neg, METH_O, NULL},
36583 { (char *)"TimeSpan_Abs", (PyCFunction)_wrap_TimeSpan_Abs, METH_O, NULL},
36584 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
36585 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
36586 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
36587 { (char *)"TimeSpan___neg__", (PyCFunction)_wrap_TimeSpan___neg__, METH_O, NULL},
36588 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
36589 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
36590 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
36591 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
36592 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
36593 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
36594 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
36595 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
36596 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
36597 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
36598 { (char *)"TimeSpan_IsNull", (PyCFunction)_wrap_TimeSpan_IsNull, METH_O, NULL},
36599 { (char *)"TimeSpan_IsPositive", (PyCFunction)_wrap_TimeSpan_IsPositive, METH_O, NULL},
36600 { (char *)"TimeSpan_IsNegative", (PyCFunction)_wrap_TimeSpan_IsNegative, METH_O, NULL},
36601 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
36602 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
36603 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
36604 { (char *)"TimeSpan_GetWeeks", (PyCFunction)_wrap_TimeSpan_GetWeeks, METH_O, NULL},
36605 { (char *)"TimeSpan_GetDays", (PyCFunction)_wrap_TimeSpan_GetDays, METH_O, NULL},
36606 { (char *)"TimeSpan_GetHours", (PyCFunction)_wrap_TimeSpan_GetHours, METH_O, NULL},
36607 { (char *)"TimeSpan_GetMinutes", (PyCFunction)_wrap_TimeSpan_GetMinutes, METH_O, NULL},
36608 { (char *)"TimeSpan_GetSeconds", (PyCFunction)_wrap_TimeSpan_GetSeconds, METH_O, NULL},
36609 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction)_wrap_TimeSpan_GetMilliseconds, METH_O, NULL},
36610 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
36611 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
36612 { (char *)"TimeSpan_swiginit", TimeSpan_swiginit, METH_VARARGS, NULL},
36613 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
36614 { (char *)"delete_DateSpan", (PyCFunction)_wrap_delete_DateSpan, METH_O, NULL},
36615 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
36616 { (char *)"DateSpan_Day", (PyCFunction)_wrap_DateSpan_Day, METH_NOARGS, NULL},
36617 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
36618 { (char *)"DateSpan_Week", (PyCFunction)_wrap_DateSpan_Week, METH_NOARGS, NULL},
36619 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
36620 { (char *)"DateSpan_Month", (PyCFunction)_wrap_DateSpan_Month, METH_NOARGS, NULL},
36621 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
36622 { (char *)"DateSpan_Year", (PyCFunction)_wrap_DateSpan_Year, METH_NOARGS, NULL},
36623 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
36624 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
36625 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
36626 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
36627 { (char *)"DateSpan_GetYears", (PyCFunction)_wrap_DateSpan_GetYears, METH_O, NULL},
36628 { (char *)"DateSpan_GetMonths", (PyCFunction)_wrap_DateSpan_GetMonths, METH_O, NULL},
36629 { (char *)"DateSpan_GetWeeks", (PyCFunction)_wrap_DateSpan_GetWeeks, METH_O, NULL},
36630 { (char *)"DateSpan_GetDays", (PyCFunction)_wrap_DateSpan_GetDays, METH_O, NULL},
36631 { (char *)"DateSpan_GetTotalDays", (PyCFunction)_wrap_DateSpan_GetTotalDays, METH_O, NULL},
36632 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
36633 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
36634 { (char *)"DateSpan_Neg", (PyCFunction)_wrap_DateSpan_Neg, METH_O, NULL},
36635 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
36636 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
36637 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
36638 { (char *)"DateSpan___neg__", (PyCFunction)_wrap_DateSpan___neg__, METH_O, NULL},
36639 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
36640 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
36641 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
36642 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
36643 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
36644 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
36645 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
36646 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
36647 { (char *)"DateSpan_swiginit", DateSpan_swiginit, METH_VARARGS, NULL},
36648 { (char *)"GetLocalTime", (PyCFunction)_wrap_GetLocalTime, METH_NOARGS, NULL},
36649 { (char *)"GetUTCTime", (PyCFunction)_wrap_GetUTCTime, METH_NOARGS, NULL},
36650 { (char *)"GetCurrentTime", (PyCFunction)_wrap_GetCurrentTime, METH_NOARGS, NULL},
36651 { (char *)"GetLocalTimeMillis", (PyCFunction)_wrap_GetLocalTimeMillis, METH_NOARGS, NULL},
36652 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36653 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36654 { (char *)"delete_DataFormat", (PyCFunction)_wrap_delete_DataFormat, METH_O, NULL},
36655 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
36656 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
36657 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
36658 { (char *)"DataFormat_GetType", (PyCFunction)_wrap_DataFormat_GetType, METH_O, NULL},
36659 { (char *)"DataFormat_GetId", (PyCFunction)_wrap_DataFormat_GetId, METH_O, NULL},
36660 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
36661 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
36662 { (char *)"DataFormat_swiginit", DataFormat_swiginit, METH_VARARGS, NULL},
36663 { (char *)"delete_DataObject", (PyCFunction)_wrap_delete_DataObject, METH_O, NULL},
36664 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36665 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
36666 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
36667 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
36668 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
36669 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
36670 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
36671 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
36672 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
36673 { (char *)"DataObjectSimple_GetFormat", (PyCFunction)_wrap_DataObjectSimple_GetFormat, METH_O, NULL},
36674 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36675 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction)_wrap_DataObjectSimple_GetDataSize, METH_O, NULL},
36676 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction)_wrap_DataObjectSimple_GetDataHere, METH_O, NULL},
36677 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
36678 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
36679 { (char *)"DataObjectSimple_swiginit", DataObjectSimple_swiginit, METH_VARARGS, NULL},
36680 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
36681 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36682 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
36683 { (char *)"PyDataObjectSimple_swiginit", PyDataObjectSimple_swiginit, METH_VARARGS, NULL},
36684 { (char *)"new_DataObjectComposite", (PyCFunction)_wrap_new_DataObjectComposite, METH_NOARGS, NULL},
36685 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
36686 { (char *)"DataObjectComposite_GetReceivedFormat", (PyCFunction)_wrap_DataObjectComposite_GetReceivedFormat, METH_O, NULL},
36687 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
36688 { (char *)"DataObjectComposite_swiginit", DataObjectComposite_swiginit, METH_VARARGS, NULL},
36689 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
36690 { (char *)"TextDataObject_GetTextLength", (PyCFunction)_wrap_TextDataObject_GetTextLength, METH_O, NULL},
36691 { (char *)"TextDataObject_GetText", (PyCFunction)_wrap_TextDataObject_GetText, METH_O, NULL},
36692 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
36693 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
36694 { (char *)"TextDataObject_swiginit", TextDataObject_swiginit, METH_VARARGS, NULL},
36695 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
36696 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36697 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
36698 { (char *)"PyTextDataObject_swiginit", PyTextDataObject_swiginit, METH_VARARGS, NULL},
36699 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
36700 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction)_wrap_BitmapDataObject_GetBitmap, METH_O, NULL},
36701 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
36702 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
36703 { (char *)"BitmapDataObject_swiginit", BitmapDataObject_swiginit, METH_VARARGS, NULL},
36704 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
36705 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36706 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
36707 { (char *)"PyBitmapDataObject_swiginit", PyBitmapDataObject_swiginit, METH_VARARGS, NULL},
36708 { (char *)"new_FileDataObject", (PyCFunction)_wrap_new_FileDataObject, METH_NOARGS, NULL},
36709 { (char *)"FileDataObject_GetFilenames", (PyCFunction)_wrap_FileDataObject_GetFilenames, METH_O, NULL},
36710 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
36711 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
36712 { (char *)"FileDataObject_swiginit", FileDataObject_swiginit, METH_VARARGS, NULL},
36713 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
36714 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
36715 { (char *)"CustomDataObject_GetSize", (PyCFunction)_wrap_CustomDataObject_GetSize, METH_O, NULL},
36716 { (char *)"CustomDataObject_GetData", (PyCFunction)_wrap_CustomDataObject_GetData, METH_O, NULL},
36717 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
36718 { (char *)"CustomDataObject_swiginit", CustomDataObject_swiginit, METH_VARARGS, NULL},
36719 { (char *)"new_URLDataObject", (PyCFunction)_wrap_new_URLDataObject, METH_NOARGS, NULL},
36720 { (char *)"URLDataObject_GetURL", (PyCFunction)_wrap_URLDataObject_GetURL, METH_O, NULL},
36721 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
36722 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
36723 { (char *)"URLDataObject_swiginit", URLDataObject_swiginit, METH_VARARGS, NULL},
36724 { (char *)"new_MetafileDataObject", (PyCFunction)_wrap_new_MetafileDataObject, METH_NOARGS, NULL},
36725 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
36726 { (char *)"MetafileDataObject_swiginit", MetafileDataObject_swiginit, METH_VARARGS, NULL},
36727 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
36728 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
36729 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36730 { (char *)"delete_DropSource", (PyCFunction)_wrap_delete_DropSource, METH_O, NULL},
36731 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
36732 { (char *)"DropSource_GetDataObject", (PyCFunction)_wrap_DropSource_GetDataObject, METH_O, NULL},
36733 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
36734 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
36735 { (char *)"DropSource_GiveFeedback", (PyCFunction) _wrap_DropSource_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
36736 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
36737 { (char *)"DropSource_swiginit", DropSource_swiginit, METH_VARARGS, NULL},
36738 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
36739 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36740 { (char *)"delete_DropTarget", (PyCFunction)_wrap_delete_DropTarget, METH_O, NULL},
36741 { (char *)"DropTarget_GetDataObject", (PyCFunction)_wrap_DropTarget_GetDataObject, METH_O, NULL},
36742 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
36743 { (char *)"DropTarget_OnEnter", (PyCFunction) _wrap_DropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
36744 { (char *)"DropTarget_OnDragOver", (PyCFunction) _wrap_DropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
36745 { (char *)"DropTarget_OnLeave", (PyCFunction)_wrap_DropTarget_OnLeave, METH_O, NULL},
36746 { (char *)"DropTarget_OnDrop", (PyCFunction) _wrap_DropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
36747 { (char *)"DropTarget_GetData", (PyCFunction)_wrap_DropTarget_GetData, METH_O, NULL},
36748 { (char *)"DropTarget_SetDefaultAction", (PyCFunction) _wrap_DropTarget_SetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
36749 { (char *)"DropTarget_GetDefaultAction", (PyCFunction)_wrap_DropTarget_GetDefaultAction, METH_O, NULL},
36750 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
36751 { (char *)"DropTarget_swiginit", DropTarget_swiginit, METH_VARARGS, NULL},
36752 { (char *)"new_TextDropTarget", (PyCFunction)_wrap_new_TextDropTarget, METH_NOARGS, NULL},
36753 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36754 { (char *)"TextDropTarget_OnDropText", (PyCFunction) _wrap_TextDropTarget_OnDropText, METH_VARARGS | METH_KEYWORDS, NULL},
36755 { (char *)"TextDropTarget_OnEnter", (PyCFunction) _wrap_TextDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
36756 { (char *)"TextDropTarget_OnDragOver", (PyCFunction) _wrap_TextDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
36757 { (char *)"TextDropTarget_OnLeave", (PyCFunction)_wrap_TextDropTarget_OnLeave, METH_O, NULL},
36758 { (char *)"TextDropTarget_OnDrop", (PyCFunction) _wrap_TextDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
36759 { (char *)"TextDropTarget_OnData", (PyCFunction) _wrap_TextDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
36760 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
36761 { (char *)"TextDropTarget_swiginit", TextDropTarget_swiginit, METH_VARARGS, NULL},
36762 { (char *)"new_FileDropTarget", (PyCFunction)_wrap_new_FileDropTarget, METH_NOARGS, NULL},
36763 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36764 { (char *)"FileDropTarget_OnDropFiles", (PyCFunction) _wrap_FileDropTarget_OnDropFiles, METH_VARARGS | METH_KEYWORDS, NULL},
36765 { (char *)"FileDropTarget_OnEnter", (PyCFunction) _wrap_FileDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
36766 { (char *)"FileDropTarget_OnDragOver", (PyCFunction) _wrap_FileDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
36767 { (char *)"FileDropTarget_OnLeave", (PyCFunction)_wrap_FileDropTarget_OnLeave, METH_O, NULL},
36768 { (char *)"FileDropTarget_OnDrop", (PyCFunction) _wrap_FileDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
36769 { (char *)"FileDropTarget_OnData", (PyCFunction) _wrap_FileDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
36770 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
36771 { (char *)"FileDropTarget_swiginit", FileDropTarget_swiginit, METH_VARARGS, NULL},
36772 { (char *)"new_Clipboard", (PyCFunction)_wrap_new_Clipboard, METH_NOARGS, NULL},
36773 { (char *)"delete_Clipboard", (PyCFunction)_wrap_delete_Clipboard, METH_O, NULL},
36774 { (char *)"Clipboard_Open", (PyCFunction)_wrap_Clipboard_Open, METH_O, NULL},
36775 { (char *)"Clipboard_Close", (PyCFunction)_wrap_Clipboard_Close, METH_O, NULL},
36776 { (char *)"Clipboard_IsOpened", (PyCFunction)_wrap_Clipboard_IsOpened, METH_O, NULL},
36777 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
36778 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
36779 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
36780 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
36781 { (char *)"Clipboard_Clear", (PyCFunction)_wrap_Clipboard_Clear, METH_O, NULL},
36782 { (char *)"Clipboard_Flush", (PyCFunction)_wrap_Clipboard_Flush, METH_O, NULL},
36783 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
36784 { (char *)"Clipboard_Get", (PyCFunction)_wrap_Clipboard_Get, METH_NOARGS, NULL},
36785 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
36786 { (char *)"Clipboard_swiginit", Clipboard_swiginit, METH_VARARGS, NULL},
36787 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
36788 { (char *)"delete_ClipboardLocker", (PyCFunction)_wrap_delete_ClipboardLocker, METH_O, NULL},
36789 { (char *)"ClipboardLocker___nonzero__", (PyCFunction)_wrap_ClipboardLocker___nonzero__, METH_O, NULL},
36790 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
36791 { (char *)"ClipboardLocker_swiginit", ClipboardLocker_swiginit, METH_VARARGS, NULL},
36792 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
36793 { (char *)"delete_VideoMode", (PyCFunction)_wrap_delete_VideoMode, METH_O, NULL},
36794 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
36795 { (char *)"VideoMode_GetWidth", (PyCFunction)_wrap_VideoMode_GetWidth, METH_O, NULL},
36796 { (char *)"VideoMode_GetHeight", (PyCFunction)_wrap_VideoMode_GetHeight, METH_O, NULL},
36797 { (char *)"VideoMode_GetDepth", (PyCFunction)_wrap_VideoMode_GetDepth, METH_O, NULL},
36798 { (char *)"VideoMode_IsOk", (PyCFunction)_wrap_VideoMode_IsOk, METH_O, NULL},
36799 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
36800 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
36801 { (char *)"VideoMode_w_set", _wrap_VideoMode_w_set, METH_VARARGS, NULL},
36802 { (char *)"VideoMode_w_get", (PyCFunction)_wrap_VideoMode_w_get, METH_O, NULL},
36803 { (char *)"VideoMode_h_set", _wrap_VideoMode_h_set, METH_VARARGS, NULL},
36804 { (char *)"VideoMode_h_get", (PyCFunction)_wrap_VideoMode_h_get, METH_O, NULL},
36805 { (char *)"VideoMode_bpp_set", _wrap_VideoMode_bpp_set, METH_VARARGS, NULL},
36806 { (char *)"VideoMode_bpp_get", (PyCFunction)_wrap_VideoMode_bpp_get, METH_O, NULL},
36807 { (char *)"VideoMode_refresh_set", _wrap_VideoMode_refresh_set, METH_VARARGS, NULL},
36808 { (char *)"VideoMode_refresh_get", (PyCFunction)_wrap_VideoMode_refresh_get, METH_O, NULL},
36809 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
36810 { (char *)"VideoMode_swiginit", VideoMode_swiginit, METH_VARARGS, NULL},
36811 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
36812 { (char *)"delete_Display", (PyCFunction)_wrap_delete_Display, METH_O, NULL},
36813 { (char *)"Display_GetCount", (PyCFunction)_wrap_Display_GetCount, METH_NOARGS, NULL},
36814 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
36815 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
36816 { (char *)"Display_IsOk", (PyCFunction)_wrap_Display_IsOk, METH_O, NULL},
36817 { (char *)"Display_GetGeometry", (PyCFunction)_wrap_Display_GetGeometry, METH_O, NULL},
36818 { (char *)"Display_GetClientArea", (PyCFunction)_wrap_Display_GetClientArea, METH_O, NULL},
36819 { (char *)"Display_GetName", (PyCFunction)_wrap_Display_GetName, METH_O, NULL},
36820 { (char *)"Display_IsPrimary", (PyCFunction)_wrap_Display_IsPrimary, METH_O, NULL},
36821 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
36822 { (char *)"Display_GetCurrentMode", (PyCFunction)_wrap_Display_GetCurrentMode, METH_O, NULL},
36823 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
36824 { (char *)"Display_ResetMode", (PyCFunction)_wrap_Display_ResetMode, METH_O, NULL},
36825 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
36826 { (char *)"Display_swiginit", Display_swiginit, METH_VARARGS, NULL},
36827 { (char *)"StandardPaths_Get", (PyCFunction)_wrap_StandardPaths_Get, METH_NOARGS, NULL},
36828 { (char *)"StandardPaths_GetConfigDir", (PyCFunction)_wrap_StandardPaths_GetConfigDir, METH_O, NULL},
36829 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction)_wrap_StandardPaths_GetUserConfigDir, METH_O, NULL},
36830 { (char *)"StandardPaths_GetDataDir", (PyCFunction)_wrap_StandardPaths_GetDataDir, METH_O, NULL},
36831 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetLocalDataDir, METH_O, NULL},
36832 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction)_wrap_StandardPaths_GetUserDataDir, METH_O, NULL},
36833 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetUserLocalDataDir, METH_O, NULL},
36834 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction)_wrap_StandardPaths_GetPluginsDir, METH_O, NULL},
36835 { (char *)"StandardPaths_GetResourcesDir", (PyCFunction)_wrap_StandardPaths_GetResourcesDir, METH_O, NULL},
36836 { (char *)"StandardPaths_GetLocalizedResourcesDir", (PyCFunction) _wrap_StandardPaths_GetLocalizedResourcesDir, METH_VARARGS | METH_KEYWORDS, NULL},
36837 { (char *)"StandardPaths_GetDocumentsDir", (PyCFunction)_wrap_StandardPaths_GetDocumentsDir, METH_O, NULL},
36838 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
36839 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction)_wrap_StandardPaths_GetInstallPrefix, METH_O, NULL},
36840 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
36841 { NULL, NULL, 0, NULL }
36842 };
36843
36844
36845 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
36846
36847 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
36848 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
36849 }
36850 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
36851 return (void *)((wxEvent *) ((wxMenuEvent *) x));
36852 }
36853 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
36854 return (void *)((wxEvent *) ((wxCloseEvent *) x));
36855 }
36856 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
36857 return (void *)((wxEvent *) ((wxMouseEvent *) x));
36858 }
36859 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
36860 return (void *)((wxEvent *) ((wxEraseEvent *) x));
36861 }
36862 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
36863 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
36864 }
36865 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
36866 return (void *)((wxEvent *) ((wxTimerEvent *) x));
36867 }
36868 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
36869 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
36870 }
36871 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
36872 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
36873 }
36874 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
36875 return (void *)((wxEvent *) ((wxPyEvent *) x));
36876 }
36877 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
36878 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
36879 }
36880 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
36881 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
36882 }
36883 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
36884 return (void *)((wxEvent *) ((wxIdleEvent *) x));
36885 }
36886 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
36887 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
36888 }
36889 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
36890 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
36891 }
36892 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
36893 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
36894 }
36895 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
36896 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
36897 }
36898 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
36899 return (void *)((wxEvent *) ((wxActivateEvent *) x));
36900 }
36901 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
36902 return (void *)((wxEvent *) ((wxSizeEvent *) x));
36903 }
36904 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
36905 return (void *)((wxEvent *) ((wxMoveEvent *) x));
36906 }
36907 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
36908 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
36909 }
36910 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
36911 return (void *)((wxEvent *) ((wxPaintEvent *) x));
36912 }
36913 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
36914 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
36915 }
36916 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
36917 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
36918 }
36919 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
36920 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
36921 }
36922 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
36923 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
36924 }
36925 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
36926 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
36927 }
36928 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
36929 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
36930 }
36931 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
36932 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
36933 }
36934 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
36935 return (void *)((wxEvent *) ((wxFocusEvent *) x));
36936 }
36937 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
36938 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
36939 }
36940 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
36941 return (void *)((wxEvent *) ((wxProcessEvent *) x));
36942 }
36943 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
36944 return (void *)((wxEvent *) ((wxShowEvent *) x));
36945 }
36946 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
36947 return (void *)((wxEvent *) ((wxCommandEvent *) x));
36948 }
36949 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
36950 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
36951 }
36952 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
36953 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
36954 }
36955 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
36956 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
36957 }
36958 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
36959 return (void *)((wxEvent *) ((wxKeyEvent *) x));
36960 }
36961 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
36962 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
36963 }
36964 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
36965 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
36966 }
36967 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
36968 return (void *)((wxConfigBase *) ((wxConfig *) x));
36969 }
36970 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
36971 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
36972 }
36973 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
36974 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
36975 }
36976 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
36977 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
36978 }
36979 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
36980 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
36981 }
36982 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
36983 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
36984 }
36985 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
36986 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
36987 }
36988 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
36989 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
36990 }
36991 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
36992 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
36993 }
36994 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
36995 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
36996 }
36997 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
36998 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
36999 }
37000 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
37001 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
37002 }
37003 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
37004 return (void *)((wxDataObject *) ((wxURLDataObject *) x));
37005 }
37006 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
37007 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
37008 }
37009 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
37010 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
37011 }
37012 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
37013 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
37014 }
37015 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
37016 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
37017 }
37018 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
37019 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
37020 }
37021 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
37022 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
37023 }
37024 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
37025 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
37026 }
37027 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
37028 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
37029 }
37030 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
37031 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
37032 }
37033 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
37034 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
37035 }
37036 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
37037 return (void *)((wxEvtHandler *) ((wxWindow *) x));
37038 }
37039 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
37040 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
37041 }
37042 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
37043 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
37044 }
37045 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
37046 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
37047 }
37048 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
37049 return (void *)((wxEvtHandler *) ((wxValidator *) x));
37050 }
37051 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
37052 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
37053 }
37054 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
37055 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
37056 }
37057 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
37058 return (void *)((wxEvtHandler *) ((wxMenu *) x));
37059 }
37060 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
37061 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
37062 }
37063 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
37064 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
37065 }
37066 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
37067 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
37068 }
37069 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
37070 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
37071 }
37072 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
37073 return (void *)((wxObject *) ((wxSizerItem *) x));
37074 }
37075 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
37076 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
37077 }
37078 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
37079 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
37080 }
37081 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
37082 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
37083 }
37084 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
37085 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
37086 }
37087 static void *_p_wxSizerTo_p_wxObject(void *x) {
37088 return (void *)((wxObject *) ((wxSizer *) x));
37089 }
37090 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
37091 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
37092 }
37093 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
37094 return (void *)((wxObject *) ((wxFileHistory *) x));
37095 }
37096 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
37097 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
37098 }
37099 static void *_p_wxEventTo_p_wxObject(void *x) {
37100 return (void *)((wxObject *) ((wxEvent *) x));
37101 }
37102 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
37103 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
37104 }
37105 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
37106 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
37107 }
37108 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
37109 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
37110 }
37111 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
37112 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
37113 }
37114 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
37115 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
37116 }
37117 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
37118 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
37119 }
37120 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
37121 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
37122 }
37123 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
37124 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
37125 }
37126 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
37127 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
37128 }
37129 static void *_p_wxControlTo_p_wxObject(void *x) {
37130 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
37131 }
37132 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
37133 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
37134 }
37135 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
37136 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
37137 }
37138 static void *_p_wxFSFileTo_p_wxObject(void *x) {
37139 return (void *)((wxObject *) ((wxFSFile *) x));
37140 }
37141 static void *_p_wxClipboardTo_p_wxObject(void *x) {
37142 return (void *)((wxObject *) ((wxClipboard *) x));
37143 }
37144 static void *_p_wxPySizerTo_p_wxObject(void *x) {
37145 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
37146 }
37147 static void *_p_wxPyEventTo_p_wxObject(void *x) {
37148 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
37149 }
37150 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
37151 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
37152 }
37153 static void *_p_wxShowEventTo_p_wxObject(void *x) {
37154 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
37155 }
37156 static void *_p_wxToolTipTo_p_wxObject(void *x) {
37157 return (void *)((wxObject *) ((wxToolTip *) x));
37158 }
37159 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
37160 return (void *)((wxObject *) ((wxMenuItem *) x));
37161 }
37162 static void *_p_wxDateEventTo_p_wxObject(void *x) {
37163 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
37164 }
37165 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
37166 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
37167 }
37168 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
37169 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
37170 }
37171 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
37172 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
37173 }
37174 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
37175 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
37176 }
37177 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
37178 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
37179 }
37180 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
37181 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
37182 }
37183 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
37184 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
37185 }
37186 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
37187 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
37188 }
37189 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
37190 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
37191 }
37192 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
37193 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
37194 }
37195 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
37196 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
37197 }
37198 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
37199 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
37200 }
37201 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
37202 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
37203 }
37204 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
37205 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
37206 }
37207 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
37208 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
37209 }
37210 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
37211 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
37212 }
37213 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
37214 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
37215 }
37216 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
37217 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
37218 }
37219 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
37220 return (void *)((wxObject *) ((wxImageHandler *) x));
37221 }
37222 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
37223 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
37224 }
37225 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
37226 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
37227 }
37228 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
37229 return (void *)((wxObject *) ((wxEvtHandler *) x));
37230 }
37231 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
37232 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
37233 }
37234 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
37235 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
37236 }
37237 static void *_p_wxImageTo_p_wxObject(void *x) {
37238 return (void *)((wxObject *) ((wxImage *) x));
37239 }
37240 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
37241 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
37242 }
37243 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
37244 return (void *)((wxObject *) ((wxSystemOptions *) x));
37245 }
37246 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
37247 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
37248 }
37249 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
37250 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
37251 }
37252 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
37253 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
37254 }
37255 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
37256 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
37257 }
37258 static void *_p_wxWindowTo_p_wxObject(void *x) {
37259 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
37260 }
37261 static void *_p_wxMenuTo_p_wxObject(void *x) {
37262 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
37263 }
37264 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
37265 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
37266 }
37267 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
37268 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
37269 }
37270 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
37271 return (void *)((wxObject *) ((wxFileSystem *) x));
37272 }
37273 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
37274 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
37275 }
37276 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
37277 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
37278 }
37279 static void *_p_wxPyAppTo_p_wxObject(void *x) {
37280 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
37281 }
37282 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
37283 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
37284 }
37285 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
37286 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
37287 }
37288 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
37289 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
37290 }
37291 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
37292 return (void *)((wxObject *) ((wxBusyInfo *) x));
37293 }
37294 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
37295 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
37296 }
37297 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
37298 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
37299 }
37300 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
37301 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
37302 }
37303 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
37304 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
37305 }
37306 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
37307 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
37308 }
37309 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
37310 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
37311 }
37312 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
37313 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
37314 }
37315 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
37316 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
37317 }
37318 static void *_p_wxValidatorTo_p_wxObject(void *x) {
37319 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
37320 }
37321 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
37322 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
37323 }
37324 static void *_p_wxLogBufferTo_p_wxLog(void *x) {
37325 return (void *)((wxLog *) ((wxLogBuffer *) x));
37326 }
37327 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
37328 return (void *)((wxLog *) ((wxLogStderr *) x));
37329 }
37330 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
37331 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
37332 }
37333 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
37334 return (void *)((wxLog *) ((wxLogWindow *) x));
37335 }
37336 static void *_p_wxLogChainTo_p_wxLog(void *x) {
37337 return (void *)((wxLog *) ((wxLogChain *) x));
37338 }
37339 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
37340 return (void *)((wxLog *) ((wxLogGui *) x));
37341 }
37342 static void *_p_wxPyLogTo_p_wxLog(void *x) {
37343 return (void *)((wxLog *) ((wxPyLog *) x));
37344 }
37345 static void *_p_wxControlTo_p_wxWindow(void *x) {
37346 return (void *)((wxWindow *) ((wxControl *) x));
37347 }
37348 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
37349 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
37350 }
37351 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
37352 return (void *)((wxWindow *) ((wxMenuBar *) x));
37353 }
37354 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
37355 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
37356 }
37357 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
37358 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
37359 }
37360 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
37361 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};
37362 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
37363 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
37364 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
37365 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxLogLevel *", 0, 0, (void*)0, 0};
37366 static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
37367 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
37368 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
37369 static swig_type_info _swigt__p_wxBitmapDataObject = {"_p_wxBitmapDataObject", "wxBitmapDataObject *", 0, 0, (void*)0, 0};
37370 static swig_type_info _swigt__p_wxBusyCursor = {"_p_wxBusyCursor", "wxBusyCursor *", 0, 0, (void*)0, 0};
37371 static swig_type_info _swigt__p_wxBusyInfo = {"_p_wxBusyInfo", "wxBusyInfo *", 0, 0, (void*)0, 0};
37372 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
37373 static swig_type_info _swigt__p_wxChar = {"_p_wxChar", "wxChar *", 0, 0, (void*)0, 0};
37374 static swig_type_info _swigt__p_wxClipboard = {"_p_wxClipboard", "wxClipboard *", 0, 0, (void*)0, 0};
37375 static swig_type_info _swigt__p_wxClipboardLocker = {"_p_wxClipboardLocker", "wxClipboardLocker *", 0, 0, (void*)0, 0};
37376 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
37377 static swig_type_info _swigt__p_wxConfig = {"_p_wxConfig", "wxConfig *", 0, 0, (void*)0, 0};
37378 static swig_type_info _swigt__p_wxConfigBase = {"_p_wxConfigBase", "wxConfigBase *", 0, 0, (void*)0, 0};
37379 static swig_type_info _swigt__p_wxConfigPathChanger = {"_p_wxConfigPathChanger", "wxConfigPathChanger *", 0, 0, (void*)0, 0};
37380 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
37381 static swig_type_info _swigt__p_wxCustomDataObject = {"_p_wxCustomDataObject", "wxCustomDataObject *", 0, 0, (void*)0, 0};
37382 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
37383 static swig_type_info _swigt__p_wxDataFormat = {"_p_wxDataFormat", "wxDataFormat *", 0, 0, (void*)0, 0};
37384 static swig_type_info _swigt__p_wxDataObject = {"_p_wxDataObject", "wxDataObject *", 0, 0, (void*)0, 0};
37385 static swig_type_info _swigt__p_wxDataObjectComposite = {"_p_wxDataObjectComposite", "wxDataObjectComposite *", 0, 0, (void*)0, 0};
37386 static swig_type_info _swigt__p_wxDataObjectSimple = {"_p_wxDataObjectSimple", "wxDataObjectSimple *", 0, 0, (void*)0, 0};
37387 static swig_type_info _swigt__p_wxDateSpan = {"_p_wxDateSpan", "wxDateSpan *", 0, 0, (void*)0, 0};
37388 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
37389 static swig_type_info _swigt__p_wxDateTime__TimeZone = {"_p_wxDateTime__TimeZone", "wxDateTime::TimeZone *", 0, 0, (void*)0, 0};
37390 static swig_type_info _swigt__p_wxDisplay = {"_p_wxDisplay", "wxDisplay *", 0, 0, (void*)0, 0};
37391 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
37392 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
37393 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0, 0};
37394 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0, 0};
37395 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0, 0};
37396 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0, 0};
37397 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0, 0};
37398 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0, 0};
37399 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0, 0};
37400 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0, 0};
37401 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0, 0};
37402 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", 0, 0, 0, 0, 0};
37403 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0, 0};
37404 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0};
37405 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0};
37406 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0, 0};
37407 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0, 0};
37408 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0, 0};
37409 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0, 0};
37410 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0, 0};
37411 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0, 0};
37412 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0, 0};
37413 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0, 0};
37414 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0};
37415 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0};
37416 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0};
37417 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0};
37418 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0};
37419 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0, 0};
37420 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0, 0};
37421 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0, 0};
37422 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0, 0};
37423 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", 0, 0, 0, 0, 0};
37424 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0, 0};
37425 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0};
37426 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0};
37427 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", 0, 0, 0, 0, 0};
37428 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0, 0};
37429 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
37430 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", 0, 0, 0, 0, 0};
37431 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0, 0};
37432 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0, 0};
37433 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0, 0};
37434 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0, 0};
37435 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0, 0};
37436 static swig_type_info _swigt__p_wxFileConfig = {"_p_wxFileConfig", "wxFileConfig *", 0, 0, (void*)0, 0};
37437 static swig_type_info _swigt__p_wxFileDataObject = {"_p_wxFileDataObject", "wxFileDataObject *", 0, 0, (void*)0, 0};
37438 static swig_type_info _swigt__p_wxFileHistory = {"_p_wxFileHistory", "wxFileHistory *", 0, 0, (void*)0, 0};
37439 static swig_type_info _swigt__p_wxFileType = {"_p_wxFileType", "wxFileType *", 0, 0, (void*)0, 0};
37440 static swig_type_info _swigt__p_wxFileTypeInfo = {"_p_wxFileTypeInfo", "wxFileTypeInfo *", 0, 0, (void*)0, 0};
37441 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
37442 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
37443 static swig_type_info _swigt__p_wxIcon = {"_p_wxIcon", "wxIcon *", 0, 0, (void*)0, 0};
37444 static swig_type_info _swigt__p_wxJoystick = {"_p_wxJoystick", "wxJoystick *", 0, 0, (void*)0, 0};
37445 static swig_type_info _swigt__p_wxJoystickEvent = {"_p_wxJoystickEvent", "wxJoystickEvent *", 0, 0, (void*)0, 0};
37446 static swig_type_info _swigt__p_wxKillError = {"_p_wxKillError", "enum wxKillError *|wxKillError *", 0, 0, (void*)0, 0};
37447 static swig_type_info _swigt__p_wxLog = {"_p_wxLog", "wxLog *", 0, 0, (void*)0, 0};
37448 static swig_type_info _swigt__p_wxLogBuffer = {"_p_wxLogBuffer", "wxLogBuffer *", 0, 0, (void*)0, 0};
37449 static swig_type_info _swigt__p_wxLogChain = {"_p_wxLogChain", "wxLogChain *", 0, 0, (void*)0, 0};
37450 static swig_type_info _swigt__p_wxLogGui = {"_p_wxLogGui", "wxLogGui *", 0, 0, (void*)0, 0};
37451 static swig_type_info _swigt__p_wxLogNull = {"_p_wxLogNull", "wxLogNull *", 0, 0, (void*)0, 0};
37452 static swig_type_info _swigt__p_wxLogStderr = {"_p_wxLogStderr", "wxLogStderr *", 0, 0, (void*)0, 0};
37453 static swig_type_info _swigt__p_wxLogTextCtrl = {"_p_wxLogTextCtrl", "wxLogTextCtrl *", 0, 0, (void*)0, 0};
37454 static swig_type_info _swigt__p_wxLogWindow = {"_p_wxLogWindow", "wxLogWindow *", 0, 0, (void*)0, 0};
37455 static swig_type_info _swigt__p_wxMemorySize = {"_p_wxMemorySize", "wxMemorySize *", 0, 0, (void*)0, 0};
37456 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
37457 static swig_type_info _swigt__p_wxMetafileDataObject = {"_p_wxMetafileDataObject", "wxMetafileDataObject *", 0, 0, (void*)0, 0};
37458 static swig_type_info _swigt__p_wxMimeTypesManager = {"_p_wxMimeTypesManager", "wxMimeTypesManager *", 0, 0, (void*)0, 0};
37459 static swig_type_info _swigt__p_wxMouseState = {"_p_wxMouseState", "wxMouseState *", 0, 0, (void*)0, 0};
37460 static swig_type_info _swigt__p_wxMutexGuiLocker = {"_p_wxMutexGuiLocker", "wxMutexGuiLocker *", 0, 0, (void*)0, 0};
37461 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
37462 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0, 0};
37463 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0, 0};
37464 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0, 0};
37465 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0};
37466 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0};
37467 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0, 0};
37468 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0, 0};
37469 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0, 0};
37470 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0, 0};
37471 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0, 0};
37472 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0, 0};
37473 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0, 0};
37474 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0, 0};
37475 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0, 0};
37476 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0, 0};
37477 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0, 0};
37478 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0, 0};
37479 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0, 0};
37480 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0, 0};
37481 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0, 0};
37482 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0, 0};
37483 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0, 0};
37484 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0, 0};
37485 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0, 0};
37486 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0, 0};
37487 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0, 0};
37488 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0};
37489 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0, 0};
37490 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", 0, 0, 0, 0, 0};
37491 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0, 0};
37492 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
37493 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
37494 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
37495 static swig_type_info _swigt__p_wxProcessEvent = {"_p_wxProcessEvent", "wxProcessEvent *", 0, 0, (void*)0, 0};
37496 static swig_type_info _swigt__p_wxPyArtProvider = {"_p_wxPyArtProvider", "wxPyArtProvider *", 0, 0, (void*)0, 0};
37497 static swig_type_info _swigt__p_wxPyBitmapDataObject = {"_p_wxPyBitmapDataObject", "wxPyBitmapDataObject *", 0, 0, (void*)0, 0};
37498 static swig_type_info _swigt__p_wxPyDataObjectSimple = {"_p_wxPyDataObjectSimple", "wxPyDataObjectSimple *", 0, 0, (void*)0, 0};
37499 static swig_type_info _swigt__p_wxPyDropSource = {"_p_wxPyDropSource", "wxPyDropSource *", 0, 0, (void*)0, 0};
37500 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
37501 static swig_type_info _swigt__p_wxPyFileDropTarget = {"_p_wxPyFileDropTarget", "wxPyFileDropTarget *", 0, 0, (void*)0, 0};
37502 static swig_type_info _swigt__p_wxPyLog = {"_p_wxPyLog", "wxPyLog *", 0, 0, (void*)0, 0};
37503 static swig_type_info _swigt__p_wxPyProcess = {"_p_wxPyProcess", "wxPyProcess *", 0, 0, (void*)0, 0};
37504 static swig_type_info _swigt__p_wxPyTextDataObject = {"_p_wxPyTextDataObject", "wxPyTextDataObject *", 0, 0, (void*)0, 0};
37505 static swig_type_info _swigt__p_wxPyTextDropTarget = {"_p_wxPyTextDropTarget", "wxPyTextDropTarget *", 0, 0, (void*)0, 0};
37506 static swig_type_info _swigt__p_wxPyTimer = {"_p_wxPyTimer", "wxPyTimer *", 0, 0, (void*)0, 0};
37507 static swig_type_info _swigt__p_wxPyTipProvider = {"_p_wxPyTipProvider", "wxPyTipProvider *", 0, 0, (void*)0, 0};
37508 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
37509 static swig_type_info _swigt__p_wxSingleInstanceChecker = {"_p_wxSingleInstanceChecker", "wxSingleInstanceChecker *", 0, 0, (void*)0, 0};
37510 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
37511 static swig_type_info _swigt__p_wxSound = {"_p_wxSound", "wxSound *", 0, 0, (void*)0, 0};
37512 static swig_type_info _swigt__p_wxStandardPaths = {"_p_wxStandardPaths", "wxStandardPaths *", 0, 0, (void*)0, 0};
37513 static swig_type_info _swigt__p_wxStopWatch = {"_p_wxStopWatch", "wxStopWatch *", 0, 0, (void*)0, 0};
37514 static swig_type_info _swigt__p_wxString = {"_p_wxString", "wxString *", 0, 0, (void*)0, 0};
37515 static swig_type_info _swigt__p_wxSystemOptions = {"_p_wxSystemOptions", "wxSystemOptions *", 0, 0, (void*)0, 0};
37516 static swig_type_info _swigt__p_wxSystemSettings = {"_p_wxSystemSettings", "wxSystemSettings *", 0, 0, (void*)0, 0};
37517 static swig_type_info _swigt__p_wxTextCtrl = {"_p_wxTextCtrl", "wxTextCtrl *", 0, 0, (void*)0, 0};
37518 static swig_type_info _swigt__p_wxTextDataObject = {"_p_wxTextDataObject", "wxTextDataObject *", 0, 0, (void*)0, 0};
37519 static swig_type_info _swigt__p_wxTimeSpan = {"_p_wxTimeSpan", "wxTimeSpan *", 0, 0, (void*)0, 0};
37520 static swig_type_info _swigt__p_wxTimer = {"_p_wxTimer", "wxTimer *", 0, 0, (void*)0, 0};
37521 static swig_type_info _swigt__p_wxTimerEvent = {"_p_wxTimerEvent", "wxTimerEvent *", 0, 0, (void*)0, 0};
37522 static swig_type_info _swigt__p_wxTimerRunner = {"_p_wxTimerRunner", "wxTimerRunner *", 0, 0, (void*)0, 0};
37523 static swig_type_info _swigt__p_wxTipProvider = {"_p_wxTipProvider", "wxTipProvider *", 0, 0, (void*)0, 0};
37524 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
37525 static swig_type_info _swigt__p_wxURLDataObject = {"_p_wxURLDataObject", "wxURLDataObject *", 0, 0, (void*)0, 0};
37526 static swig_type_info _swigt__p_wxVideoMode = {"_p_wxVideoMode", "wxVideoMode *", 0, 0, (void*)0, 0};
37527 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
37528 static swig_type_info _swigt__p_wxWindowDisabler = {"_p_wxWindowDisabler", "wxWindowDisabler *", 0, 0, (void*)0, 0};
37529
37530 static swig_type_info *swig_type_initial[] = {
37531 &_swigt__p_char,
37532 &_swigt__p_form_ops_t,
37533 &_swigt__p_int,
37534 &_swigt__p_unsigned_char,
37535 &_swigt__p_unsigned_int,
37536 &_swigt__p_unsigned_long,
37537 &_swigt__p_void,
37538 &_swigt__p_wxANIHandler,
37539 &_swigt__p_wxAcceleratorTable,
37540 &_swigt__p_wxActivateEvent,
37541 &_swigt__p_wxArrayString,
37542 &_swigt__p_wxBMPHandler,
37543 &_swigt__p_wxBitmap,
37544 &_swigt__p_wxBitmapDataObject,
37545 &_swigt__p_wxBoxSizer,
37546 &_swigt__p_wxBusyCursor,
37547 &_swigt__p_wxBusyInfo,
37548 &_swigt__p_wxCURHandler,
37549 &_swigt__p_wxCaret,
37550 &_swigt__p_wxChar,
37551 &_swigt__p_wxChildFocusEvent,
37552 &_swigt__p_wxClipboard,
37553 &_swigt__p_wxClipboardLocker,
37554 &_swigt__p_wxCloseEvent,
37555 &_swigt__p_wxColour,
37556 &_swigt__p_wxCommandEvent,
37557 &_swigt__p_wxConfig,
37558 &_swigt__p_wxConfigBase,
37559 &_swigt__p_wxConfigPathChanger,
37560 &_swigt__p_wxContextMenuEvent,
37561 &_swigt__p_wxControl,
37562 &_swigt__p_wxControlWithItems,
37563 &_swigt__p_wxCursor,
37564 &_swigt__p_wxCustomDataObject,
37565 &_swigt__p_wxDC,
37566 &_swigt__p_wxDataFormat,
37567 &_swigt__p_wxDataObject,
37568 &_swigt__p_wxDataObjectComposite,
37569 &_swigt__p_wxDataObjectSimple,
37570 &_swigt__p_wxDateEvent,
37571 &_swigt__p_wxDateSpan,
37572 &_swigt__p_wxDateTime,
37573 &_swigt__p_wxDateTime__TimeZone,
37574 &_swigt__p_wxDisplay,
37575 &_swigt__p_wxDisplayChangedEvent,
37576 &_swigt__p_wxDropFilesEvent,
37577 &_swigt__p_wxDuplexMode,
37578 &_swigt__p_wxEraseEvent,
37579 &_swigt__p_wxEvent,
37580 &_swigt__p_wxEvtHandler,
37581 &_swigt__p_wxFSFile,
37582 &_swigt__p_wxFileConfig,
37583 &_swigt__p_wxFileDataObject,
37584 &_swigt__p_wxFileHistory,
37585 &_swigt__p_wxFileSystem,
37586 &_swigt__p_wxFileType,
37587 &_swigt__p_wxFileTypeInfo,
37588 &_swigt__p_wxFlexGridSizer,
37589 &_swigt__p_wxFocusEvent,
37590 &_swigt__p_wxFont,
37591 &_swigt__p_wxFrame,
37592 &_swigt__p_wxGBSizerItem,
37593 &_swigt__p_wxGIFHandler,
37594 &_swigt__p_wxGridBagSizer,
37595 &_swigt__p_wxGridSizer,
37596 &_swigt__p_wxICOHandler,
37597 &_swigt__p_wxIcon,
37598 &_swigt__p_wxIconizeEvent,
37599 &_swigt__p_wxIdleEvent,
37600 &_swigt__p_wxImage,
37601 &_swigt__p_wxImageHandler,
37602 &_swigt__p_wxIndividualLayoutConstraint,
37603 &_swigt__p_wxInitDialogEvent,
37604 &_swigt__p_wxJPEGHandler,
37605 &_swigt__p_wxJoystick,
37606 &_swigt__p_wxJoystickEvent,
37607 &_swigt__p_wxKeyEvent,
37608 &_swigt__p_wxKillError,
37609 &_swigt__p_wxLayoutConstraints,
37610 &_swigt__p_wxLog,
37611 &_swigt__p_wxLogBuffer,
37612 &_swigt__p_wxLogChain,
37613 &_swigt__p_wxLogGui,
37614 &_swigt__p_wxLogNull,
37615 &_swigt__p_wxLogStderr,
37616 &_swigt__p_wxLogTextCtrl,
37617 &_swigt__p_wxLogWindow,
37618 &_swigt__p_wxMaximizeEvent,
37619 &_swigt__p_wxMemorySize,
37620 &_swigt__p_wxMenu,
37621 &_swigt__p_wxMenuBar,
37622 &_swigt__p_wxMenuEvent,
37623 &_swigt__p_wxMenuItem,
37624 &_swigt__p_wxMetafileDataObject,
37625 &_swigt__p_wxMimeTypesManager,
37626 &_swigt__p_wxMouseCaptureChangedEvent,
37627 &_swigt__p_wxMouseEvent,
37628 &_swigt__p_wxMouseState,
37629 &_swigt__p_wxMoveEvent,
37630 &_swigt__p_wxMutexGuiLocker,
37631 &_swigt__p_wxNavigationKeyEvent,
37632 &_swigt__p_wxNcPaintEvent,
37633 &_swigt__p_wxNotifyEvent,
37634 &_swigt__p_wxObject,
37635 &_swigt__p_wxOutputStream,
37636 &_swigt__p_wxPCXHandler,
37637 &_swigt__p_wxPNGHandler,
37638 &_swigt__p_wxPNMHandler,
37639 &_swigt__p_wxPaintEvent,
37640 &_swigt__p_wxPaletteChangedEvent,
37641 &_swigt__p_wxPaperSize,
37642 &_swigt__p_wxPoint,
37643 &_swigt__p_wxProcessEvent,
37644 &_swigt__p_wxPyApp,
37645 &_swigt__p_wxPyArtProvider,
37646 &_swigt__p_wxPyBitmapDataObject,
37647 &_swigt__p_wxPyCommandEvent,
37648 &_swigt__p_wxPyDataObjectSimple,
37649 &_swigt__p_wxPyDropSource,
37650 &_swigt__p_wxPyDropTarget,
37651 &_swigt__p_wxPyEvent,
37652 &_swigt__p_wxPyFileDropTarget,
37653 &_swigt__p_wxPyImageHandler,
37654 &_swigt__p_wxPyLog,
37655 &_swigt__p_wxPyProcess,
37656 &_swigt__p_wxPySizer,
37657 &_swigt__p_wxPyTextDataObject,
37658 &_swigt__p_wxPyTextDropTarget,
37659 &_swigt__p_wxPyTimer,
37660 &_swigt__p_wxPyTipProvider,
37661 &_swigt__p_wxPyValidator,
37662 &_swigt__p_wxQueryNewPaletteEvent,
37663 &_swigt__p_wxRect,
37664 &_swigt__p_wxScrollEvent,
37665 &_swigt__p_wxScrollWinEvent,
37666 &_swigt__p_wxSetCursorEvent,
37667 &_swigt__p_wxShowEvent,
37668 &_swigt__p_wxSingleInstanceChecker,
37669 &_swigt__p_wxSize,
37670 &_swigt__p_wxSizeEvent,
37671 &_swigt__p_wxSizer,
37672 &_swigt__p_wxSizerItem,
37673 &_swigt__p_wxSound,
37674 &_swigt__p_wxStandardPaths,
37675 &_swigt__p_wxStaticBoxSizer,
37676 &_swigt__p_wxStdDialogButtonSizer,
37677 &_swigt__p_wxStopWatch,
37678 &_swigt__p_wxString,
37679 &_swigt__p_wxSysColourChangedEvent,
37680 &_swigt__p_wxSystemOptions,
37681 &_swigt__p_wxSystemSettings,
37682 &_swigt__p_wxTIFFHandler,
37683 &_swigt__p_wxTextCtrl,
37684 &_swigt__p_wxTextDataObject,
37685 &_swigt__p_wxTimeSpan,
37686 &_swigt__p_wxTimer,
37687 &_swigt__p_wxTimerEvent,
37688 &_swigt__p_wxTimerRunner,
37689 &_swigt__p_wxTipProvider,
37690 &_swigt__p_wxToolTip,
37691 &_swigt__p_wxURLDataObject,
37692 &_swigt__p_wxUpdateUIEvent,
37693 &_swigt__p_wxValidator,
37694 &_swigt__p_wxVideoMode,
37695 &_swigt__p_wxWindow,
37696 &_swigt__p_wxWindowCreateEvent,
37697 &_swigt__p_wxWindowDestroyEvent,
37698 &_swigt__p_wxWindowDisabler,
37699 &_swigt__p_wxXPMHandler,
37700 };
37701
37702 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
37703 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
37704 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
37705 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
37706 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
37707 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
37708 static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
37709 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
37710 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
37711 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}};
37712 static swig_cast_info _swigc__p_wxBusyCursor[] = { {&_swigt__p_wxBusyCursor, 0, 0, 0},{0, 0, 0, 0}};
37713 static swig_cast_info _swigc__p_wxBusyInfo[] = { {&_swigt__p_wxBusyInfo, 0, 0, 0},{0, 0, 0, 0}};
37714 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
37715 static swig_cast_info _swigc__p_wxChar[] = { {&_swigt__p_wxChar, 0, 0, 0},{0, 0, 0, 0}};
37716 static swig_cast_info _swigc__p_wxClipboard[] = { {&_swigt__p_wxClipboard, 0, 0, 0},{0, 0, 0, 0}};
37717 static swig_cast_info _swigc__p_wxClipboardLocker[] = { {&_swigt__p_wxClipboardLocker, 0, 0, 0},{0, 0, 0, 0}};
37718 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
37719 static swig_cast_info _swigc__p_wxConfig[] = { {&_swigt__p_wxConfig, 0, 0, 0},{0, 0, 0, 0}};
37720 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}};
37721 static swig_cast_info _swigc__p_wxConfigPathChanger[] = { {&_swigt__p_wxConfigPathChanger, 0, 0, 0},{0, 0, 0, 0}};
37722 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
37723 static swig_cast_info _swigc__p_wxCustomDataObject[] = { {&_swigt__p_wxCustomDataObject, 0, 0, 0},{0, 0, 0, 0}};
37724 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
37725 static swig_cast_info _swigc__p_wxDataFormat[] = { {&_swigt__p_wxDataFormat, 0, 0, 0},{0, 0, 0, 0}};
37726 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}};
37727 static swig_cast_info _swigc__p_wxDataObjectComposite[] = { {&_swigt__p_wxDataObjectComposite, 0, 0, 0},{0, 0, 0, 0}};
37728 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}};
37729 static swig_cast_info _swigc__p_wxDateSpan[] = { {&_swigt__p_wxDateSpan, 0, 0, 0},{0, 0, 0, 0}};
37730 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
37731 static swig_cast_info _swigc__p_wxDateTime__TimeZone[] = { {&_swigt__p_wxDateTime__TimeZone, 0, 0, 0},{0, 0, 0, 0}};
37732 static swig_cast_info _swigc__p_wxDisplay[] = { {&_swigt__p_wxDisplay, 0, 0, 0},{0, 0, 0, 0}};
37733 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
37734 static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
37735 static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
37736 static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
37737 static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
37738 static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
37739 static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
37740 static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
37741 static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
37742 static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
37743 static swig_cast_info _swigc__p_wxNotifyEvent[] = {{&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
37744 static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
37745 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
37746 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
37747 static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
37748 static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
37749 static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
37750 static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
37751 static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
37752 static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
37753 static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
37754 static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
37755 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
37756 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
37757 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
37758 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
37759 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
37760 static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
37761 static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
37762 static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
37763 static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
37764 static swig_cast_info _swigc__p_wxCommandEvent[] = {{&_swigt__p_wxCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
37765 static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
37766 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
37767 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
37768 static swig_cast_info _swigc__p_wxKeyEvent[] = {{&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
37769 static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
37770 static swig_cast_info _swigc__p_wxEvent[] = { {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxTimerEvent, _p_wxTimerEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxJoystickEvent, _p_wxJoystickEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEvent, 0, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxProcessEvent, _p_wxProcessEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxEvent, 0, 0},{0, 0, 0, 0}};
37771 static swig_cast_info _swigc__p_wxControl[] = {{&_swigt__p_wxControl, 0, 0, 0},{0, 0, 0, 0}};
37772 static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
37773 static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
37774 static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
37775 static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};
37776 static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
37777 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}};
37778 static swig_cast_info _swigc__p_wxFileConfig[] = { {&_swigt__p_wxFileConfig, 0, 0, 0},{0, 0, 0, 0}};
37779 static swig_cast_info _swigc__p_wxFileDataObject[] = { {&_swigt__p_wxFileDataObject, 0, 0, 0},{0, 0, 0, 0}};
37780 static swig_cast_info _swigc__p_wxFileHistory[] = { {&_swigt__p_wxFileHistory, 0, 0, 0},{0, 0, 0, 0}};
37781 static swig_cast_info _swigc__p_wxFileType[] = { {&_swigt__p_wxFileType, 0, 0, 0},{0, 0, 0, 0}};
37782 static swig_cast_info _swigc__p_wxFileTypeInfo[] = { {&_swigt__p_wxFileTypeInfo, 0, 0, 0},{0, 0, 0, 0}};
37783 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
37784 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
37785 static swig_cast_info _swigc__p_wxIcon[] = { {&_swigt__p_wxIcon, 0, 0, 0},{0, 0, 0, 0}};
37786 static swig_cast_info _swigc__p_wxJoystick[] = { {&_swigt__p_wxJoystick, 0, 0, 0},{0, 0, 0, 0}};
37787 static swig_cast_info _swigc__p_wxJoystickEvent[] = { {&_swigt__p_wxJoystickEvent, 0, 0, 0},{0, 0, 0, 0}};
37788 static swig_cast_info _swigc__p_wxKillError[] = { {&_swigt__p_wxKillError, 0, 0, 0},{0, 0, 0, 0}};
37789 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}};
37790 static swig_cast_info _swigc__p_wxLogBuffer[] = { {&_swigt__p_wxLogBuffer, 0, 0, 0},{0, 0, 0, 0}};
37791 static swig_cast_info _swigc__p_wxLogChain[] = { {&_swigt__p_wxLogChain, 0, 0, 0},{0, 0, 0, 0}};
37792 static swig_cast_info _swigc__p_wxLogGui[] = { {&_swigt__p_wxLogGui, 0, 0, 0},{0, 0, 0, 0}};
37793 static swig_cast_info _swigc__p_wxLogNull[] = { {&_swigt__p_wxLogNull, 0, 0, 0},{0, 0, 0, 0}};
37794 static swig_cast_info _swigc__p_wxLogStderr[] = { {&_swigt__p_wxLogStderr, 0, 0, 0},{0, 0, 0, 0}};
37795 static swig_cast_info _swigc__p_wxLogTextCtrl[] = { {&_swigt__p_wxLogTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
37796 static swig_cast_info _swigc__p_wxLogWindow[] = { {&_swigt__p_wxLogWindow, 0, 0, 0},{0, 0, 0, 0}};
37797 static swig_cast_info _swigc__p_wxMemorySize[] = { {&_swigt__p_wxMemorySize, 0, 0, 0},{0, 0, 0, 0}};
37798 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
37799 static swig_cast_info _swigc__p_wxMetafileDataObject[] = { {&_swigt__p_wxMetafileDataObject, 0, 0, 0},{0, 0, 0, 0}};
37800 static swig_cast_info _swigc__p_wxMimeTypesManager[] = { {&_swigt__p_wxMimeTypesManager, 0, 0, 0},{0, 0, 0, 0}};
37801 static swig_cast_info _swigc__p_wxMouseState[] = { {&_swigt__p_wxMouseState, 0, 0, 0},{0, 0, 0, 0}};
37802 static swig_cast_info _swigc__p_wxMutexGuiLocker[] = { {&_swigt__p_wxMutexGuiLocker, 0, 0, 0},{0, 0, 0, 0}};
37803 static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
37804 static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
37805 static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
37806 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
37807 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
37808 static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
37809 static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
37810 static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
37811 static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
37812 static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
37813 static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
37814 static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
37815 static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
37816 static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
37817 static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
37818 static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
37819 static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
37820 static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
37821 static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
37822 static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
37823 static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
37824 static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
37825 static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
37826 static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
37827 static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
37828 static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
37829 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
37830 static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
37831 static swig_cast_info _swigc__p_wxImage[] = {{&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
37832 static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
37833 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileHistory, _p_wxFileHistoryTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxTimerEvent, _p_wxTimerEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboard, _p_wxClipboardTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxToolTip, _p_wxToolTipTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSystemOptions, _p_wxSystemOptionsTo_p_wxObject, 0, 0}, {&_swigt__p_wxJoystickEvent, _p_wxJoystickEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyProcess, _p_wxPyProcessTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxBusyInfo, _p_wxBusyInfoTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxProcessEvent, _p_wxProcessEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyTimer, _p_wxPyTimerTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
37834 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
37835 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
37836 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
37837 static swig_cast_info _swigc__p_wxProcessEvent[] = { {&_swigt__p_wxProcessEvent, 0, 0, 0},{0, 0, 0, 0}};
37838 static swig_cast_info _swigc__p_wxPyArtProvider[] = { {&_swigt__p_wxPyArtProvider, 0, 0, 0},{0, 0, 0, 0}};
37839 static swig_cast_info _swigc__p_wxPyBitmapDataObject[] = { {&_swigt__p_wxPyBitmapDataObject, 0, 0, 0},{0, 0, 0, 0}};
37840 static swig_cast_info _swigc__p_wxPyDataObjectSimple[] = { {&_swigt__p_wxPyDataObjectSimple, 0, 0, 0},{0, 0, 0, 0}};
37841 static swig_cast_info _swigc__p_wxPyDropSource[] = { {&_swigt__p_wxPyDropSource, 0, 0, 0},{0, 0, 0, 0}};
37842 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}};
37843 static swig_cast_info _swigc__p_wxPyFileDropTarget[] = { {&_swigt__p_wxPyFileDropTarget, 0, 0, 0},{0, 0, 0, 0}};
37844 static swig_cast_info _swigc__p_wxPyLog[] = { {&_swigt__p_wxPyLog, 0, 0, 0},{0, 0, 0, 0}};
37845 static swig_cast_info _swigc__p_wxPyProcess[] = { {&_swigt__p_wxPyProcess, 0, 0, 0},{0, 0, 0, 0}};
37846 static swig_cast_info _swigc__p_wxPyTextDataObject[] = { {&_swigt__p_wxPyTextDataObject, 0, 0, 0},{0, 0, 0, 0}};
37847 static swig_cast_info _swigc__p_wxPyTextDropTarget[] = { {&_swigt__p_wxPyTextDropTarget, 0, 0, 0},{0, 0, 0, 0}};
37848 static swig_cast_info _swigc__p_wxPyTimer[] = { {&_swigt__p_wxPyTimer, 0, 0, 0},{0, 0, 0, 0}};
37849 static swig_cast_info _swigc__p_wxPyTipProvider[] = { {&_swigt__p_wxPyTipProvider, 0, 0, 0},{0, 0, 0, 0}};
37850 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
37851 static swig_cast_info _swigc__p_wxSingleInstanceChecker[] = { {&_swigt__p_wxSingleInstanceChecker, 0, 0, 0},{0, 0, 0, 0}};
37852 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
37853 static swig_cast_info _swigc__p_wxSound[] = { {&_swigt__p_wxSound, 0, 0, 0},{0, 0, 0, 0}};
37854 static swig_cast_info _swigc__p_wxStandardPaths[] = { {&_swigt__p_wxStandardPaths, 0, 0, 0},{0, 0, 0, 0}};
37855 static swig_cast_info _swigc__p_wxStopWatch[] = { {&_swigt__p_wxStopWatch, 0, 0, 0},{0, 0, 0, 0}};
37856 static swig_cast_info _swigc__p_wxString[] = { {&_swigt__p_wxString, 0, 0, 0},{0, 0, 0, 0}};
37857 static swig_cast_info _swigc__p_wxSystemOptions[] = { {&_swigt__p_wxSystemOptions, 0, 0, 0},{0, 0, 0, 0}};
37858 static swig_cast_info _swigc__p_wxSystemSettings[] = { {&_swigt__p_wxSystemSettings, 0, 0, 0},{0, 0, 0, 0}};
37859 static swig_cast_info _swigc__p_wxTextCtrl[] = { {&_swigt__p_wxTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
37860 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}};
37861 static swig_cast_info _swigc__p_wxTimeSpan[] = { {&_swigt__p_wxTimeSpan, 0, 0, 0},{0, 0, 0, 0}};
37862 static swig_cast_info _swigc__p_wxTimer[] = { {&_swigt__p_wxTimer, 0, 0, 0},{0, 0, 0, 0}};
37863 static swig_cast_info _swigc__p_wxTimerEvent[] = { {&_swigt__p_wxTimerEvent, 0, 0, 0},{0, 0, 0, 0}};
37864 static swig_cast_info _swigc__p_wxTimerRunner[] = { {&_swigt__p_wxTimerRunner, 0, 0, 0},{0, 0, 0, 0}};
37865 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}};
37866 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
37867 static swig_cast_info _swigc__p_wxURLDataObject[] = { {&_swigt__p_wxURLDataObject, 0, 0, 0},{0, 0, 0, 0}};
37868 static swig_cast_info _swigc__p_wxVideoMode[] = { {&_swigt__p_wxVideoMode, 0, 0, 0},{0, 0, 0, 0}};
37869 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}};
37870 static swig_cast_info _swigc__p_wxWindowDisabler[] = { {&_swigt__p_wxWindowDisabler, 0, 0, 0},{0, 0, 0, 0}};
37871
37872 static swig_cast_info *swig_cast_initial[] = {
37873 _swigc__p_char,
37874 _swigc__p_form_ops_t,
37875 _swigc__p_int,
37876 _swigc__p_unsigned_char,
37877 _swigc__p_unsigned_int,
37878 _swigc__p_unsigned_long,
37879 _swigc__p_void,
37880 _swigc__p_wxANIHandler,
37881 _swigc__p_wxAcceleratorTable,
37882 _swigc__p_wxActivateEvent,
37883 _swigc__p_wxArrayString,
37884 _swigc__p_wxBMPHandler,
37885 _swigc__p_wxBitmap,
37886 _swigc__p_wxBitmapDataObject,
37887 _swigc__p_wxBoxSizer,
37888 _swigc__p_wxBusyCursor,
37889 _swigc__p_wxBusyInfo,
37890 _swigc__p_wxCURHandler,
37891 _swigc__p_wxCaret,
37892 _swigc__p_wxChar,
37893 _swigc__p_wxChildFocusEvent,
37894 _swigc__p_wxClipboard,
37895 _swigc__p_wxClipboardLocker,
37896 _swigc__p_wxCloseEvent,
37897 _swigc__p_wxColour,
37898 _swigc__p_wxCommandEvent,
37899 _swigc__p_wxConfig,
37900 _swigc__p_wxConfigBase,
37901 _swigc__p_wxConfigPathChanger,
37902 _swigc__p_wxContextMenuEvent,
37903 _swigc__p_wxControl,
37904 _swigc__p_wxControlWithItems,
37905 _swigc__p_wxCursor,
37906 _swigc__p_wxCustomDataObject,
37907 _swigc__p_wxDC,
37908 _swigc__p_wxDataFormat,
37909 _swigc__p_wxDataObject,
37910 _swigc__p_wxDataObjectComposite,
37911 _swigc__p_wxDataObjectSimple,
37912 _swigc__p_wxDateEvent,
37913 _swigc__p_wxDateSpan,
37914 _swigc__p_wxDateTime,
37915 _swigc__p_wxDateTime__TimeZone,
37916 _swigc__p_wxDisplay,
37917 _swigc__p_wxDisplayChangedEvent,
37918 _swigc__p_wxDropFilesEvent,
37919 _swigc__p_wxDuplexMode,
37920 _swigc__p_wxEraseEvent,
37921 _swigc__p_wxEvent,
37922 _swigc__p_wxEvtHandler,
37923 _swigc__p_wxFSFile,
37924 _swigc__p_wxFileConfig,
37925 _swigc__p_wxFileDataObject,
37926 _swigc__p_wxFileHistory,
37927 _swigc__p_wxFileSystem,
37928 _swigc__p_wxFileType,
37929 _swigc__p_wxFileTypeInfo,
37930 _swigc__p_wxFlexGridSizer,
37931 _swigc__p_wxFocusEvent,
37932 _swigc__p_wxFont,
37933 _swigc__p_wxFrame,
37934 _swigc__p_wxGBSizerItem,
37935 _swigc__p_wxGIFHandler,
37936 _swigc__p_wxGridBagSizer,
37937 _swigc__p_wxGridSizer,
37938 _swigc__p_wxICOHandler,
37939 _swigc__p_wxIcon,
37940 _swigc__p_wxIconizeEvent,
37941 _swigc__p_wxIdleEvent,
37942 _swigc__p_wxImage,
37943 _swigc__p_wxImageHandler,
37944 _swigc__p_wxIndividualLayoutConstraint,
37945 _swigc__p_wxInitDialogEvent,
37946 _swigc__p_wxJPEGHandler,
37947 _swigc__p_wxJoystick,
37948 _swigc__p_wxJoystickEvent,
37949 _swigc__p_wxKeyEvent,
37950 _swigc__p_wxKillError,
37951 _swigc__p_wxLayoutConstraints,
37952 _swigc__p_wxLog,
37953 _swigc__p_wxLogBuffer,
37954 _swigc__p_wxLogChain,
37955 _swigc__p_wxLogGui,
37956 _swigc__p_wxLogNull,
37957 _swigc__p_wxLogStderr,
37958 _swigc__p_wxLogTextCtrl,
37959 _swigc__p_wxLogWindow,
37960 _swigc__p_wxMaximizeEvent,
37961 _swigc__p_wxMemorySize,
37962 _swigc__p_wxMenu,
37963 _swigc__p_wxMenuBar,
37964 _swigc__p_wxMenuEvent,
37965 _swigc__p_wxMenuItem,
37966 _swigc__p_wxMetafileDataObject,
37967 _swigc__p_wxMimeTypesManager,
37968 _swigc__p_wxMouseCaptureChangedEvent,
37969 _swigc__p_wxMouseEvent,
37970 _swigc__p_wxMouseState,
37971 _swigc__p_wxMoveEvent,
37972 _swigc__p_wxMutexGuiLocker,
37973 _swigc__p_wxNavigationKeyEvent,
37974 _swigc__p_wxNcPaintEvent,
37975 _swigc__p_wxNotifyEvent,
37976 _swigc__p_wxObject,
37977 _swigc__p_wxOutputStream,
37978 _swigc__p_wxPCXHandler,
37979 _swigc__p_wxPNGHandler,
37980 _swigc__p_wxPNMHandler,
37981 _swigc__p_wxPaintEvent,
37982 _swigc__p_wxPaletteChangedEvent,
37983 _swigc__p_wxPaperSize,
37984 _swigc__p_wxPoint,
37985 _swigc__p_wxProcessEvent,
37986 _swigc__p_wxPyApp,
37987 _swigc__p_wxPyArtProvider,
37988 _swigc__p_wxPyBitmapDataObject,
37989 _swigc__p_wxPyCommandEvent,
37990 _swigc__p_wxPyDataObjectSimple,
37991 _swigc__p_wxPyDropSource,
37992 _swigc__p_wxPyDropTarget,
37993 _swigc__p_wxPyEvent,
37994 _swigc__p_wxPyFileDropTarget,
37995 _swigc__p_wxPyImageHandler,
37996 _swigc__p_wxPyLog,
37997 _swigc__p_wxPyProcess,
37998 _swigc__p_wxPySizer,
37999 _swigc__p_wxPyTextDataObject,
38000 _swigc__p_wxPyTextDropTarget,
38001 _swigc__p_wxPyTimer,
38002 _swigc__p_wxPyTipProvider,
38003 _swigc__p_wxPyValidator,
38004 _swigc__p_wxQueryNewPaletteEvent,
38005 _swigc__p_wxRect,
38006 _swigc__p_wxScrollEvent,
38007 _swigc__p_wxScrollWinEvent,
38008 _swigc__p_wxSetCursorEvent,
38009 _swigc__p_wxShowEvent,
38010 _swigc__p_wxSingleInstanceChecker,
38011 _swigc__p_wxSize,
38012 _swigc__p_wxSizeEvent,
38013 _swigc__p_wxSizer,
38014 _swigc__p_wxSizerItem,
38015 _swigc__p_wxSound,
38016 _swigc__p_wxStandardPaths,
38017 _swigc__p_wxStaticBoxSizer,
38018 _swigc__p_wxStdDialogButtonSizer,
38019 _swigc__p_wxStopWatch,
38020 _swigc__p_wxString,
38021 _swigc__p_wxSysColourChangedEvent,
38022 _swigc__p_wxSystemOptions,
38023 _swigc__p_wxSystemSettings,
38024 _swigc__p_wxTIFFHandler,
38025 _swigc__p_wxTextCtrl,
38026 _swigc__p_wxTextDataObject,
38027 _swigc__p_wxTimeSpan,
38028 _swigc__p_wxTimer,
38029 _swigc__p_wxTimerEvent,
38030 _swigc__p_wxTimerRunner,
38031 _swigc__p_wxTipProvider,
38032 _swigc__p_wxToolTip,
38033 _swigc__p_wxURLDataObject,
38034 _swigc__p_wxUpdateUIEvent,
38035 _swigc__p_wxValidator,
38036 _swigc__p_wxVideoMode,
38037 _swigc__p_wxWindow,
38038 _swigc__p_wxWindowCreateEvent,
38039 _swigc__p_wxWindowDestroyEvent,
38040 _swigc__p_wxWindowDisabler,
38041 _swigc__p_wxXPMHandler,
38042 };
38043
38044
38045 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
38046
38047 static swig_const_info swig_const_table[] = {
38048 {0, 0, 0, 0.0, 0, 0}};
38049
38050 #ifdef __cplusplus
38051 }
38052 #endif
38053 /* -----------------------------------------------------------------------------
38054 * Type initialization:
38055 * This problem is tough by the requirement that no dynamic
38056 * memory is used. Also, since swig_type_info structures store pointers to
38057 * swig_cast_info structures and swig_cast_info structures store pointers back
38058 * to swig_type_info structures, we need some lookup code at initialization.
38059 * The idea is that swig generates all the structures that are needed.
38060 * The runtime then collects these partially filled structures.
38061 * The SWIG_InitializeModule function takes these initial arrays out of
38062 * swig_module, and does all the lookup, filling in the swig_module.types
38063 * array with the correct data and linking the correct swig_cast_info
38064 * structures together.
38065 *
38066 * The generated swig_type_info structures are assigned staticly to an initial
38067 * array. We just loop though that array, and handle each type individually.
38068 * First we lookup if this type has been already loaded, and if so, use the
38069 * loaded structure instead of the generated one. Then we have to fill in the
38070 * cast linked list. The cast data is initially stored in something like a
38071 * two-dimensional array. Each row corresponds to a type (there are the same
38072 * number of rows as there are in the swig_type_initial array). Each entry in
38073 * a column is one of the swig_cast_info structures for that type.
38074 * The cast_initial array is actually an array of arrays, because each row has
38075 * a variable number of columns. So to actually build the cast linked list,
38076 * we find the array of casts associated with the type, and loop through it
38077 * adding the casts to the list. The one last trick we need to do is making
38078 * sure the type pointer in the swig_cast_info struct is correct.
38079 *
38080 * First off, we lookup the cast->type name to see if it is already loaded.
38081 * There are three cases to handle:
38082 * 1) If the cast->type has already been loaded AND the type we are adding
38083 * casting info to has not been loaded (it is in this module), THEN we
38084 * replace the cast->type pointer with the type pointer that has already
38085 * been loaded.
38086 * 2) If BOTH types (the one we are adding casting info to, and the
38087 * cast->type) are loaded, THEN the cast info has already been loaded by
38088 * the previous module so we just ignore it.
38089 * 3) Finally, if cast->type has not already been loaded, then we add that
38090 * swig_cast_info to the linked list (because the cast->type) pointer will
38091 * be correct.
38092 * ----------------------------------------------------------------------------- */
38093
38094 #ifdef __cplusplus
38095 extern "C" {
38096 #if 0
38097 } /* c-mode */
38098 #endif
38099 #endif
38100
38101 #if 0
38102 #define SWIGRUNTIME_DEBUG
38103 #endif
38104
38105 SWIGRUNTIME void
38106 SWIG_InitializeModule(void *clientdata) {
38107 size_t i;
38108 swig_module_info *module_head;
38109 static int init_run = 0;
38110
38111 clientdata = clientdata;
38112
38113 if (init_run) return;
38114 init_run = 1;
38115
38116 /* Initialize the swig_module */
38117 swig_module.type_initial = swig_type_initial;
38118 swig_module.cast_initial = swig_cast_initial;
38119
38120 /* Try and load any already created modules */
38121 module_head = SWIG_GetModule(clientdata);
38122 if (module_head) {
38123 swig_module.next = module_head->next;
38124 module_head->next = &swig_module;
38125 } else {
38126 /* This is the first module loaded */
38127 swig_module.next = &swig_module;
38128 SWIG_SetModule(clientdata, &swig_module);
38129 }
38130
38131 /* Now work on filling in swig_module.types */
38132 #ifdef SWIGRUNTIME_DEBUG
38133 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
38134 #endif
38135 for (i = 0; i < swig_module.size; ++i) {
38136 swig_type_info *type = 0;
38137 swig_type_info *ret;
38138 swig_cast_info *cast;
38139
38140 #ifdef SWIGRUNTIME_DEBUG
38141 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
38142 #endif
38143
38144 /* if there is another module already loaded */
38145 if (swig_module.next != &swig_module) {
38146 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
38147 }
38148 if (type) {
38149 /* Overwrite clientdata field */
38150 #ifdef SWIGRUNTIME_DEBUG
38151 printf("SWIG_InitializeModule: found type %s\n", type->name);
38152 #endif
38153 if (swig_module.type_initial[i]->clientdata) {
38154 type->clientdata = swig_module.type_initial[i]->clientdata;
38155 #ifdef SWIGRUNTIME_DEBUG
38156 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
38157 #endif
38158 }
38159 } else {
38160 type = swig_module.type_initial[i];
38161 }
38162
38163 /* Insert casting types */
38164 cast = swig_module.cast_initial[i];
38165 while (cast->type) {
38166 /* Don't need to add information already in the list */
38167 ret = 0;
38168 #ifdef SWIGRUNTIME_DEBUG
38169 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
38170 #endif
38171 if (swig_module.next != &swig_module) {
38172 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
38173 #ifdef SWIGRUNTIME_DEBUG
38174 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
38175 #endif
38176 }
38177 if (ret) {
38178 if (type == swig_module.type_initial[i]) {
38179 #ifdef SWIGRUNTIME_DEBUG
38180 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
38181 #endif
38182 cast->type = ret;
38183 ret = 0;
38184 } else {
38185 /* Check for casting already in the list */
38186 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
38187 #ifdef SWIGRUNTIME_DEBUG
38188 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
38189 #endif
38190 if (!ocast) ret = 0;
38191 }
38192 }
38193
38194 if (!ret) {
38195 #ifdef SWIGRUNTIME_DEBUG
38196 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
38197 #endif
38198 if (type->cast) {
38199 type->cast->prev = cast;
38200 cast->next = type->cast;
38201 }
38202 type->cast = cast;
38203 }
38204 cast++;
38205 }
38206 /* Set entry in modules->types array equal to the type */
38207 swig_module.types[i] = type;
38208 }
38209 swig_module.types[i] = 0;
38210
38211 #ifdef SWIGRUNTIME_DEBUG
38212 printf("**** SWIG_InitializeModule: Cast List ******\n");
38213 for (i = 0; i < swig_module.size; ++i) {
38214 int j = 0;
38215 swig_cast_info *cast = swig_module.cast_initial[i];
38216 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
38217 while (cast->type) {
38218 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
38219 cast++;
38220 ++j;
38221 }
38222 printf("---- Total casts: %d\n",j);
38223 }
38224 printf("**** SWIG_InitializeModule: Cast List ******\n");
38225 #endif
38226 }
38227
38228 /* This function will propagate the clientdata field of type to
38229 * any new swig_type_info structures that have been added into the list
38230 * of equivalent types. It is like calling
38231 * SWIG_TypeClientData(type, clientdata) a second time.
38232 */
38233 SWIGRUNTIME void
38234 SWIG_PropagateClientData(void) {
38235 size_t i;
38236 swig_cast_info *equiv;
38237 static int init_run = 0;
38238
38239 if (init_run) return;
38240 init_run = 1;
38241
38242 for (i = 0; i < swig_module.size; i++) {
38243 if (swig_module.types[i]->clientdata) {
38244 equiv = swig_module.types[i]->cast;
38245 while (equiv) {
38246 if (!equiv->converter) {
38247 if (equiv->type && !equiv->type->clientdata)
38248 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
38249 }
38250 equiv = equiv->next;
38251 }
38252 }
38253 }
38254 }
38255
38256 #ifdef __cplusplus
38257 #if 0
38258 {
38259 /* c-mode */
38260 #endif
38261 }
38262 #endif
38263
38264
38265
38266 #ifdef __cplusplus
38267 extern "C" {
38268 #endif
38269
38270 /* Python-specific SWIG API */
38271 #define SWIG_newvarlink() SWIG_Python_newvarlink()
38272 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
38273 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
38274
38275 /* -----------------------------------------------------------------------------
38276 * global variable support code.
38277 * ----------------------------------------------------------------------------- */
38278
38279 typedef struct swig_globalvar {
38280 char *name; /* Name of global variable */
38281 PyObject *(*get_attr)(void); /* Return the current value */
38282 int (*set_attr)(PyObject *); /* Set the value */
38283 struct swig_globalvar *next;
38284 } swig_globalvar;
38285
38286 typedef struct swig_varlinkobject {
38287 PyObject_HEAD
38288 swig_globalvar *vars;
38289 } swig_varlinkobject;
38290
38291 SWIGINTERN PyObject *
38292 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
38293 return PyString_FromString("<Swig global variables>");
38294 }
38295
38296 SWIGINTERN PyObject *
38297 swig_varlink_str(swig_varlinkobject *v) {
38298 PyObject *str = PyString_FromString("(");
38299 swig_globalvar *var;
38300 for (var = v->vars; var; var=var->next) {
38301 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
38302 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
38303 }
38304 PyString_ConcatAndDel(&str,PyString_FromString(")"));
38305 return str;
38306 }
38307
38308 SWIGINTERN int
38309 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
38310 PyObject *str = swig_varlink_str(v);
38311 fprintf(fp,"Swig global variables ");
38312 fprintf(fp,"%s\n", PyString_AsString(str));
38313 Py_DECREF(str);
38314 return 0;
38315 }
38316
38317 SWIGINTERN void
38318 swig_varlink_dealloc(swig_varlinkobject *v) {
38319 swig_globalvar *var = v->vars;
38320 while (var) {
38321 swig_globalvar *n = var->next;
38322 free(var->name);
38323 free(var);
38324 var = n;
38325 }
38326 }
38327
38328 SWIGINTERN PyObject *
38329 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
38330 PyObject *res = NULL;
38331 swig_globalvar *var = v->vars;
38332 while (var) {
38333 if (strcmp(var->name,n) == 0) {
38334 res = (*var->get_attr)();
38335 break;
38336 }
38337 var = var->next;
38338 }
38339 if (res == NULL && !PyErr_Occurred()) {
38340 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
38341 }
38342 return res;
38343 }
38344
38345 SWIGINTERN int
38346 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
38347 int res = 1;
38348 swig_globalvar *var = v->vars;
38349 while (var) {
38350 if (strcmp(var->name,n) == 0) {
38351 res = (*var->set_attr)(p);
38352 break;
38353 }
38354 var = var->next;
38355 }
38356 if (res == 1 && !PyErr_Occurred()) {
38357 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
38358 }
38359 return res;
38360 }
38361
38362 SWIGINTERN PyTypeObject*
38363 swig_varlink_type(void) {
38364 static char varlink__doc__[] = "Swig var link object";
38365 static PyTypeObject varlink_type;
38366 static int type_init = 0;
38367 if (!type_init) {
38368 const PyTypeObject tmp
38369 = {
38370 PyObject_HEAD_INIT(NULL)
38371 0, /* Number of items in variable part (ob_size) */
38372 (char *)"swigvarlink", /* Type name (tp_name) */
38373 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
38374 0, /* Itemsize (tp_itemsize) */
38375 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
38376 (printfunc) swig_varlink_print, /* Print (tp_print) */
38377 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
38378 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
38379 0, /* tp_compare */
38380 (reprfunc) swig_varlink_repr, /* tp_repr */
38381 0, /* tp_as_number */
38382 0, /* tp_as_sequence */
38383 0, /* tp_as_mapping */
38384 0, /* tp_hash */
38385 0, /* tp_call */
38386 (reprfunc)swig_varlink_str, /* tp_str */
38387 0, /* tp_getattro */
38388 0, /* tp_setattro */
38389 0, /* tp_as_buffer */
38390 0, /* tp_flags */
38391 varlink__doc__, /* tp_doc */
38392 0, /* tp_traverse */
38393 0, /* tp_clear */
38394 0, /* tp_richcompare */
38395 0, /* tp_weaklistoffset */
38396 #if PY_VERSION_HEX >= 0x02020000
38397 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
38398 #endif
38399 #if PY_VERSION_HEX >= 0x02030000
38400 0, /* tp_del */
38401 #endif
38402 #ifdef COUNT_ALLOCS
38403 0,0,0,0 /* tp_alloc -> tp_next */
38404 #endif
38405 };
38406 varlink_type = tmp;
38407 varlink_type.ob_type = &PyType_Type;
38408 type_init = 1;
38409 }
38410 return &varlink_type;
38411 }
38412
38413 /* Create a variable linking object for use later */
38414 SWIGINTERN PyObject *
38415 SWIG_Python_newvarlink(void) {
38416 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
38417 if (result) {
38418 result->vars = 0;
38419 }
38420 return ((PyObject*) result);
38421 }
38422
38423 SWIGINTERN void
38424 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
38425 swig_varlinkobject *v = (swig_varlinkobject *) p;
38426 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
38427 if (gv) {
38428 size_t size = strlen(name)+1;
38429 gv->name = (char *)malloc(size);
38430 if (gv->name) {
38431 strncpy(gv->name,name,size);
38432 gv->get_attr = get_attr;
38433 gv->set_attr = set_attr;
38434 gv->next = v->vars;
38435 }
38436 }
38437 v->vars = gv;
38438 }
38439
38440 SWIGINTERN PyObject *
38441 SWIG_globals() {
38442 static PyObject *_SWIG_globals = 0;
38443 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
38444 return _SWIG_globals;
38445 }
38446
38447 /* -----------------------------------------------------------------------------
38448 * constants/methods manipulation
38449 * ----------------------------------------------------------------------------- */
38450
38451 /* Install Constants */
38452 SWIGINTERN void
38453 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
38454 PyObject *obj = 0;
38455 size_t i;
38456 for (i = 0; constants[i].type; ++i) {
38457 switch(constants[i].type) {
38458 case SWIG_PY_POINTER:
38459 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
38460 break;
38461 case SWIG_PY_BINARY:
38462 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
38463 break;
38464 default:
38465 obj = 0;
38466 break;
38467 }
38468 if (obj) {
38469 PyDict_SetItemString(d, constants[i].name, obj);
38470 Py_DECREF(obj);
38471 }
38472 }
38473 }
38474
38475 /* -----------------------------------------------------------------------------*/
38476 /* Fix SwigMethods to carry the callback ptrs when needed */
38477 /* -----------------------------------------------------------------------------*/
38478
38479 SWIGINTERN void
38480 SWIG_Python_FixMethods(PyMethodDef *methods,
38481 swig_const_info *const_table,
38482 swig_type_info **types,
38483 swig_type_info **types_initial) {
38484 size_t i;
38485 for (i = 0; methods[i].ml_name; ++i) {
38486 char *c = methods[i].ml_doc;
38487 if (c && (c = strstr(c, "swig_ptr: "))) {
38488 int j;
38489 swig_const_info *ci = 0;
38490 char *name = c + 10;
38491 for (j = 0; const_table[j].type; ++j) {
38492 if (strncmp(const_table[j].name, name,
38493 strlen(const_table[j].name)) == 0) {
38494 ci = &(const_table[j]);
38495 break;
38496 }
38497 }
38498 if (ci) {
38499 size_t shift = (ci->ptype) - types;
38500 swig_type_info *ty = types_initial[shift];
38501 size_t ldoc = (c - methods[i].ml_doc);
38502 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
38503 char *ndoc = (char*)malloc(ldoc + lptr + 10);
38504 if (ndoc) {
38505 char *buff = ndoc;
38506 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
38507 if (ptr) {
38508 strncpy(buff, methods[i].ml_doc, ldoc);
38509 buff += ldoc;
38510 strncpy(buff, "swig_ptr: ", 10);
38511 buff += 10;
38512 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
38513 methods[i].ml_doc = ndoc;
38514 }
38515 }
38516 }
38517 }
38518 }
38519 }
38520
38521 #ifdef __cplusplus
38522 }
38523 #endif
38524
38525 /* -----------------------------------------------------------------------------*
38526 * Partial Init method
38527 * -----------------------------------------------------------------------------*/
38528
38529 #ifdef __cplusplus
38530 extern "C"
38531 #endif
38532 SWIGEXPORT void SWIG_init(void) {
38533 PyObject *m, *d;
38534
38535 /* Fix SwigMethods to carry the callback ptrs when needed */
38536 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
38537
38538 m = Py_InitModule((char *) SWIG_name, SwigMethods);
38539 d = PyModule_GetDict(m);
38540
38541 SWIG_InitializeModule(0);
38542 SWIG_InstallConstants(d,swig_const_table);
38543
38544
38545 SWIG_Python_SetConstant(d, "SYS_OEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_OEM_FIXED_FONT)));
38546 SWIG_Python_SetConstant(d, "SYS_ANSI_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_FIXED_FONT)));
38547 SWIG_Python_SetConstant(d, "SYS_ANSI_VAR_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_VAR_FONT)));
38548 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FONT)));
38549 SWIG_Python_SetConstant(d, "SYS_DEVICE_DEFAULT_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEVICE_DEFAULT_FONT)));
38550 SWIG_Python_SetConstant(d, "SYS_DEFAULT_PALETTE",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_PALETTE)));
38551 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FIXED_FONT)));
38552 SWIG_Python_SetConstant(d, "SYS_DEFAULT_GUI_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_GUI_FONT)));
38553 SWIG_Python_SetConstant(d, "SYS_ICONTITLE_FONT",SWIG_From_int(static_cast< int >(wxSYS_ICONTITLE_FONT)));
38554 SWIG_Python_SetConstant(d, "SYS_COLOUR_SCROLLBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_SCROLLBAR)));
38555 SWIG_Python_SetConstant(d, "SYS_COLOUR_BACKGROUND",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BACKGROUND)));
38556 SWIG_Python_SetConstant(d, "SYS_COLOUR_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_DESKTOP)));
38557 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVECAPTION)));
38558 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTION)));
38559 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENU",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENU)));
38560 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOW)));
38561 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWFRAME",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWFRAME)));
38562 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUTEXT)));
38563 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWTEXT)));
38564 SWIG_Python_SetConstant(d, "SYS_COLOUR_CAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_CAPTIONTEXT)));
38565 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVEBORDER)));
38566 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVEBORDER)));
38567 SWIG_Python_SetConstant(d, "SYS_COLOUR_APPWORKSPACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_APPWORKSPACE)));
38568 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHT)));
38569 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHTTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHTTEXT)));
38570 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNFACE)));
38571 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DFACE)));
38572 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNSHADOW)));
38573 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DSHADOW)));
38574 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRAYTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRAYTEXT)));
38575 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNTEXT)));
38576 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
38577 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHIGHLIGHT)));
38578 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHILIGHT)));
38579 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHIGHLIGHT)));
38580 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHILIGHT)));
38581 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DDKSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DDKSHADOW)));
38582 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DLIGHT)));
38583 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOTEXT)));
38584 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOBK",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOBK)));
38585 SWIG_Python_SetConstant(d, "SYS_COLOUR_LISTBOX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_LISTBOX)));
38586 SWIG_Python_SetConstant(d, "SYS_COLOUR_HOTLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HOTLIGHT)));
38587 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
38588 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTINACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
38589 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUHILIGHT)));
38590 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUBAR)));
38591 SWIG_Python_SetConstant(d, "SYS_COLOUR_MAX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MAX)));
38592 SWIG_Python_SetConstant(d, "SYS_MOUSE_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_MOUSE_BUTTONS)));
38593 SWIG_Python_SetConstant(d, "SYS_BORDER_X",SWIG_From_int(static_cast< int >(wxSYS_BORDER_X)));
38594 SWIG_Python_SetConstant(d, "SYS_BORDER_Y",SWIG_From_int(static_cast< int >(wxSYS_BORDER_Y)));
38595 SWIG_Python_SetConstant(d, "SYS_CURSOR_X",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_X)));
38596 SWIG_Python_SetConstant(d, "SYS_CURSOR_Y",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_Y)));
38597 SWIG_Python_SetConstant(d, "SYS_DCLICK_X",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_X)));
38598 SWIG_Python_SetConstant(d, "SYS_DCLICK_Y",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_Y)));
38599 SWIG_Python_SetConstant(d, "SYS_DRAG_X",SWIG_From_int(static_cast< int >(wxSYS_DRAG_X)));
38600 SWIG_Python_SetConstant(d, "SYS_DRAG_Y",SWIG_From_int(static_cast< int >(wxSYS_DRAG_Y)));
38601 SWIG_Python_SetConstant(d, "SYS_EDGE_X",SWIG_From_int(static_cast< int >(wxSYS_EDGE_X)));
38602 SWIG_Python_SetConstant(d, "SYS_EDGE_Y",SWIG_From_int(static_cast< int >(wxSYS_EDGE_Y)));
38603 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_X)));
38604 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_Y)));
38605 SWIG_Python_SetConstant(d, "SYS_HTHUMB_X",SWIG_From_int(static_cast< int >(wxSYS_HTHUMB_X)));
38606 SWIG_Python_SetConstant(d, "SYS_ICON_X",SWIG_From_int(static_cast< int >(wxSYS_ICON_X)));
38607 SWIG_Python_SetConstant(d, "SYS_ICON_Y",SWIG_From_int(static_cast< int >(wxSYS_ICON_Y)));
38608 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_X",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_X)));
38609 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_Y",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_Y)));
38610 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_X",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_X)));
38611 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_Y",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_Y)));
38612 SWIG_Python_SetConstant(d, "SYS_SCREEN_X",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_X)));
38613 SWIG_Python_SetConstant(d, "SYS_SCREEN_Y",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_Y)));
38614 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_X",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_X)));
38615 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_Y",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_Y)));
38616 SWIG_Python_SetConstant(d, "SYS_SMALLICON_X",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_X)));
38617 SWIG_Python_SetConstant(d, "SYS_SMALLICON_Y",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_Y)));
38618 SWIG_Python_SetConstant(d, "SYS_HSCROLL_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_Y)));
38619 SWIG_Python_SetConstant(d, "SYS_VSCROLL_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_X)));
38620 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_X)));
38621 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_Y)));
38622 SWIG_Python_SetConstant(d, "SYS_VTHUMB_Y",SWIG_From_int(static_cast< int >(wxSYS_VTHUMB_Y)));
38623 SWIG_Python_SetConstant(d, "SYS_CAPTION_Y",SWIG_From_int(static_cast< int >(wxSYS_CAPTION_Y)));
38624 SWIG_Python_SetConstant(d, "SYS_MENU_Y",SWIG_From_int(static_cast< int >(wxSYS_MENU_Y)));
38625 SWIG_Python_SetConstant(d, "SYS_NETWORK_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_NETWORK_PRESENT)));
38626 SWIG_Python_SetConstant(d, "SYS_PENWINDOWS_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_PENWINDOWS_PRESENT)));
38627 SWIG_Python_SetConstant(d, "SYS_SHOW_SOUNDS",SWIG_From_int(static_cast< int >(wxSYS_SHOW_SOUNDS)));
38628 SWIG_Python_SetConstant(d, "SYS_SWAP_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_SWAP_BUTTONS)));
38629 SWIG_Python_SetConstant(d, "SYS_CAN_DRAW_FRAME_DECORATIONS",SWIG_From_int(static_cast< int >(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
38630 SWIG_Python_SetConstant(d, "SYS_CAN_ICONIZE_FRAME",SWIG_From_int(static_cast< int >(wxSYS_CAN_ICONIZE_FRAME)));
38631 SWIG_Python_SetConstant(d, "SYS_TABLET_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_TABLET_PRESENT)));
38632 SWIG_Python_SetConstant(d, "SYS_SCREEN_NONE",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_NONE)));
38633 SWIG_Python_SetConstant(d, "SYS_SCREEN_TINY",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_TINY)));
38634 SWIG_Python_SetConstant(d, "SYS_SCREEN_PDA",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_PDA)));
38635 SWIG_Python_SetConstant(d, "SYS_SCREEN_SMALL",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_SMALL)));
38636 SWIG_Python_SetConstant(d, "SYS_SCREEN_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_DESKTOP)));
38637 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
38638 SWIG_addvarlink(SWIG_globals(),(char*)"WINDOW_DEFAULT_VARIANT",WINDOW_DEFAULT_VARIANT_get, WINDOW_DEFAULT_VARIANT_set);
38639 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorPromptStr",FileSelectorPromptStr_get, FileSelectorPromptStr_set);
38640 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorDefaultWildcardStr",FileSelectorDefaultWildcardStr_get, FileSelectorDefaultWildcardStr_set);
38641 SWIG_addvarlink(SWIG_globals(),(char*)"DirSelectorPromptStr",DirSelectorPromptStr_get, DirSelectorPromptStr_set);
38642 SWIG_Python_SetConstant(d, "SHUTDOWN_POWEROFF",SWIG_From_int(static_cast< int >(wxSHUTDOWN_POWEROFF)));
38643 SWIG_Python_SetConstant(d, "SHUTDOWN_REBOOT",SWIG_From_int(static_cast< int >(wxSHUTDOWN_REBOOT)));
38644 SWIG_Python_SetConstant(d, "TIMER_CONTINUOUS",SWIG_From_int(static_cast< int >(wxTIMER_CONTINUOUS)));
38645 SWIG_Python_SetConstant(d, "TIMER_ONE_SHOT",SWIG_From_int(static_cast< int >(wxTIMER_ONE_SHOT)));
38646 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
38647
38648 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
38649
38650 SWIG_Python_SetConstant(d, "LOG_FatalError",SWIG_From_int(static_cast< int >(wxLOG_FatalError)));
38651 SWIG_Python_SetConstant(d, "LOG_Error",SWIG_From_int(static_cast< int >(wxLOG_Error)));
38652 SWIG_Python_SetConstant(d, "LOG_Warning",SWIG_From_int(static_cast< int >(wxLOG_Warning)));
38653 SWIG_Python_SetConstant(d, "LOG_Message",SWIG_From_int(static_cast< int >(wxLOG_Message)));
38654 SWIG_Python_SetConstant(d, "LOG_Status",SWIG_From_int(static_cast< int >(wxLOG_Status)));
38655 SWIG_Python_SetConstant(d, "LOG_Info",SWIG_From_int(static_cast< int >(wxLOG_Info)));
38656 SWIG_Python_SetConstant(d, "LOG_Debug",SWIG_From_int(static_cast< int >(wxLOG_Debug)));
38657 SWIG_Python_SetConstant(d, "LOG_Trace",SWIG_From_int(static_cast< int >(wxLOG_Trace)));
38658 SWIG_Python_SetConstant(d, "LOG_Progress",SWIG_From_int(static_cast< int >(wxLOG_Progress)));
38659 SWIG_Python_SetConstant(d, "LOG_User",SWIG_From_int(static_cast< int >(wxLOG_User)));
38660 SWIG_Python_SetConstant(d, "LOG_Max",SWIG_From_int(static_cast< int >(wxLOG_Max)));
38661 SWIG_Python_SetConstant(d, "TRACE_MemAlloc",SWIG_FromCharPtr("memalloc"));
38662 SWIG_Python_SetConstant(d, "TRACE_Messages",SWIG_FromCharPtr("messages"));
38663 SWIG_Python_SetConstant(d, "TRACE_ResAlloc",SWIG_FromCharPtr("resalloc"));
38664 SWIG_Python_SetConstant(d, "TRACE_RefCount",SWIG_FromCharPtr("refcount"));
38665 SWIG_Python_SetConstant(d, "TRACE_OleCalls",SWIG_FromCharPtr("ole"));
38666 SWIG_Python_SetConstant(d, "TraceMemAlloc",SWIG_From_int(static_cast< int >(0x0001)));
38667 SWIG_Python_SetConstant(d, "TraceMessages",SWIG_From_int(static_cast< int >(0x0002)));
38668 SWIG_Python_SetConstant(d, "TraceResAlloc",SWIG_From_int(static_cast< int >(0x0004)));
38669 SWIG_Python_SetConstant(d, "TraceRefCount",SWIG_From_int(static_cast< int >(0x0008)));
38670 SWIG_Python_SetConstant(d, "TraceOleCalls",SWIG_From_int(static_cast< int >(0x0100)));
38671 SWIG_Python_SetConstant(d, "PROCESS_DEFAULT",SWIG_From_int(static_cast< int >(wxPROCESS_DEFAULT)));
38672 SWIG_Python_SetConstant(d, "PROCESS_REDIRECT",SWIG_From_int(static_cast< int >(wxPROCESS_REDIRECT)));
38673 SWIG_Python_SetConstant(d, "KILL_OK",SWIG_From_int(static_cast< int >(wxKILL_OK)));
38674 SWIG_Python_SetConstant(d, "KILL_BAD_SIGNAL",SWIG_From_int(static_cast< int >(wxKILL_BAD_SIGNAL)));
38675 SWIG_Python_SetConstant(d, "KILL_ACCESS_DENIED",SWIG_From_int(static_cast< int >(wxKILL_ACCESS_DENIED)));
38676 SWIG_Python_SetConstant(d, "KILL_NO_PROCESS",SWIG_From_int(static_cast< int >(wxKILL_NO_PROCESS)));
38677 SWIG_Python_SetConstant(d, "KILL_ERROR",SWIG_From_int(static_cast< int >(wxKILL_ERROR)));
38678 SWIG_Python_SetConstant(d, "KILL_NOCHILDREN",SWIG_From_int(static_cast< int >(wxKILL_NOCHILDREN)));
38679 SWIG_Python_SetConstant(d, "KILL_CHILDREN",SWIG_From_int(static_cast< int >(wxKILL_CHILDREN)));
38680 SWIG_Python_SetConstant(d, "SIGNONE",SWIG_From_int(static_cast< int >(wxSIGNONE)));
38681 SWIG_Python_SetConstant(d, "SIGHUP",SWIG_From_int(static_cast< int >(wxSIGHUP)));
38682 SWIG_Python_SetConstant(d, "SIGINT",SWIG_From_int(static_cast< int >(wxSIGINT)));
38683 SWIG_Python_SetConstant(d, "SIGQUIT",SWIG_From_int(static_cast< int >(wxSIGQUIT)));
38684 SWIG_Python_SetConstant(d, "SIGILL",SWIG_From_int(static_cast< int >(wxSIGILL)));
38685 SWIG_Python_SetConstant(d, "SIGTRAP",SWIG_From_int(static_cast< int >(wxSIGTRAP)));
38686 SWIG_Python_SetConstant(d, "SIGABRT",SWIG_From_int(static_cast< int >(wxSIGABRT)));
38687 SWIG_Python_SetConstant(d, "SIGIOT",SWIG_From_int(static_cast< int >(wxSIGIOT)));
38688 SWIG_Python_SetConstant(d, "SIGEMT",SWIG_From_int(static_cast< int >(wxSIGEMT)));
38689 SWIG_Python_SetConstant(d, "SIGFPE",SWIG_From_int(static_cast< int >(wxSIGFPE)));
38690 SWIG_Python_SetConstant(d, "SIGKILL",SWIG_From_int(static_cast< int >(wxSIGKILL)));
38691 SWIG_Python_SetConstant(d, "SIGBUS",SWIG_From_int(static_cast< int >(wxSIGBUS)));
38692 SWIG_Python_SetConstant(d, "SIGSEGV",SWIG_From_int(static_cast< int >(wxSIGSEGV)));
38693 SWIG_Python_SetConstant(d, "SIGSYS",SWIG_From_int(static_cast< int >(wxSIGSYS)));
38694 SWIG_Python_SetConstant(d, "SIGPIPE",SWIG_From_int(static_cast< int >(wxSIGPIPE)));
38695 SWIG_Python_SetConstant(d, "SIGALRM",SWIG_From_int(static_cast< int >(wxSIGALRM)));
38696 SWIG_Python_SetConstant(d, "SIGTERM",SWIG_From_int(static_cast< int >(wxSIGTERM)));
38697 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
38698 SWIG_Python_SetConstant(d, "EXEC_ASYNC",SWIG_From_int(static_cast< int >(wxEXEC_ASYNC)));
38699 SWIG_Python_SetConstant(d, "EXEC_SYNC",SWIG_From_int(static_cast< int >(wxEXEC_SYNC)));
38700 SWIG_Python_SetConstant(d, "EXEC_NOHIDE",SWIG_From_int(static_cast< int >(wxEXEC_NOHIDE)));
38701 SWIG_Python_SetConstant(d, "EXEC_MAKE_GROUP_LEADER",SWIG_From_int(static_cast< int >(wxEXEC_MAKE_GROUP_LEADER)));
38702 SWIG_Python_SetConstant(d, "EXEC_NODISABLE",SWIG_From_int(static_cast< int >(wxEXEC_NODISABLE)));
38703
38704 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
38705
38706 SWIG_Python_SetConstant(d, "JOYSTICK1",SWIG_From_int(static_cast< int >(wxJOYSTICK1)));
38707 SWIG_Python_SetConstant(d, "JOYSTICK2",SWIG_From_int(static_cast< int >(wxJOYSTICK2)));
38708 SWIG_Python_SetConstant(d, "JOY_BUTTON_ANY",SWIG_From_int(static_cast< int >(wxJOY_BUTTON_ANY)));
38709 SWIG_Python_SetConstant(d, "JOY_BUTTON1",SWIG_From_int(static_cast< int >(wxJOY_BUTTON1)));
38710 SWIG_Python_SetConstant(d, "JOY_BUTTON2",SWIG_From_int(static_cast< int >(wxJOY_BUTTON2)));
38711 SWIG_Python_SetConstant(d, "JOY_BUTTON3",SWIG_From_int(static_cast< int >(wxJOY_BUTTON3)));
38712 SWIG_Python_SetConstant(d, "JOY_BUTTON4",SWIG_From_int(static_cast< int >(wxJOY_BUTTON4)));
38713 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
38714 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
38715 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
38716 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
38717 SWIG_Python_SetConstant(d, "SOUND_SYNC",SWIG_From_int(static_cast< int >(wxSOUND_SYNC)));
38718 SWIG_Python_SetConstant(d, "SOUND_ASYNC",SWIG_From_int(static_cast< int >(wxSOUND_ASYNC)));
38719 SWIG_Python_SetConstant(d, "SOUND_LOOP",SWIG_From_int(static_cast< int >(wxSOUND_LOOP)));
38720 SWIG_Python_SetConstant(d, "MAILCAP_STANDARD",SWIG_From_int(static_cast< int >(wxMAILCAP_STANDARD)));
38721 SWIG_Python_SetConstant(d, "MAILCAP_NETSCAPE",SWIG_From_int(static_cast< int >(wxMAILCAP_NETSCAPE)));
38722 SWIG_Python_SetConstant(d, "MAILCAP_KDE",SWIG_From_int(static_cast< int >(wxMAILCAP_KDE)));
38723 SWIG_Python_SetConstant(d, "MAILCAP_GNOME",SWIG_From_int(static_cast< int >(wxMAILCAP_GNOME)));
38724 SWIG_Python_SetConstant(d, "MAILCAP_ALL",SWIG_From_int(static_cast< int >(wxMAILCAP_ALL)));
38725 SWIG_addvarlink(SWIG_globals(),(char*)"TheMimeTypesManager",TheMimeTypesManager_get, TheMimeTypesManager_set);
38726 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TOOLBAR",ART_TOOLBAR_get, ART_TOOLBAR_set);
38727 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MENU",ART_MENU_get, ART_MENU_set);
38728 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FRAME_ICON",ART_FRAME_ICON_get, ART_FRAME_ICON_set);
38729 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CMN_DIALOG",ART_CMN_DIALOG_get, ART_CMN_DIALOG_set);
38730 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BROWSER",ART_HELP_BROWSER_get, ART_HELP_BROWSER_set);
38731 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MESSAGE_BOX",ART_MESSAGE_BOX_get, ART_MESSAGE_BOX_set);
38732 SWIG_addvarlink(SWIG_globals(),(char*)"ART_BUTTON",ART_BUTTON_get, ART_BUTTON_set);
38733 SWIG_addvarlink(SWIG_globals(),(char*)"ART_OTHER",ART_OTHER_get, ART_OTHER_set);
38734 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ADD_BOOKMARK",ART_ADD_BOOKMARK_get, ART_ADD_BOOKMARK_set);
38735 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DEL_BOOKMARK",ART_DEL_BOOKMARK_get, ART_DEL_BOOKMARK_set);
38736 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SIDE_PANEL",ART_HELP_SIDE_PANEL_get, ART_HELP_SIDE_PANEL_set);
38737 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SETTINGS",ART_HELP_SETTINGS_get, ART_HELP_SETTINGS_set);
38738 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BOOK",ART_HELP_BOOK_get, ART_HELP_BOOK_set);
38739 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_FOLDER",ART_HELP_FOLDER_get, ART_HELP_FOLDER_set);
38740 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_PAGE",ART_HELP_PAGE_get, ART_HELP_PAGE_set);
38741 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_BACK",ART_GO_BACK_get, ART_GO_BACK_set);
38742 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_FORWARD",ART_GO_FORWARD_get, ART_GO_FORWARD_set);
38743 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_UP",ART_GO_UP_get, ART_GO_UP_set);
38744 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DOWN",ART_GO_DOWN_get, ART_GO_DOWN_set);
38745 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_TO_PARENT",ART_GO_TO_PARENT_get, ART_GO_TO_PARENT_set);
38746 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_HOME",ART_GO_HOME_get, ART_GO_HOME_set);
38747 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_OPEN",ART_FILE_OPEN_get, ART_FILE_OPEN_set);
38748 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE",ART_FILE_SAVE_get, ART_FILE_SAVE_set);
38749 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE_AS",ART_FILE_SAVE_AS_get, ART_FILE_SAVE_AS_set);
38750 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PRINT",ART_PRINT_get, ART_PRINT_set);
38751 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP",ART_HELP_get, ART_HELP_set);
38752 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TIP",ART_TIP_get, ART_TIP_set);
38753 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REPORT_VIEW",ART_REPORT_VIEW_get, ART_REPORT_VIEW_set);
38754 SWIG_addvarlink(SWIG_globals(),(char*)"ART_LIST_VIEW",ART_LIST_VIEW_get, ART_LIST_VIEW_set);
38755 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW_DIR",ART_NEW_DIR_get, ART_NEW_DIR_set);
38756 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HARDDISK",ART_HARDDISK_get, ART_HARDDISK_set);
38757 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FLOPPY",ART_FLOPPY_get, ART_FLOPPY_set);
38758 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CDROM",ART_CDROM_get, ART_CDROM_set);
38759 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REMOVABLE",ART_REMOVABLE_get, ART_REMOVABLE_set);
38760 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER",ART_FOLDER_get, ART_FOLDER_set);
38761 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER_OPEN",ART_FOLDER_OPEN_get, ART_FOLDER_OPEN_set);
38762 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DIR_UP",ART_GO_DIR_UP_get, ART_GO_DIR_UP_set);
38763 SWIG_addvarlink(SWIG_globals(),(char*)"ART_EXECUTABLE_FILE",ART_EXECUTABLE_FILE_get, ART_EXECUTABLE_FILE_set);
38764 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NORMAL_FILE",ART_NORMAL_FILE_get, ART_NORMAL_FILE_set);
38765 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TICK_MARK",ART_TICK_MARK_get, ART_TICK_MARK_set);
38766 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CROSS_MARK",ART_CROSS_MARK_get, ART_CROSS_MARK_set);
38767 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ERROR",ART_ERROR_get, ART_ERROR_set);
38768 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUESTION",ART_QUESTION_get, ART_QUESTION_set);
38769 SWIG_addvarlink(SWIG_globals(),(char*)"ART_WARNING",ART_WARNING_get, ART_WARNING_set);
38770 SWIG_addvarlink(SWIG_globals(),(char*)"ART_INFORMATION",ART_INFORMATION_get, ART_INFORMATION_set);
38771 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MISSING_IMAGE",ART_MISSING_IMAGE_get, ART_MISSING_IMAGE_set);
38772 SWIG_addvarlink(SWIG_globals(),(char*)"ART_COPY",ART_COPY_get, ART_COPY_set);
38773 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CUT",ART_CUT_get, ART_CUT_set);
38774 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PASTE",ART_PASTE_get, ART_PASTE_set);
38775 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DELETE",ART_DELETE_get, ART_DELETE_set);
38776 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW",ART_NEW_get, ART_NEW_set);
38777 SWIG_addvarlink(SWIG_globals(),(char*)"ART_UNDO",ART_UNDO_get, ART_UNDO_set);
38778 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REDO",ART_REDO_get, ART_REDO_set);
38779 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUIT",ART_QUIT_get, ART_QUIT_set);
38780 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND",ART_FIND_get, ART_FIND_set);
38781 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND_AND_REPLACE",ART_FIND_AND_REPLACE_get, ART_FIND_AND_REPLACE_set);
38782
38783 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
38784
38785 SWIG_Python_SetConstant(d, "CONFIG_USE_LOCAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_LOCAL_FILE)));
38786 SWIG_Python_SetConstant(d, "CONFIG_USE_GLOBAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_GLOBAL_FILE)));
38787 SWIG_Python_SetConstant(d, "CONFIG_USE_RELATIVE_PATH",SWIG_From_int(static_cast< int >(wxCONFIG_USE_RELATIVE_PATH)));
38788 SWIG_Python_SetConstant(d, "CONFIG_USE_NO_ESCAPE_CHARACTERS",SWIG_From_int(static_cast< int >(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
38789 SWIG_Python_SetConstant(d, "ConfigBase_Type_Unknown",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Unknown)));
38790 SWIG_Python_SetConstant(d, "ConfigBase_Type_String",SWIG_From_int(static_cast< int >(wxConfigBase::Type_String)));
38791 SWIG_Python_SetConstant(d, "ConfigBase_Type_Boolean",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Boolean)));
38792 SWIG_Python_SetConstant(d, "ConfigBase_Type_Integer",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Integer)));
38793 SWIG_Python_SetConstant(d, "ConfigBase_Type_Float",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Float)));
38794 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTimeFormat",DefaultDateTimeFormat_get, DefaultDateTimeFormat_set);
38795 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultTimeSpanFormat",DefaultTimeSpanFormat_get, DefaultTimeSpanFormat_set);
38796 SWIG_Python_SetConstant(d, "DateTime_Local",SWIG_From_int(static_cast< int >(wxDateTime::Local)));
38797 SWIG_Python_SetConstant(d, "DateTime_GMT_12",SWIG_From_int(static_cast< int >(wxDateTime::GMT_12)));
38798 SWIG_Python_SetConstant(d, "DateTime_GMT_11",SWIG_From_int(static_cast< int >(wxDateTime::GMT_11)));
38799 SWIG_Python_SetConstant(d, "DateTime_GMT_10",SWIG_From_int(static_cast< int >(wxDateTime::GMT_10)));
38800 SWIG_Python_SetConstant(d, "DateTime_GMT_9",SWIG_From_int(static_cast< int >(wxDateTime::GMT_9)));
38801 SWIG_Python_SetConstant(d, "DateTime_GMT_8",SWIG_From_int(static_cast< int >(wxDateTime::GMT_8)));
38802 SWIG_Python_SetConstant(d, "DateTime_GMT_7",SWIG_From_int(static_cast< int >(wxDateTime::GMT_7)));
38803 SWIG_Python_SetConstant(d, "DateTime_GMT_6",SWIG_From_int(static_cast< int >(wxDateTime::GMT_6)));
38804 SWIG_Python_SetConstant(d, "DateTime_GMT_5",SWIG_From_int(static_cast< int >(wxDateTime::GMT_5)));
38805 SWIG_Python_SetConstant(d, "DateTime_GMT_4",SWIG_From_int(static_cast< int >(wxDateTime::GMT_4)));
38806 SWIG_Python_SetConstant(d, "DateTime_GMT_3",SWIG_From_int(static_cast< int >(wxDateTime::GMT_3)));
38807 SWIG_Python_SetConstant(d, "DateTime_GMT_2",SWIG_From_int(static_cast< int >(wxDateTime::GMT_2)));
38808 SWIG_Python_SetConstant(d, "DateTime_GMT_1",SWIG_From_int(static_cast< int >(wxDateTime::GMT_1)));
38809 SWIG_Python_SetConstant(d, "DateTime_GMT0",SWIG_From_int(static_cast< int >(wxDateTime::GMT0)));
38810 SWIG_Python_SetConstant(d, "DateTime_GMT1",SWIG_From_int(static_cast< int >(wxDateTime::GMT1)));
38811 SWIG_Python_SetConstant(d, "DateTime_GMT2",SWIG_From_int(static_cast< int >(wxDateTime::GMT2)));
38812 SWIG_Python_SetConstant(d, "DateTime_GMT3",SWIG_From_int(static_cast< int >(wxDateTime::GMT3)));
38813 SWIG_Python_SetConstant(d, "DateTime_GMT4",SWIG_From_int(static_cast< int >(wxDateTime::GMT4)));
38814 SWIG_Python_SetConstant(d, "DateTime_GMT5",SWIG_From_int(static_cast< int >(wxDateTime::GMT5)));
38815 SWIG_Python_SetConstant(d, "DateTime_GMT6",SWIG_From_int(static_cast< int >(wxDateTime::GMT6)));
38816 SWIG_Python_SetConstant(d, "DateTime_GMT7",SWIG_From_int(static_cast< int >(wxDateTime::GMT7)));
38817 SWIG_Python_SetConstant(d, "DateTime_GMT8",SWIG_From_int(static_cast< int >(wxDateTime::GMT8)));
38818 SWIG_Python_SetConstant(d, "DateTime_GMT9",SWIG_From_int(static_cast< int >(wxDateTime::GMT9)));
38819 SWIG_Python_SetConstant(d, "DateTime_GMT10",SWIG_From_int(static_cast< int >(wxDateTime::GMT10)));
38820 SWIG_Python_SetConstant(d, "DateTime_GMT11",SWIG_From_int(static_cast< int >(wxDateTime::GMT11)));
38821 SWIG_Python_SetConstant(d, "DateTime_GMT12",SWIG_From_int(static_cast< int >(wxDateTime::GMT12)));
38822 SWIG_Python_SetConstant(d, "DateTime_WET",SWIG_From_int(static_cast< int >(wxDateTime::WET)));
38823 SWIG_Python_SetConstant(d, "DateTime_WEST",SWIG_From_int(static_cast< int >(wxDateTime::WEST)));
38824 SWIG_Python_SetConstant(d, "DateTime_CET",SWIG_From_int(static_cast< int >(wxDateTime::CET)));
38825 SWIG_Python_SetConstant(d, "DateTime_CEST",SWIG_From_int(static_cast< int >(wxDateTime::CEST)));
38826 SWIG_Python_SetConstant(d, "DateTime_EET",SWIG_From_int(static_cast< int >(wxDateTime::EET)));
38827 SWIG_Python_SetConstant(d, "DateTime_EEST",SWIG_From_int(static_cast< int >(wxDateTime::EEST)));
38828 SWIG_Python_SetConstant(d, "DateTime_MSK",SWIG_From_int(static_cast< int >(wxDateTime::MSK)));
38829 SWIG_Python_SetConstant(d, "DateTime_MSD",SWIG_From_int(static_cast< int >(wxDateTime::MSD)));
38830 SWIG_Python_SetConstant(d, "DateTime_AST",SWIG_From_int(static_cast< int >(wxDateTime::AST)));
38831 SWIG_Python_SetConstant(d, "DateTime_ADT",SWIG_From_int(static_cast< int >(wxDateTime::ADT)));
38832 SWIG_Python_SetConstant(d, "DateTime_EST",SWIG_From_int(static_cast< int >(wxDateTime::EST)));
38833 SWIG_Python_SetConstant(d, "DateTime_EDT",SWIG_From_int(static_cast< int >(wxDateTime::EDT)));
38834 SWIG_Python_SetConstant(d, "DateTime_CST",SWIG_From_int(static_cast< int >(wxDateTime::CST)));
38835 SWIG_Python_SetConstant(d, "DateTime_CDT",SWIG_From_int(static_cast< int >(wxDateTime::CDT)));
38836 SWIG_Python_SetConstant(d, "DateTime_MST",SWIG_From_int(static_cast< int >(wxDateTime::MST)));
38837 SWIG_Python_SetConstant(d, "DateTime_MDT",SWIG_From_int(static_cast< int >(wxDateTime::MDT)));
38838 SWIG_Python_SetConstant(d, "DateTime_PST",SWIG_From_int(static_cast< int >(wxDateTime::PST)));
38839 SWIG_Python_SetConstant(d, "DateTime_PDT",SWIG_From_int(static_cast< int >(wxDateTime::PDT)));
38840 SWIG_Python_SetConstant(d, "DateTime_HST",SWIG_From_int(static_cast< int >(wxDateTime::HST)));
38841 SWIG_Python_SetConstant(d, "DateTime_AKST",SWIG_From_int(static_cast< int >(wxDateTime::AKST)));
38842 SWIG_Python_SetConstant(d, "DateTime_AKDT",SWIG_From_int(static_cast< int >(wxDateTime::AKDT)));
38843 SWIG_Python_SetConstant(d, "DateTime_A_WST",SWIG_From_int(static_cast< int >(wxDateTime::A_WST)));
38844 SWIG_Python_SetConstant(d, "DateTime_A_CST",SWIG_From_int(static_cast< int >(wxDateTime::A_CST)));
38845 SWIG_Python_SetConstant(d, "DateTime_A_EST",SWIG_From_int(static_cast< int >(wxDateTime::A_EST)));
38846 SWIG_Python_SetConstant(d, "DateTime_A_ESST",SWIG_From_int(static_cast< int >(wxDateTime::A_ESST)));
38847 SWIG_Python_SetConstant(d, "DateTime_UTC",SWIG_From_int(static_cast< int >(wxDateTime::UTC)));
38848 SWIG_Python_SetConstant(d, "DateTime_Gregorian",SWIG_From_int(static_cast< int >(wxDateTime::Gregorian)));
38849 SWIG_Python_SetConstant(d, "DateTime_Julian",SWIG_From_int(static_cast< int >(wxDateTime::Julian)));
38850 SWIG_Python_SetConstant(d, "DateTime_Gr_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Unknown)));
38851 SWIG_Python_SetConstant(d, "DateTime_Gr_Standard",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Standard)));
38852 SWIG_Python_SetConstant(d, "DateTime_Gr_Alaska",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Alaska)));
38853 SWIG_Python_SetConstant(d, "DateTime_Gr_Albania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Albania)));
38854 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria)));
38855 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Brixen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Brixen)));
38856 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Salzburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Salzburg)));
38857 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Tyrol",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Tyrol)));
38858 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Carinthia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Carinthia)));
38859 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Styria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Styria)));
38860 SWIG_Python_SetConstant(d, "DateTime_Gr_Belgium",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Belgium)));
38861 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria)));
38862 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_1)));
38863 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_2)));
38864 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_3)));
38865 SWIG_Python_SetConstant(d, "DateTime_Gr_Canada",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Canada)));
38866 SWIG_Python_SetConstant(d, "DateTime_Gr_China",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China)));
38867 SWIG_Python_SetConstant(d, "DateTime_Gr_China_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_1)));
38868 SWIG_Python_SetConstant(d, "DateTime_Gr_China_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_2)));
38869 SWIG_Python_SetConstant(d, "DateTime_Gr_Czechoslovakia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Czechoslovakia)));
38870 SWIG_Python_SetConstant(d, "DateTime_Gr_Denmark",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Denmark)));
38871 SWIG_Python_SetConstant(d, "DateTime_Gr_Egypt",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Egypt)));
38872 SWIG_Python_SetConstant(d, "DateTime_Gr_Estonia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Estonia)));
38873 SWIG_Python_SetConstant(d, "DateTime_Gr_Finland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Finland)));
38874 SWIG_Python_SetConstant(d, "DateTime_Gr_France",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France)));
38875 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Alsace",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Alsace)));
38876 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Lorraine",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Lorraine)));
38877 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Strasbourg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Strasbourg)));
38878 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany)));
38879 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Catholic)));
38880 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Prussia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Prussia)));
38881 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Protestant)));
38882 SWIG_Python_SetConstant(d, "DateTime_Gr_GreatBritain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_GreatBritain)));
38883 SWIG_Python_SetConstant(d, "DateTime_Gr_Greece",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Greece)));
38884 SWIG_Python_SetConstant(d, "DateTime_Gr_Hungary",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Hungary)));
38885 SWIG_Python_SetConstant(d, "DateTime_Gr_Ireland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Ireland)));
38886 SWIG_Python_SetConstant(d, "DateTime_Gr_Italy",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Italy)));
38887 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan)));
38888 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_1)));
38889 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_2)));
38890 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_3)));
38891 SWIG_Python_SetConstant(d, "DateTime_Gr_Latvia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Latvia)));
38892 SWIG_Python_SetConstant(d, "DateTime_Gr_Lithuania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Lithuania)));
38893 SWIG_Python_SetConstant(d, "DateTime_Gr_Luxemburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Luxemburg)));
38894 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands)));
38895 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Groningen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Groningen)));
38896 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Gelderland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Gelderland)));
38897 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Utrecht",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Utrecht)));
38898 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Friesland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Friesland)));
38899 SWIG_Python_SetConstant(d, "DateTime_Gr_Norway",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Norway)));
38900 SWIG_Python_SetConstant(d, "DateTime_Gr_Poland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Poland)));
38901 SWIG_Python_SetConstant(d, "DateTime_Gr_Portugal",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Portugal)));
38902 SWIG_Python_SetConstant(d, "DateTime_Gr_Romania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Romania)));
38903 SWIG_Python_SetConstant(d, "DateTime_Gr_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Russia)));
38904 SWIG_Python_SetConstant(d, "DateTime_Gr_Scotland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Scotland)));
38905 SWIG_Python_SetConstant(d, "DateTime_Gr_Spain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Spain)));
38906 SWIG_Python_SetConstant(d, "DateTime_Gr_Sweden",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Sweden)));
38907 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland)));
38908 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Catholic)));
38909 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Protestant)));
38910 SWIG_Python_SetConstant(d, "DateTime_Gr_Turkey",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Turkey)));
38911 SWIG_Python_SetConstant(d, "DateTime_Gr_USA",SWIG_From_int(static_cast< int >(wxDateTime::Gr_USA)));
38912 SWIG_Python_SetConstant(d, "DateTime_Gr_Wales",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Wales)));
38913 SWIG_Python_SetConstant(d, "DateTime_Gr_Yugoslavia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Yugoslavia)));
38914 SWIG_Python_SetConstant(d, "DateTime_Country_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Country_Unknown)));
38915 SWIG_Python_SetConstant(d, "DateTime_Country_Default",SWIG_From_int(static_cast< int >(wxDateTime::Country_Default)));
38916 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_Start",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_Start)));
38917 SWIG_Python_SetConstant(d, "DateTime_Country_EEC",SWIG_From_int(static_cast< int >(wxDateTime::Country_EEC)));
38918 SWIG_Python_SetConstant(d, "DateTime_France",SWIG_From_int(static_cast< int >(wxDateTime::France)));
38919 SWIG_Python_SetConstant(d, "DateTime_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Germany)));
38920 SWIG_Python_SetConstant(d, "DateTime_UK",SWIG_From_int(static_cast< int >(wxDateTime::UK)));
38921 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_End",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_End)));
38922 SWIG_Python_SetConstant(d, "DateTime_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Russia)));
38923 SWIG_Python_SetConstant(d, "DateTime_USA",SWIG_From_int(static_cast< int >(wxDateTime::USA)));
38924 SWIG_Python_SetConstant(d, "DateTime_Jan",SWIG_From_int(static_cast< int >(wxDateTime::Jan)));
38925 SWIG_Python_SetConstant(d, "DateTime_Feb",SWIG_From_int(static_cast< int >(wxDateTime::Feb)));
38926 SWIG_Python_SetConstant(d, "DateTime_Mar",SWIG_From_int(static_cast< int >(wxDateTime::Mar)));
38927 SWIG_Python_SetConstant(d, "DateTime_Apr",SWIG_From_int(static_cast< int >(wxDateTime::Apr)));
38928 SWIG_Python_SetConstant(d, "DateTime_May",SWIG_From_int(static_cast< int >(wxDateTime::May)));
38929 SWIG_Python_SetConstant(d, "DateTime_Jun",SWIG_From_int(static_cast< int >(wxDateTime::Jun)));
38930 SWIG_Python_SetConstant(d, "DateTime_Jul",SWIG_From_int(static_cast< int >(wxDateTime::Jul)));
38931 SWIG_Python_SetConstant(d, "DateTime_Aug",SWIG_From_int(static_cast< int >(wxDateTime::Aug)));
38932 SWIG_Python_SetConstant(d, "DateTime_Sep",SWIG_From_int(static_cast< int >(wxDateTime::Sep)));
38933 SWIG_Python_SetConstant(d, "DateTime_Oct",SWIG_From_int(static_cast< int >(wxDateTime::Oct)));
38934 SWIG_Python_SetConstant(d, "DateTime_Nov",SWIG_From_int(static_cast< int >(wxDateTime::Nov)));
38935 SWIG_Python_SetConstant(d, "DateTime_Dec",SWIG_From_int(static_cast< int >(wxDateTime::Dec)));
38936 SWIG_Python_SetConstant(d, "DateTime_Inv_Month",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Month)));
38937 SWIG_Python_SetConstant(d, "DateTime_Sun",SWIG_From_int(static_cast< int >(wxDateTime::Sun)));
38938 SWIG_Python_SetConstant(d, "DateTime_Mon",SWIG_From_int(static_cast< int >(wxDateTime::Mon)));
38939 SWIG_Python_SetConstant(d, "DateTime_Tue",SWIG_From_int(static_cast< int >(wxDateTime::Tue)));
38940 SWIG_Python_SetConstant(d, "DateTime_Wed",SWIG_From_int(static_cast< int >(wxDateTime::Wed)));
38941 SWIG_Python_SetConstant(d, "DateTime_Thu",SWIG_From_int(static_cast< int >(wxDateTime::Thu)));
38942 SWIG_Python_SetConstant(d, "DateTime_Fri",SWIG_From_int(static_cast< int >(wxDateTime::Fri)));
38943 SWIG_Python_SetConstant(d, "DateTime_Sat",SWIG_From_int(static_cast< int >(wxDateTime::Sat)));
38944 SWIG_Python_SetConstant(d, "DateTime_Inv_WeekDay",SWIG_From_int(static_cast< int >(wxDateTime::Inv_WeekDay)));
38945 SWIG_Python_SetConstant(d, "DateTime_Inv_Year",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Year)));
38946 SWIG_Python_SetConstant(d, "DateTime_Name_Full",SWIG_From_int(static_cast< int >(wxDateTime::Name_Full)));
38947 SWIG_Python_SetConstant(d, "DateTime_Name_Abbr",SWIG_From_int(static_cast< int >(wxDateTime::Name_Abbr)));
38948 SWIG_Python_SetConstant(d, "DateTime_Default_First",SWIG_From_int(static_cast< int >(wxDateTime::Default_First)));
38949 SWIG_Python_SetConstant(d, "DateTime_Monday_First",SWIG_From_int(static_cast< int >(wxDateTime::Monday_First)));
38950 SWIG_Python_SetConstant(d, "DateTime_Sunday_First",SWIG_From_int(static_cast< int >(wxDateTime::Sunday_First)));
38951 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTime",DefaultDateTime_get, DefaultDateTime_set);
38952 SWIG_Python_SetConstant(d, "DF_INVALID",SWIG_From_int(static_cast< int >(wxDF_INVALID)));
38953 SWIG_Python_SetConstant(d, "DF_TEXT",SWIG_From_int(static_cast< int >(wxDF_TEXT)));
38954 SWIG_Python_SetConstant(d, "DF_BITMAP",SWIG_From_int(static_cast< int >(wxDF_BITMAP)));
38955 SWIG_Python_SetConstant(d, "DF_METAFILE",SWIG_From_int(static_cast< int >(wxDF_METAFILE)));
38956 SWIG_Python_SetConstant(d, "DF_SYLK",SWIG_From_int(static_cast< int >(wxDF_SYLK)));
38957 SWIG_Python_SetConstant(d, "DF_DIF",SWIG_From_int(static_cast< int >(wxDF_DIF)));
38958 SWIG_Python_SetConstant(d, "DF_TIFF",SWIG_From_int(static_cast< int >(wxDF_TIFF)));
38959 SWIG_Python_SetConstant(d, "DF_OEMTEXT",SWIG_From_int(static_cast< int >(wxDF_OEMTEXT)));
38960 SWIG_Python_SetConstant(d, "DF_DIB",SWIG_From_int(static_cast< int >(wxDF_DIB)));
38961 SWIG_Python_SetConstant(d, "DF_PALETTE",SWIG_From_int(static_cast< int >(wxDF_PALETTE)));
38962 SWIG_Python_SetConstant(d, "DF_PENDATA",SWIG_From_int(static_cast< int >(wxDF_PENDATA)));
38963 SWIG_Python_SetConstant(d, "DF_RIFF",SWIG_From_int(static_cast< int >(wxDF_RIFF)));
38964 SWIG_Python_SetConstant(d, "DF_WAVE",SWIG_From_int(static_cast< int >(wxDF_WAVE)));
38965 SWIG_Python_SetConstant(d, "DF_UNICODETEXT",SWIG_From_int(static_cast< int >(wxDF_UNICODETEXT)));
38966 SWIG_Python_SetConstant(d, "DF_ENHMETAFILE",SWIG_From_int(static_cast< int >(wxDF_ENHMETAFILE)));
38967 SWIG_Python_SetConstant(d, "DF_FILENAME",SWIG_From_int(static_cast< int >(wxDF_FILENAME)));
38968 SWIG_Python_SetConstant(d, "DF_LOCALE",SWIG_From_int(static_cast< int >(wxDF_LOCALE)));
38969 SWIG_Python_SetConstant(d, "DF_PRIVATE",SWIG_From_int(static_cast< int >(wxDF_PRIVATE)));
38970 SWIG_Python_SetConstant(d, "DF_HTML",SWIG_From_int(static_cast< int >(wxDF_HTML)));
38971 SWIG_Python_SetConstant(d, "DF_MAX",SWIG_From_int(static_cast< int >(wxDF_MAX)));
38972 SWIG_addvarlink(SWIG_globals(),(char*)"FormatInvalid",FormatInvalid_get, FormatInvalid_set);
38973 SWIG_Python_SetConstant(d, "DataObject_Get",SWIG_From_int(static_cast< int >(wxDataObject::Get)));
38974 SWIG_Python_SetConstant(d, "DataObject_Set",SWIG_From_int(static_cast< int >(wxDataObject::Set)));
38975 SWIG_Python_SetConstant(d, "DataObject_Both",SWIG_From_int(static_cast< int >(wxDataObject::Both)));
38976 SWIG_Python_SetConstant(d, "Drag_CopyOnly",SWIG_From_int(static_cast< int >(wxDrag_CopyOnly)));
38977 SWIG_Python_SetConstant(d, "Drag_AllowMove",SWIG_From_int(static_cast< int >(wxDrag_AllowMove)));
38978 SWIG_Python_SetConstant(d, "Drag_DefaultMove",SWIG_From_int(static_cast< int >(wxDrag_DefaultMove)));
38979 SWIG_Python_SetConstant(d, "DragError",SWIG_From_int(static_cast< int >(wxDragError)));
38980 SWIG_Python_SetConstant(d, "DragNone",SWIG_From_int(static_cast< int >(wxDragNone)));
38981 SWIG_Python_SetConstant(d, "DragCopy",SWIG_From_int(static_cast< int >(wxDragCopy)));
38982 SWIG_Python_SetConstant(d, "DragMove",SWIG_From_int(static_cast< int >(wxDragMove)));
38983 SWIG_Python_SetConstant(d, "DragLink",SWIG_From_int(static_cast< int >(wxDragLink)));
38984 SWIG_Python_SetConstant(d, "DragCancel",SWIG_From_int(static_cast< int >(wxDragCancel)));
38985
38986 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
38987 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
38988 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
38989 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
38990
38991 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultVideoMode",DefaultVideoMode_get, DefaultVideoMode_set);
38992 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_None",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_None)));
38993 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Messages",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Messages)));
38994 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Max",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Max)));
38995 }
38996
wxWidgets (Impactor)