]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/msw/_misc_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
* wx.Panel doesn't have a SetTitle anymore. What was this used for
[wxWidgets.git] / wxPython / src / msw / _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_wxMetafile swig_types[93]
2556 #define SWIGTYPE_p_wxMetafileDataObject swig_types[94]
2557 #define SWIGTYPE_p_wxMimeTypesManager swig_types[95]
2558 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[96]
2559 #define SWIGTYPE_p_wxMouseEvent swig_types[97]
2560 #define SWIGTYPE_p_wxMouseState swig_types[98]
2561 #define SWIGTYPE_p_wxMoveEvent swig_types[99]
2562 #define SWIGTYPE_p_wxMutexGuiLocker swig_types[100]
2563 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[101]
2564 #define SWIGTYPE_p_wxNcPaintEvent swig_types[102]
2565 #define SWIGTYPE_p_wxNotifyEvent swig_types[103]
2566 #define SWIGTYPE_p_wxObject swig_types[104]
2567 #define SWIGTYPE_p_wxOutputStream swig_types[105]
2568 #define SWIGTYPE_p_wxPCXHandler swig_types[106]
2569 #define SWIGTYPE_p_wxPNGHandler swig_types[107]
2570 #define SWIGTYPE_p_wxPNMHandler swig_types[108]
2571 #define SWIGTYPE_p_wxPaintEvent swig_types[109]
2572 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[110]
2573 #define SWIGTYPE_p_wxPaperSize swig_types[111]
2574 #define SWIGTYPE_p_wxPoint swig_types[112]
2575 #define SWIGTYPE_p_wxProcessEvent swig_types[113]
2576 #define SWIGTYPE_p_wxPyApp swig_types[114]
2577 #define SWIGTYPE_p_wxPyArtProvider swig_types[115]
2578 #define SWIGTYPE_p_wxPyBitmapDataObject swig_types[116]
2579 #define SWIGTYPE_p_wxPyCommandEvent swig_types[117]
2580 #define SWIGTYPE_p_wxPyDataObjectSimple swig_types[118]
2581 #define SWIGTYPE_p_wxPyDropSource swig_types[119]
2582 #define SWIGTYPE_p_wxPyDropTarget swig_types[120]
2583 #define SWIGTYPE_p_wxPyEvent swig_types[121]
2584 #define SWIGTYPE_p_wxPyFileDropTarget swig_types[122]
2585 #define SWIGTYPE_p_wxPyImageHandler swig_types[123]
2586 #define SWIGTYPE_p_wxPyLog swig_types[124]
2587 #define SWIGTYPE_p_wxPyProcess swig_types[125]
2588 #define SWIGTYPE_p_wxPySizer swig_types[126]
2589 #define SWIGTYPE_p_wxPyTextDataObject swig_types[127]
2590 #define SWIGTYPE_p_wxPyTextDropTarget swig_types[128]
2591 #define SWIGTYPE_p_wxPyTimer swig_types[129]
2592 #define SWIGTYPE_p_wxPyTipProvider swig_types[130]
2593 #define SWIGTYPE_p_wxPyValidator swig_types[131]
2594 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[132]
2595 #define SWIGTYPE_p_wxRect swig_types[133]
2596 #define SWIGTYPE_p_wxScrollEvent swig_types[134]
2597 #define SWIGTYPE_p_wxScrollWinEvent swig_types[135]
2598 #define SWIGTYPE_p_wxSetCursorEvent swig_types[136]
2599 #define SWIGTYPE_p_wxShowEvent swig_types[137]
2600 #define SWIGTYPE_p_wxSingleInstanceChecker swig_types[138]
2601 #define SWIGTYPE_p_wxSize swig_types[139]
2602 #define SWIGTYPE_p_wxSizeEvent swig_types[140]
2603 #define SWIGTYPE_p_wxSizer swig_types[141]
2604 #define SWIGTYPE_p_wxSizerItem swig_types[142]
2605 #define SWIGTYPE_p_wxSound swig_types[143]
2606 #define SWIGTYPE_p_wxStandardPaths swig_types[144]
2607 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[145]
2608 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[146]
2609 #define SWIGTYPE_p_wxStopWatch swig_types[147]
2610 #define SWIGTYPE_p_wxString swig_types[148]
2611 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[149]
2612 #define SWIGTYPE_p_wxSystemOptions swig_types[150]
2613 #define SWIGTYPE_p_wxSystemSettings swig_types[151]
2614 #define SWIGTYPE_p_wxTIFFHandler swig_types[152]
2615 #define SWIGTYPE_p_wxTextCtrl swig_types[153]
2616 #define SWIGTYPE_p_wxTextDataObject swig_types[154]
2617 #define SWIGTYPE_p_wxTimeSpan swig_types[155]
2618 #define SWIGTYPE_p_wxTimer swig_types[156]
2619 #define SWIGTYPE_p_wxTimerEvent swig_types[157]
2620 #define SWIGTYPE_p_wxTimerRunner swig_types[158]
2621 #define SWIGTYPE_p_wxTipProvider swig_types[159]
2622 #define SWIGTYPE_p_wxToolTip swig_types[160]
2623 #define SWIGTYPE_p_wxURLDataObject swig_types[161]
2624 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[162]
2625 #define SWIGTYPE_p_wxValidator swig_types[163]
2626 #define SWIGTYPE_p_wxVideoMode swig_types[164]
2627 #define SWIGTYPE_p_wxWindow swig_types[165]
2628 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[166]
2629 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[167]
2630 #define SWIGTYPE_p_wxWindowDisabler swig_types[168]
2631 #define SWIGTYPE_p_wxXPMHandler swig_types[169]
2632 static swig_type_info *swig_types[171];
2633 static swig_module_info swig_module = {swig_types, 170, 0, 0, 0, 0};
2634 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2635 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2636
2637 /* -------- TYPES TABLE (END) -------- */
2638
2639 #if (PY_VERSION_HEX <= 0x02000000)
2640 # if !defined(SWIG_PYTHON_CLASSIC)
2641 # error "This python version requires to use swig with the '-classic' option"
2642 # endif
2643 #endif
2644 #if (PY_VERSION_HEX <= 0x02020000)
2645 # error "This python version requires to use swig with the '-nomodern' option"
2646 #endif
2647 #if (PY_VERSION_HEX <= 0x02020000)
2648 # error "This python version requires to use swig with the '-nomodernargs' option"
2649 #endif
2650 #ifndef METH_O
2651 # error "This python version requires to use swig with the '-nofastunpack' option"
2652 #endif
2653
2654 /*-----------------------------------------------
2655 @(target):= _misc_.so
2656 ------------------------------------------------*/
2657 #define SWIG_init init_misc_
2658
2659 #define SWIG_name "_misc_"
2660
2661 #define SWIGVERSION 0x010329
2662
2663
2664 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2665 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2666
2667
2668 #include <stdexcept>
2669
2670
2671 namespace swig {
2672 class PyObject_ptr {
2673 protected:
2674 PyObject *_obj;
2675
2676 public:
2677 PyObject_ptr() :_obj(0)
2678 {
2679 }
2680
2681 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2682 {
2683 Py_XINCREF(_obj);
2684 }
2685
2686 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2687 {
2688 if (initial_ref) Py_XINCREF(_obj);
2689 }
2690
2691 PyObject_ptr & operator=(const PyObject_ptr& item)
2692 {
2693 Py_XINCREF(item._obj);
2694 Py_XDECREF(_obj);
2695 _obj = item._obj;
2696 return *this;
2697 }
2698
2699 ~PyObject_ptr()
2700 {
2701 Py_XDECREF(_obj);
2702 }
2703
2704 operator PyObject *() const
2705 {
2706 return _obj;
2707 }
2708
2709 PyObject *operator->() const
2710 {
2711 return _obj;
2712 }
2713 };
2714 }
2715
2716
2717 namespace swig {
2718 struct PyObject_var : PyObject_ptr {
2719 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2720
2721 PyObject_var & operator = (PyObject* obj)
2722 {
2723 Py_XDECREF(_obj);
2724 _obj = obj;
2725 return *this;
2726 }
2727 };
2728 }
2729
2730
2731 #include "wx/wxPython/wxPython.h"
2732 #include "wx/wxPython/pyclasses.h"
2733 #include "wx/wxPython/pyistream.h"
2734
2735 static const wxString wxPyEmptyString(wxEmptyString);
2736
2737
2738
2739 #define SWIG_From_long PyInt_FromLong
2740
2741
2742 SWIGINTERNINLINE PyObject *
2743 SWIG_From_int (int value)
2744 {
2745 return SWIG_From_long (value);
2746 }
2747
2748
2749 #include <limits.h>
2750 #ifndef LLONG_MIN
2751 # define LLONG_MIN LONG_LONG_MIN
2752 #endif
2753 #ifndef LLONG_MAX
2754 # define LLONG_MAX LONG_LONG_MAX
2755 #endif
2756 #ifndef ULLONG_MAX
2757 # define ULLONG_MAX ULONG_LONG_MAX
2758 #endif
2759
2760
2761 SWIGINTERN int
2762 SWIG_AsVal_long (PyObject* obj, long* val)
2763 {
2764 if (PyNumber_Check(obj)) {
2765 if (val) *val = PyInt_AsLong(obj);
2766 return SWIG_OK;
2767 }
2768 return SWIG_TypeError;
2769 }
2770
2771
2772 SWIGINTERN int
2773 SWIG_AsVal_int (PyObject * obj, int *val)
2774 {
2775 long v;
2776 int res = SWIG_AsVal_long (obj, &v);
2777 if (SWIG_IsOK(res)) {
2778 if ((v < INT_MIN || v > INT_MAX)) {
2779 return SWIG_OverflowError;
2780 } else {
2781 if (val) *val = static_cast< int >(v);
2782 }
2783 }
2784 return res;
2785 }
2786
2787 static const wxString wxPyWINDOW_DEFAULT_VARIANT(wxWINDOW_DEFAULT_VARIANT);
2788
2789 #include <wx/stockitem.h>
2790
2791 static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
2792 static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
2793 static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
2794
2795 SWIGINTERN int
2796 SWIG_AsVal_bool (PyObject *obj, bool *val)
2797 {
2798 if (obj == Py_True) {
2799 if (val) *val = true;
2800 return SWIG_OK;
2801 } else if (obj == Py_False) {
2802 if (val) *val = false;
2803 return SWIG_OK;
2804 } else {
2805 long v = 0;
2806 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
2807 if (SWIG_IsOK(res) && val) *val = v ? true : false;
2808 return res;
2809 }
2810 }
2811
2812
2813 SWIGINTERN int
2814 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
2815 {
2816 long v = 0;
2817 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2818 return SWIG_TypeError;
2819 }
2820 else if (val)
2821 *val = (unsigned long)v;
2822 return SWIG_OK;
2823 }
2824
2825
2826 SWIGINTERNINLINE PyObject*
2827 SWIG_From_unsigned_SS_long (unsigned long value)
2828 {
2829 return (value > LONG_MAX) ?
2830 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
2831 }
2832
2833
2834 void* wxGetXDisplay()
2835 {
2836 #ifdef __WXGTK__
2837 return wxGetDisplay();
2838 #else
2839 return NULL;
2840 #endif
2841 }
2842
2843
2844 wxWindow* FindWindowAtPointer() {
2845 wxPoint unused;
2846 return wxFindWindowAtPointer(unused);
2847 }
2848
2849
2850 bool wxThread_IsMain() {
2851 #ifdef WXP_WITH_THREAD
2852 return wxThread::IsMain();
2853 #else
2854 return true;
2855 #endif
2856 }
2857
2858 SWIGINTERN void wxCaret_Destroy(wxCaret *self){
2859 delete self;
2860 }
2861
2862 #include <wx/snglinst.h>
2863
2864
2865 #ifdef __WXMSW__
2866 #include <wx/msw/private.h>
2867 #include <wx/dynload.h>
2868 #endif
2869
2870
2871
2872 bool wxDrawWindowOnDC(wxWindow* window, const wxDC& dc
2873 #if 0
2874 , int method
2875 #endif
2876 )
2877 {
2878 #ifdef __WXMSW__
2879 #if 0
2880 switch (method)
2881 {
2882 case 1:
2883 // This one only partially works. Appears to be an undocumented
2884 // "standard" convention that not all widgets adhear to. For
2885 // example, for some widgets backgrounds or non-client areas may
2886 // not be painted.
2887 ::SendMessage(GetHwndOf(window), WM_PAINT, (long)GetHdcOf(dc), 0);
2888 break;
2889
2890 case 2:
2891 #endif
2892 // This one works much better, nearly all widgets and their
2893 // children are captured correctly[**]. Prior to the big
2894 // background erase changes that Vadim did in 2004-2005 this
2895 // method failed badly on XP with Themes activated, most native
2896 // widgets draw only partially, if at all. Without themes it
2897 // worked just like on Win2k. After those changes this method
2898 // works very well.
2899 //
2900 // ** For example the radio buttons in a wxRadioBox are not its
2901 // children by default, but you can capture it via the panel
2902 // instead, or change RADIOBTN_PARENT_IS_RADIOBOX in radiobox.cpp.
2903 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2904 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2905 PRF_ERASEBKGND | PRF_OWNED );
2906 return true;
2907 #if 0
2908 break;
2909
2910 case 3:
2911 // This one is only defined in the latest SDK and is only
2912 // available on XP. MSDN says it is similar to sending WM_PRINT
2913 // so I expect that it will work similar to the above. Since it
2914 // is avaialble only on XP, it can't be compiled like this and
2915 // will have to be loaded dynamically.
2916 // //::PrintWindow(GetHwndOf(window), GetHdcOf(dc), 0); //break;
2917
2918 // fall through
2919
2920 case 4:
2921 // Use PrintWindow if available, or fallback to WM_PRINT
2922 // otherwise. Unfortunately using PrintWindow is even worse than
2923 // WM_PRINT. For most native widgets nothing is drawn to the dc
2924 // at all, with or without Themes.
2925 typedef BOOL (WINAPI *PrintWindow_t)(HWND, HDC, UINT);
2926 static bool s_triedToLoad = false;
2927 static PrintWindow_t pfnPrintWindow = NULL;
2928 if ( !s_triedToLoad )
2929 {
2930
2931 s_triedToLoad = true;
2932 wxDynamicLibrary dllUser32(_T("user32.dll"));
2933 if ( dllUser32.IsLoaded() )
2934 {
2935 wxLogNull nolog; // Don't report errors here
2936 pfnPrintWindow = (PrintWindow_t)dllUser32.GetSymbol(_T("PrintWindow"));
2937 }
2938 }
2939 if (pfnPrintWindow)
2940 {
2941 //printf("Using PrintWindow\n");
2942 pfnPrintWindow(GetHwndOf(window), GetHdcOf(dc), 0);
2943 }
2944 else
2945 {
2946 //printf("Using WM_PRINT\n");
2947 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2948 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2949 PRF_ERASEBKGND | PRF_OWNED );
2950 }
2951 }
2952 #endif // 0
2953 #else
2954 return false;
2955 #endif // __WXMSW__
2956 }
2957
2958
2959
2960 #include <wx/tipdlg.h>
2961
2962
2963 SWIGINTERNINLINE PyObject *
2964 SWIG_From_size_t (size_t value)
2965 {
2966 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
2967 }
2968
2969
2970 class wxPyTipProvider : public wxTipProvider {
2971 public:
2972 wxPyTipProvider(size_t currentTip)
2973 : wxTipProvider(currentTip) {}
2974
2975 DEC_PYCALLBACK_STRING__pure(GetTip);
2976 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
2977 PYPRIVATE;
2978 };
2979
2980 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
2981 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
2982
2983
2984 SWIGINTERNINLINE int
2985 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
2986 {
2987 unsigned long v;
2988 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
2989 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
2990 return res;
2991 }
2992
2993
2994 IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
2995
2996 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
2997
2998 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
2999 : wxTimer(owner, id)
3000 {
3001 if (owner == NULL)
3002 SetOwner(this);
3003 }
3004
3005
3006 SWIGINTERN swig_type_info*
3007 SWIG_pchar_descriptor()
3008 {
3009 static int init = 0;
3010 static swig_type_info* info = 0;
3011 if (!init) {
3012 info = SWIG_TypeQuery("_p_char");
3013 init = 1;
3014 }
3015 return info;
3016 }
3017
3018
3019 SWIGINTERNINLINE PyObject *
3020 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3021 {
3022 if (carray) {
3023 if (size > INT_MAX) {
3024 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3025 return pchar_descriptor ?
3026 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3027 } else {
3028 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3029 }
3030 } else {
3031 return SWIG_Py_Void();
3032 }
3033 }
3034
3035
3036 SWIGINTERNINLINE PyObject *
3037 SWIG_FromCharPtr(const char *cptr)
3038 {
3039 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3040 }
3041
3042
3043 SWIGINTERN int
3044 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3045 {
3046 unsigned long v;
3047 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3048 if (SWIG_IsOK(res)) {
3049 if ((v > UINT_MAX)) {
3050 return SWIG_OverflowError;
3051 } else {
3052 if (val) *val = static_cast< unsigned int >(v);
3053 }
3054 }
3055 return res;
3056 }
3057
3058 SWIGINTERN wxString wxLog_TimeStamp(){
3059 wxString msg;
3060 wxLog::TimeStamp(&msg);
3061 return msg;
3062 }
3063 SWIGINTERN void wxLog_Destroy(wxLog *self){ delete self; }
3064 // Make some wrappers that double any % signs so they are 'escaped'
3065 void wxPyLogFatalError(const wxString& msg)
3066 {
3067 wxString m(msg);
3068 m.Replace(wxT("%"), wxT("%%"));
3069 wxLogFatalError(m);
3070 }
3071
3072 void wxPyLogError(const wxString& msg)
3073 {
3074 wxString m(msg);
3075 m.Replace(wxT("%"), wxT("%%"));
3076 wxLogError(m);
3077 }
3078
3079 void wxPyLogWarning(const wxString& msg)
3080 {
3081 wxString m(msg);
3082 m.Replace(wxT("%"), wxT("%%"));
3083 wxLogWarning(m);
3084 }
3085
3086 void wxPyLogMessage(const wxString& msg)
3087 {
3088 wxString m(msg);
3089 m.Replace(wxT("%"), wxT("%%"));
3090 wxLogMessage(m);
3091 }
3092
3093 void wxPyLogInfo(const wxString& msg)
3094 {
3095 wxString m(msg);
3096 m.Replace(wxT("%"), wxT("%%"));
3097 wxLogInfo(m);
3098 }
3099
3100 void wxPyLogDebug(const wxString& msg)
3101 {
3102 wxString m(msg);
3103 m.Replace(wxT("%"), wxT("%%"));
3104 wxLogDebug(m);
3105 }
3106
3107 void wxPyLogVerbose(const wxString& msg)
3108 {
3109 wxString m(msg);
3110 m.Replace(wxT("%"), wxT("%%"));
3111 wxLogVerbose(m);
3112 }
3113
3114 void wxPyLogStatus(const wxString& msg)
3115 {
3116 wxString m(msg);
3117 m.Replace(wxT("%"), wxT("%%"));
3118 wxLogStatus(m);
3119 }
3120
3121 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
3122 {
3123 wxString m(msg);
3124 m.Replace(wxT("%"), wxT("%%"));
3125 wxLogStatus(pFrame, m);
3126 }
3127
3128 void wxPyLogSysError(const wxString& msg)
3129 {
3130 wxString m(msg);
3131 m.Replace(wxT("%"), wxT("%%"));
3132 wxLogSysError(m);
3133 }
3134
3135 void wxPyLogGeneric(unsigned long level, const wxString& msg)
3136 {
3137 wxString m(msg);
3138 m.Replace(wxT("%"), wxT("%%"));
3139 wxLogGeneric(level, m);
3140 }
3141
3142 void wxPyLogTrace(unsigned long mask, const wxString& msg)
3143 {
3144 wxString m(msg);
3145 m.Replace(wxT("%"), wxT("%%"));
3146 wxLogTrace(mask, m);
3147 }
3148
3149 void wxPyLogTrace(const wxString& mask, const wxString& msg)
3150 {
3151 wxString m(msg);
3152 m.Replace(wxT("%"), wxT("%%"));
3153 wxLogTrace(mask, m);
3154 }
3155
3156
3157
3158 // A wxLog class that can be derived from in wxPython
3159 class wxPyLog : public wxLog {
3160 public:
3161 wxPyLog() : wxLog() {}
3162
3163 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
3164 bool found;
3165 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3166 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
3167 PyObject* s = wx2PyString(szString);
3168 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
3169 Py_DECREF(s);
3170 }
3171 wxPyEndBlockThreads(blocked);
3172 if (! found)
3173 wxLog::DoLog(level, szString, t);
3174 }
3175
3176 virtual void DoLogString(const wxChar *szString, time_t t) {
3177 bool found;
3178 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3179 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
3180 PyObject* s = wx2PyString(szString);
3181 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
3182 Py_DECREF(s);
3183 }
3184 wxPyEndBlockThreads(blocked);
3185 if (! found)
3186 wxLog::DoLogString(szString, t);
3187 }
3188
3189 DEC_PYCALLBACK_VOID_(Flush);
3190 PYPRIVATE;
3191 };
3192 IMP_PYCALLBACK_VOID_(wxPyLog, wxLog, Flush);
3193
3194
3195
3196
3197 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
3198
3199
3200 #include <wx/joystick.h>
3201
3202
3203 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
3204 // A C++ stub class for wxJoystick for platforms that don't have it.
3205 class wxJoystick : public wxObject {
3206 public:
3207 wxJoystick(int joystick = wxJOYSTICK1) {
3208 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3209 PyErr_SetString(PyExc_NotImplementedError,
3210 "wxJoystick is not available on this platform.");
3211 wxPyEndBlockThreads(blocked);
3212 }
3213 wxPoint GetPosition() { return wxPoint(-1,-1); }
3214 int GetZPosition() { return -1; }
3215 int GetButtonState() { return -1; }
3216 int GetPOVPosition() { return -1; }
3217 int GetPOVCTSPosition() { return -1; }
3218 int GetRudderPosition() { return -1; }
3219 int GetUPosition() { return -1; }
3220 int GetVPosition() { return -1; }
3221 int GetMovementThreshold() { return -1; }
3222 void SetMovementThreshold(int threshold) {}
3223
3224 bool IsOk(void) { return false; }
3225 int GetNumberJoysticks() { return -1; }
3226 int GetManufacturerId() { return -1; }
3227 int GetProductId() { return -1; }
3228 wxString GetProductName() { return wxEmptyString; }
3229 int GetXMin() { return -1; }
3230 int GetYMin() { return -1; }
3231 int GetZMin() { return -1; }
3232 int GetXMax() { return -1; }
3233 int GetYMax() { return -1; }
3234 int GetZMax() { return -1; }
3235 int GetNumberButtons() { return -1; }
3236 int GetNumberAxes() { return -1; }
3237 int GetMaxButtons() { return -1; }
3238 int GetMaxAxes() { return -1; }
3239 int GetPollingMin() { return -1; }
3240 int GetPollingMax() { return -1; }
3241 int GetRudderMin() { return -1; }
3242 int GetRudderMax() { return -1; }
3243 int GetUMin() { return -1; }
3244 int GetUMax() { return -1; }
3245 int GetVMin() { return -1; }
3246 int GetVMax() { return -1; }
3247
3248 bool HasRudder() { return false; }
3249 bool HasZ() { return false; }
3250 bool HasU() { return false; }
3251 bool HasV() { return false; }
3252 bool HasPOV() { return false; }
3253 bool HasPOV4Dir() { return false; }
3254 bool HasPOVCTS() { return false; }
3255
3256 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
3257 bool ReleaseCapture() { return false; }
3258 };
3259 #endif
3260
3261
3262 #include <wx/sound.h>
3263
3264
3265 #if !wxUSE_SOUND
3266 // A C++ stub class for wxWave for platforms that don't have it.
3267 class wxSound : public wxObject
3268 {
3269 public:
3270 wxSound() {
3271 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3272 PyErr_SetString(PyExc_NotImplementedError,
3273 "wxSound is not available on this platform.");
3274 wxPyEndBlockThreads(blocked);
3275 }
3276 wxSound(const wxString&/*, bool*/) {
3277 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3278 PyErr_SetString(PyExc_NotImplementedError,
3279 "wxSound is not available on this platform.");
3280 wxPyEndBlockThreads(blocked);
3281 }
3282 wxSound(int, const wxByte*) {
3283 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3284 PyErr_SetString(PyExc_NotImplementedError,
3285 "wxSound is not available on this platform.");
3286 wxPyEndBlockThreads(blocked);
3287 }
3288
3289 ~wxSound() {};
3290
3291 bool Create(const wxString&/*, bool*/) { return false; }
3292 bool Create(int, const wxByte*) { return false; };
3293 bool IsOk() { return false; };
3294 bool Play(unsigned) const { return false; }
3295 static bool Play(const wxString&, unsigned) { return false; }
3296 static void Stop() {}
3297 };
3298
3299 #endif
3300
3301 SWIGINTERN wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
3302 if (fileName.Length() == 0)
3303 return new wxSound;
3304 else
3305 return new wxSound(fileName);
3306 }
3307 SWIGINTERN wxSound *new_wxSound(PyObject *data){
3308 unsigned char* buffer; int size;
3309 wxSound *sound = NULL;
3310
3311 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3312 if (!PyArg_Parse(data, "t#", &buffer, &size))
3313 goto done;
3314 sound = new wxSound(size, buffer);
3315 done:
3316 wxPyEndBlockThreads(blocked);
3317 return sound;
3318 }
3319 SWIGINTERN bool wxSound_CreateFromData(wxSound *self,PyObject *data){
3320 #ifndef __WXMAC__
3321 unsigned char* buffer;
3322 int size;
3323 bool rv = false;
3324
3325 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3326 if (!PyArg_Parse(data, "t#", &buffer, &size))
3327 goto done;
3328 rv = self->Create(size, buffer);
3329 done:
3330 wxPyEndBlockThreads(blocked);
3331 return rv;
3332 #else
3333 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3334 PyErr_SetString(PyExc_NotImplementedError,
3335 "Create from data is not available on this platform.");
3336 wxPyEndBlockThreads(blocked);
3337 return false;
3338 #endif
3339 }
3340
3341 #include <wx/mimetype.h>
3342
3343 SWIGINTERN PyObject *wxFileType_GetMimeType(wxFileType *self){
3344 wxString str;
3345 if (self->GetMimeType(&str))
3346 return wx2PyString(str);
3347 else
3348 RETURN_NONE();
3349 }
3350 SWIGINTERN PyObject *wxFileType_GetMimeTypes(wxFileType *self){
3351 wxArrayString arr;
3352 if (self->GetMimeTypes(arr))
3353 return wxArrayString2PyList_helper(arr);
3354 else
3355 RETURN_NONE();
3356 }
3357 SWIGINTERN PyObject *wxFileType_GetExtensions(wxFileType *self){
3358 wxArrayString arr;
3359 if (self->GetExtensions(arr))
3360 return wxArrayString2PyList_helper(arr);
3361 else
3362 RETURN_NONE();
3363 }
3364 SWIGINTERN wxIcon *wxFileType_GetIcon(wxFileType *self){
3365 wxIconLocation loc;
3366 if (self->GetIcon(&loc))
3367 return new wxIcon(loc);
3368 else
3369 return NULL;
3370 }
3371 SWIGINTERN PyObject *wxFileType_GetIconInfo(wxFileType *self){
3372 wxIconLocation loc;
3373 if (self->GetIcon(&loc)) {
3374 wxString iconFile = loc.GetFileName();
3375 int iconIndex = -1;
3376
3377 iconIndex = loc.GetIndex();
3378
3379 // Make a tuple and put the values in it
3380 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3381 PyObject* tuple = PyTuple_New(3);
3382 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
3383 wxT("wxIcon"), true));
3384 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
3385 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
3386 wxPyEndBlockThreads(blocked);
3387 return tuple;
3388 }
3389 else
3390 RETURN_NONE();
3391 }
3392 SWIGINTERN PyObject *wxFileType_GetDescription(wxFileType *self){
3393 wxString str;
3394 if (self->GetDescription(&str))
3395 return wx2PyString(str);
3396 else
3397 RETURN_NONE();
3398 }
3399 SWIGINTERN PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3400 wxString str;
3401 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3402 return wx2PyString(str);
3403 else
3404 RETURN_NONE();
3405 }
3406 SWIGINTERN PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3407 wxString str;
3408 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3409 return wx2PyString(str);
3410 else
3411 RETURN_NONE();
3412 }
3413 SWIGINTERN PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3414 wxArrayString verbs;
3415 wxArrayString commands;
3416 if (self->GetAllCommands(&verbs, &commands,
3417 wxFileType::MessageParameters(filename, mimetype))) {
3418 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3419 PyObject* tuple = PyTuple_New(2);
3420 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
3421 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
3422 wxPyEndBlockThreads(blocked);
3423 return tuple;
3424 }
3425 else
3426 RETURN_NONE();
3427 }
3428 SWIGINTERN wxString wxFileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3429 return wxFileType::ExpandCommand(command,
3430 wxFileType::MessageParameters(filename, mimetype));
3431 }
3432 SWIGINTERN PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
3433 wxArrayString arr;
3434 self->EnumAllFileTypes(arr);
3435 return wxArrayString2PyList_helper(arr);
3436 }
3437
3438 #include <wx/artprov.h>
3439
3440 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
3441 static const wxString wxPyART_MENU(wxART_MENU);
3442 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
3443 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
3444 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
3445 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
3446 static const wxString wxPyART_BUTTON(wxART_BUTTON);
3447 static const wxString wxPyART_OTHER(wxART_OTHER);
3448 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
3449 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
3450 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
3451 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
3452 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
3453 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
3454 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
3455 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
3456 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
3457 static const wxString wxPyART_GO_UP(wxART_GO_UP);
3458 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
3459 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
3460 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
3461 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
3462 static const wxString wxPyART_FILE_SAVE(wxART_FILE_SAVE);
3463 static const wxString wxPyART_FILE_SAVE_AS(wxART_FILE_SAVE_AS);
3464 static const wxString wxPyART_PRINT(wxART_PRINT);
3465 static const wxString wxPyART_HELP(wxART_HELP);
3466 static const wxString wxPyART_TIP(wxART_TIP);
3467 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
3468 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
3469 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
3470 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
3471 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
3472 static const wxString wxPyART_CDROM(wxART_CDROM);
3473 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
3474 static const wxString wxPyART_FOLDER(wxART_FOLDER);
3475 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
3476 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
3477 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
3478 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
3479 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
3480 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
3481 static const wxString wxPyART_ERROR(wxART_ERROR);
3482 static const wxString wxPyART_QUESTION(wxART_QUESTION);
3483 static const wxString wxPyART_WARNING(wxART_WARNING);
3484 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
3485 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
3486 static const wxString wxPyART_COPY(wxART_COPY);
3487 static const wxString wxPyART_CUT(wxART_CUT);
3488 static const wxString wxPyART_PASTE(wxART_PASTE);
3489 static const wxString wxPyART_DELETE(wxART_DELETE);
3490 static const wxString wxPyART_NEW(wxART_NEW);
3491 static const wxString wxPyART_UNDO(wxART_UNDO);
3492 static const wxString wxPyART_REDO(wxART_REDO);
3493 static const wxString wxPyART_QUIT(wxART_QUIT);
3494 static const wxString wxPyART_FIND(wxART_FIND);
3495 static const wxString wxPyART_FIND_AND_REPLACE(wxART_FIND_AND_REPLACE);
3496 // Python aware wxArtProvider
3497 class wxPyArtProvider : public wxArtProvider {
3498 public:
3499
3500 virtual wxBitmap CreateBitmap(const wxArtID& id,
3501 const wxArtClient& client,
3502 const wxSize& size) {
3503 wxBitmap rval = wxNullBitmap;
3504 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3505 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
3506 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
3507 PyObject* ro;
3508 wxBitmap* ptr;
3509 PyObject* s1, *s2;
3510 s1 = wx2PyString(id);
3511 s2 = wx2PyString(client);
3512 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
3513 Py_DECREF(so);
3514 Py_DECREF(s1);
3515 Py_DECREF(s2);
3516 if (ro) {
3517 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
3518 rval = *ptr;
3519 Py_DECREF(ro);
3520 }
3521 }
3522 wxPyEndBlockThreads(blocked);
3523 return rval;
3524 }
3525
3526 PYPRIVATE;
3527 };
3528
3529 SWIGINTERN void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
3530
3531
3532
3533 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
3534 PyObject* ret = PyTuple_New(3);
3535 if (ret) {
3536 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
3537 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
3538 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
3539 }
3540 return ret;
3541 }
3542
3543 SWIGINTERN PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
3544 bool cont;
3545 long index = 0;
3546 wxString value;
3547
3548 cont = self->GetFirstGroup(value, index);
3549 return __EnumerationHelper(cont, value, index);
3550 }
3551 SWIGINTERN PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
3552 bool cont;
3553 wxString value;
3554
3555 cont = self->GetNextGroup(value, index);
3556 return __EnumerationHelper(cont, value, index);
3557 }
3558 SWIGINTERN PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
3559 bool cont;
3560 long index = 0;
3561 wxString value;
3562
3563 cont = self->GetFirstEntry(value, index);
3564 return __EnumerationHelper(cont, value, index);
3565 }
3566 SWIGINTERN PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
3567 bool cont;
3568 wxString value;
3569
3570 cont = self->GetNextEntry(value, index);
3571 return __EnumerationHelper(cont, value, index);
3572 }
3573 SWIGINTERN long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
3574 long rv;
3575 self->Read(key, &rv, defaultVal);
3576 return rv;
3577 }
3578
3579 SWIGINTERN int
3580 SWIG_AsVal_double (PyObject *obj, double* val)
3581 {
3582 if (PyNumber_Check(obj)) {
3583 if (val) *val = PyFloat_AsDouble(obj);
3584 return SWIG_OK;
3585 }
3586 return SWIG_TypeError;
3587 }
3588
3589 SWIGINTERN double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
3590 double rv;
3591 self->Read(key, &rv, defaultVal);
3592 return rv;
3593 }
3594
3595 #define SWIG_From_double PyFloat_FromDouble
3596
3597 SWIGINTERN bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
3598 bool rv;
3599 self->Read(key, &rv, defaultVal);
3600 return rv;
3601 }
3602
3603 #include <wx/datetime.h>
3604
3605 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
3606 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
3607
3608 #define LOCAL_TZ wxDateTime::Local
3609
3610 SWIGINTERN PyObject *wxDateTime_GetAmPmStrings(){
3611 wxString am;
3612 wxString pm;
3613 wxDateTime::GetAmPmStrings(&am, &pm);
3614 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3615 PyObject* tup = PyTuple_New(2);
3616 PyTuple_SET_ITEM(tup, 0, wx2PyString(am));
3617 PyTuple_SET_ITEM(tup, 1, wx2PyString(pm));
3618 wxPyEndBlockThreads(blocked);
3619 return tup;
3620 }
3621
3622 SWIGINTERNINLINE PyObject *
3623 SWIG_From_unsigned_SS_int (unsigned int value)
3624 {
3625 return SWIG_From_unsigned_SS_long (value);
3626 }
3627
3628 SWIGINTERN wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
3629 SWIGINTERN wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
3630 SWIGINTERN wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
3631 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
3632 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
3633 SWIGINTERN bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
3634 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
3635 return (*self < *other);
3636 }
3637 SWIGINTERN bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
3638 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
3639 return (*self <= *other);
3640 }
3641 SWIGINTERN bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
3642 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
3643 return (*self > *other);
3644 }
3645 SWIGINTERN bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
3646 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
3647 return (*self >= *other);
3648 }
3649 SWIGINTERN bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
3650 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
3651 return (*self == *other);
3652 }
3653 SWIGINTERN bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
3654 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
3655 return (*self != *other);
3656 }
3657 SWIGINTERN int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
3658 const wxChar* rv;
3659 const wxChar* _date = date;
3660 rv = self->ParseRfc822Date(_date);
3661 if (rv == NULL) return -1;
3662 return rv - _date;
3663 }
3664 SWIGINTERN int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
3665 const wxChar* rv;
3666 const wxChar* _date = date;
3667 rv = self->ParseFormat(_date, format, dateDef);
3668 if (rv == NULL) return -1;
3669 return rv - _date;
3670 }
3671 SWIGINTERN int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
3672 const wxChar* rv;
3673 const wxChar* _datetime = datetime;
3674 rv = self->ParseDateTime(_datetime);
3675 if (rv == NULL) return -1;
3676 return rv - _datetime;
3677 }
3678 SWIGINTERN int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
3679 const wxChar* rv;
3680 const wxChar* _date = date;
3681 rv = self->ParseDate(_date);
3682 if (rv == NULL) return -1;
3683 return rv - _date;
3684 }
3685 SWIGINTERN int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
3686 const wxChar* rv;
3687 const wxChar* _time = time;
3688 rv = self->ParseTime(_time);
3689 if (rv == NULL) return -1;
3690 return rv - _time;
3691 }
3692 SWIGINTERN wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
3693 SWIGINTERN wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
3694 SWIGINTERN wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
3695 SWIGINTERN wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
3696 SWIGINTERN bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
3697 SWIGINTERN bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
3698 SWIGINTERN bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
3699 SWIGINTERN bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
3700 SWIGINTERN bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
3701 SWIGINTERN bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
3702 SWIGINTERN wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
3703 SWIGINTERN wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
3704 SWIGINTERN wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
3705 SWIGINTERN wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
3706 SWIGINTERN bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
3707 SWIGINTERN bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
3708
3709 #include <wx/dataobj.h>
3710
3711 SWIGINTERN PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
3712 size_t count = self->GetFormatCount(dir);
3713 wxDataFormat* formats = new wxDataFormat[count];
3714 self->GetAllFormats(formats, dir);
3715
3716 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3717 PyObject* list = PyList_New(count);
3718 for (size_t i=0; i<count; i++) {
3719 wxDataFormat* format = new wxDataFormat(formats[i]);
3720 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
3721 PyList_SET_ITEM(list, i, obj); // PyList_SET_ITEM steals a reference
3722 }
3723 wxPyEndBlockThreads(blocked);
3724 delete [] formats;
3725 return list;
3726 }
3727 SWIGINTERN PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
3728 PyObject* rval = NULL;
3729 size_t size = self->GetDataSize(format);
3730 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3731 if (size) {
3732 char* buf = new char[size];
3733 if (self->GetDataHere(format, buf))
3734 rval = PyString_FromStringAndSize(buf, size);
3735 delete [] buf;
3736 }
3737 if (! rval) {
3738 rval = Py_None;
3739 Py_INCREF(rval);
3740 }
3741 wxPyEndBlockThreads(blocked);
3742 return rval;
3743 }
3744 SWIGINTERN bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
3745 bool rval;
3746 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3747 if (PyString_Check(data)) {
3748 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
3749 }
3750 else {
3751 // raise a TypeError if not a string
3752 PyErr_SetString(PyExc_TypeError, "String expected.");
3753 rval = false;
3754 }
3755 wxPyEndBlockThreads(blocked);
3756 return rval;
3757 }
3758 SWIGINTERN PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
3759 PyObject* rval = NULL;
3760 size_t size = self->GetDataSize();
3761 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3762 if (size) {
3763 char* buf = new char[size];
3764 if (self->GetDataHere(buf))
3765 rval = PyString_FromStringAndSize(buf, size);
3766 delete [] buf;
3767 }
3768 if (! rval) {
3769 rval = Py_None;
3770 Py_INCREF(rval);
3771 }
3772 wxPyEndBlockThreads(blocked);
3773 return rval;
3774 }
3775 SWIGINTERN bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
3776 bool rval;
3777 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3778 if (PyString_Check(data)) {
3779 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3780 }
3781 else {
3782 // raise a TypeError if not a string
3783 PyErr_SetString(PyExc_TypeError, "String expected.");
3784 rval = false;
3785 }
3786 wxPyEndBlockThreads(blocked);
3787 return rval;
3788 }
3789 // Create a new class for wxPython to use
3790 class wxPyDataObjectSimple : public wxDataObjectSimple {
3791 public:
3792 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
3793 : wxDataObjectSimple(format) {}
3794
3795 DEC_PYCALLBACK_SIZET__const(GetDataSize);
3796 bool GetDataHere(void *buf) const;
3797 bool SetData(size_t len, const void *buf) const;
3798 PYPRIVATE;
3799 };
3800
3801 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
3802
3803 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
3804 // We need to get the data for this object and write it to buf. I think
3805 // the best way to do this for wxPython is to have the Python method
3806 // return either a string or None and then act appropriately with the
3807 // C++ version.
3808
3809 bool rval = false;
3810 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3811 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
3812 PyObject* ro;
3813 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3814 if (ro) {
3815 rval = (ro != Py_None && PyString_Check(ro));
3816 if (rval)
3817 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
3818 Py_DECREF(ro);
3819 }
3820 }
3821 wxPyEndBlockThreads(blocked);
3822 return rval;
3823 }
3824
3825 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) const{
3826 // For this one we simply need to make a string from buf and len
3827 // and send it to the Python method.
3828 bool rval = false;
3829 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3830 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
3831 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
3832 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
3833 Py_DECREF(data);
3834 }
3835 wxPyEndBlockThreads(blocked);
3836 return rval;
3837 }
3838
3839 // Create a new class for wxPython to use
3840 class wxPyTextDataObject : public wxTextDataObject {
3841 public:
3842 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
3843 : wxTextDataObject(text) {}
3844
3845 DEC_PYCALLBACK_SIZET__const(GetTextLength);
3846 DEC_PYCALLBACK_STRING__const(GetText);
3847 DEC_PYCALLBACK__STRING(SetText);
3848 PYPRIVATE;
3849 };
3850
3851 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
3852 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
3853 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
3854
3855
3856 // Create a new class for wxPython to use
3857 class wxPyBitmapDataObject : public wxBitmapDataObject {
3858 public:
3859 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
3860 : wxBitmapDataObject(bitmap) {}
3861
3862 wxBitmap GetBitmap() const;
3863 void SetBitmap(const wxBitmap& bitmap);
3864 PYPRIVATE;
3865 };
3866
3867 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
3868 wxBitmap* rval = &wxNullBitmap;
3869 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3870 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
3871 PyObject* ro;
3872 wxBitmap* ptr;
3873 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3874 if (ro) {
3875 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
3876 rval = ptr;
3877 Py_DECREF(ro);
3878 }
3879 }
3880 wxPyEndBlockThreads(blocked);
3881 return *rval;
3882 }
3883
3884 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
3885 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3886 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
3887 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
3888 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
3889 Py_DECREF(bo);
3890 }
3891 wxPyEndBlockThreads(blocked);
3892 }
3893
3894 SWIGINTERN wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
3895 return new wxCustomDataObject(wxDataFormat(formatName));
3896 }
3897 SWIGINTERN bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
3898 bool rval;
3899 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3900 if (PyString_Check(data)) {
3901 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3902 }
3903 else {
3904 // raise a TypeError if not a string
3905 PyErr_SetString(PyExc_TypeError, "String expected.");
3906 rval = false;
3907 }
3908 wxPyEndBlockThreads(blocked);
3909 return rval;
3910 }
3911 SWIGINTERN PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
3912 PyObject* obj;
3913 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3914 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
3915 wxPyEndBlockThreads(blocked);
3916 return obj;
3917 }
3918
3919 #include <wx/metafile.h>
3920
3921
3922 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
3923
3924
3925 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
3926 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
3927 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
3928 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
3929 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
3930
3931
3932 class wxPyTextDropTarget : public wxTextDropTarget {
3933 public:
3934 wxPyTextDropTarget() {}
3935
3936 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
3937
3938 DEC_PYCALLBACK__(OnLeave);
3939 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3940 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3941 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3942 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3943
3944 PYPRIVATE;
3945 };
3946
3947 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
3948 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
3949 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
3950 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
3951 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
3952 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
3953
3954
3955
3956 class wxPyFileDropTarget : public wxFileDropTarget {
3957 public:
3958 wxPyFileDropTarget() {}
3959
3960 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
3961
3962 DEC_PYCALLBACK__(OnLeave);
3963 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3964 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3965 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3966 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3967
3968 PYPRIVATE;
3969 };
3970
3971 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
3972 const wxArrayString& filenames) {
3973 bool rval = false;
3974 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3975 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
3976 PyObject* list = wxArrayString2PyList_helper(filenames);
3977 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
3978 Py_DECREF(list);
3979 }
3980 wxPyEndBlockThreads(blocked);
3981 return rval;
3982 }
3983
3984
3985
3986 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
3987 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
3988 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
3989 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
3990 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
3991
3992
3993
3994
3995 SWIGINTERN bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
3996
3997 #include <wx/display.h>
3998
3999 SWIGINTERN bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
4000 SWIGINTERN bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
4001
4002 #if !wxUSE_DISPLAY
4003 const wxVideoMode wxDefaultVideoMode;
4004 #endif
4005
4006 SWIGINTERN PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4007 #if wxUSE_DISPLAY
4008 PyObject* pyList = NULL;
4009 wxArrayVideoModes arr = self->GetModes(mode);
4010 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4011 pyList = PyList_New(0);
4012 for (size_t i=0; i < arr.GetCount(); i++)
4013 {
4014 wxVideoMode* m = new wxVideoMode(arr.Item(i));
4015 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
4016 PyList_Append(pyList, pyObj);
4017 Py_DECREF(pyObj);
4018 }
4019 wxPyEndBlockThreads(blocked);
4020 return pyList;
4021 #else
4022 wxPyRaiseNotImplemented();
4023 return NULL;
4024 #endif
4025 }
4026 SWIGINTERN wxVideoMode wxDisplay_GetCurrentMode(wxDisplay const *self){
4027 #if wxUSE_DISPLAY
4028 return self->GetCurrentMode();
4029 #else
4030 wxPyRaiseNotImplemented();
4031 return wxDefaultVideoMode;
4032 #endif
4033 }
4034 SWIGINTERN bool wxDisplay_ChangeMode(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4035 #if wxUSE_DISPLAY
4036 return self->ChangeMode(mode);
4037 #else
4038 wxPyRaiseNotImplemented();
4039 return false;
4040 #endif
4041 }
4042 SWIGINTERN void wxDisplay_ResetMode(wxDisplay *self){
4043 #if wxUSE_DISPLAY
4044 self->ResetMode();
4045 #else
4046 wxPyRaiseNotImplemented();
4047 #endif
4048 }
4049
4050 #include <wx/stdpaths.h>
4051
4052 SWIGINTERN wxStandardPaths *wxStandardPaths_Get(){
4053 return (wxStandardPaths*) &wxStandardPaths::Get();
4054 }
4055 SWIGINTERN void wxStandardPaths_SetInstallPrefix(wxStandardPaths *self,wxString const &prefix){}
4056 SWIGINTERN wxString wxStandardPaths_GetInstallPrefix(wxStandardPaths *self){ return wxEmptyString; }
4057 #ifdef __cplusplus
4058 extern "C" {
4059 #endif
4060 SWIGINTERN PyObject *_wrap_SystemSettings_GetColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4061 PyObject *resultobj = 0;
4062 wxSystemColour arg1 ;
4063 wxColour result;
4064 int val1 ;
4065 int ecode1 = 0 ;
4066 PyObject * obj0 = 0 ;
4067 char * kwnames[] = {
4068 (char *) "index", NULL
4069 };
4070
4071 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) SWIG_fail;
4072 ecode1 = SWIG_AsVal_int(obj0, &val1);
4073 if (!SWIG_IsOK(ecode1)) {
4074 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetColour" "', expected argument " "1"" of type '" "wxSystemColour""'");
4075 }
4076 arg1 = static_cast< wxSystemColour >(val1);
4077 {
4078 if (!wxPyCheckForApp()) SWIG_fail;
4079 PyThreadState* __tstate = wxPyBeginAllowThreads();
4080 result = wxSystemSettings::GetColour(arg1);
4081 wxPyEndAllowThreads(__tstate);
4082 if (PyErr_Occurred()) SWIG_fail;
4083 }
4084 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
4085 return resultobj;
4086 fail:
4087 return NULL;
4088 }
4089
4090
4091 SWIGINTERN PyObject *_wrap_SystemSettings_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4092 PyObject *resultobj = 0;
4093 wxSystemFont arg1 ;
4094 wxFont result;
4095 int val1 ;
4096 int ecode1 = 0 ;
4097 PyObject * obj0 = 0 ;
4098 char * kwnames[] = {
4099 (char *) "index", NULL
4100 };
4101
4102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) SWIG_fail;
4103 ecode1 = SWIG_AsVal_int(obj0, &val1);
4104 if (!SWIG_IsOK(ecode1)) {
4105 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetFont" "', expected argument " "1"" of type '" "wxSystemFont""'");
4106 }
4107 arg1 = static_cast< wxSystemFont >(val1);
4108 {
4109 if (!wxPyCheckForApp()) SWIG_fail;
4110 PyThreadState* __tstate = wxPyBeginAllowThreads();
4111 result = wxSystemSettings::GetFont(arg1);
4112 wxPyEndAllowThreads(__tstate);
4113 if (PyErr_Occurred()) SWIG_fail;
4114 }
4115 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
4116 return resultobj;
4117 fail:
4118 return NULL;
4119 }
4120
4121
4122 SWIGINTERN PyObject *_wrap_SystemSettings_GetMetric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4123 PyObject *resultobj = 0;
4124 wxSystemMetric arg1 ;
4125 wxWindow *arg2 = (wxWindow *) NULL ;
4126 int result;
4127 int val1 ;
4128 int ecode1 = 0 ;
4129 void *argp2 = 0 ;
4130 int res2 = 0 ;
4131 PyObject * obj0 = 0 ;
4132 PyObject * obj1 = 0 ;
4133 char * kwnames[] = {
4134 (char *) "index",(char *) "win", NULL
4135 };
4136
4137 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SystemSettings_GetMetric",kwnames,&obj0,&obj1)) SWIG_fail;
4138 ecode1 = SWIG_AsVal_int(obj0, &val1);
4139 if (!SWIG_IsOK(ecode1)) {
4140 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetMetric" "', expected argument " "1"" of type '" "wxSystemMetric""'");
4141 }
4142 arg1 = static_cast< wxSystemMetric >(val1);
4143 if (obj1) {
4144 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
4145 if (!SWIG_IsOK(res2)) {
4146 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SystemSettings_GetMetric" "', expected argument " "2"" of type '" "wxWindow *""'");
4147 }
4148 arg2 = reinterpret_cast< wxWindow * >(argp2);
4149 }
4150 {
4151 if (!wxPyCheckForApp()) SWIG_fail;
4152 PyThreadState* __tstate = wxPyBeginAllowThreads();
4153 result = (int)wxSystemSettings::GetMetric(arg1,arg2);
4154 wxPyEndAllowThreads(__tstate);
4155 if (PyErr_Occurred()) SWIG_fail;
4156 }
4157 resultobj = SWIG_From_int(static_cast< int >(result));
4158 return resultobj;
4159 fail:
4160 return NULL;
4161 }
4162
4163
4164 SWIGINTERN PyObject *_wrap_SystemSettings_HasFeature(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4165 PyObject *resultobj = 0;
4166 wxSystemFeature arg1 ;
4167 bool result;
4168 int val1 ;
4169 int ecode1 = 0 ;
4170 PyObject * obj0 = 0 ;
4171 char * kwnames[] = {
4172 (char *) "index", NULL
4173 };
4174
4175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) SWIG_fail;
4176 ecode1 = SWIG_AsVal_int(obj0, &val1);
4177 if (!SWIG_IsOK(ecode1)) {
4178 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_HasFeature" "', expected argument " "1"" of type '" "wxSystemFeature""'");
4179 }
4180 arg1 = static_cast< wxSystemFeature >(val1);
4181 {
4182 if (!wxPyCheckForApp()) SWIG_fail;
4183 PyThreadState* __tstate = wxPyBeginAllowThreads();
4184 result = (bool)wxSystemSettings::HasFeature(arg1);
4185 wxPyEndAllowThreads(__tstate);
4186 if (PyErr_Occurred()) SWIG_fail;
4187 }
4188 {
4189 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4190 }
4191 return resultobj;
4192 fail:
4193 return NULL;
4194 }
4195
4196
4197 SWIGINTERN PyObject *_wrap_SystemSettings_GetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4198 PyObject *resultobj = 0;
4199 wxSystemScreenType result;
4200
4201 if (!SWIG_Python_UnpackTuple(args,"SystemSettings_GetScreenType",0,0,0)) SWIG_fail;
4202 {
4203 if (!wxPyCheckForApp()) SWIG_fail;
4204 PyThreadState* __tstate = wxPyBeginAllowThreads();
4205 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
4206 wxPyEndAllowThreads(__tstate);
4207 if (PyErr_Occurred()) SWIG_fail;
4208 }
4209 resultobj = SWIG_From_int(static_cast< int >(result));
4210 return resultobj;
4211 fail:
4212 return NULL;
4213 }
4214
4215
4216 SWIGINTERN PyObject *_wrap_SystemSettings_SetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4217 PyObject *resultobj = 0;
4218 wxSystemScreenType arg1 ;
4219 int val1 ;
4220 int ecode1 = 0 ;
4221 PyObject * obj0 = 0 ;
4222 char * kwnames[] = {
4223 (char *) "screen", NULL
4224 };
4225
4226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) SWIG_fail;
4227 ecode1 = SWIG_AsVal_int(obj0, &val1);
4228 if (!SWIG_IsOK(ecode1)) {
4229 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_SetScreenType" "', expected argument " "1"" of type '" "wxSystemScreenType""'");
4230 }
4231 arg1 = static_cast< wxSystemScreenType >(val1);
4232 {
4233 if (!wxPyCheckForApp()) SWIG_fail;
4234 PyThreadState* __tstate = wxPyBeginAllowThreads();
4235 wxSystemSettings::SetScreenType(arg1);
4236 wxPyEndAllowThreads(__tstate);
4237 if (PyErr_Occurred()) SWIG_fail;
4238 }
4239 resultobj = SWIG_Py_Void();
4240 return resultobj;
4241 fail:
4242 return NULL;
4243 }
4244
4245
4246 SWIGINTERN PyObject *SystemSettings_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4247 PyObject *obj;
4248 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4249 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemSettings, SWIG_NewClientData(obj));
4250 return SWIG_Py_Void();
4251 }
4252
4253 SWIGINTERN int WINDOW_DEFAULT_VARIANT_set(PyObject *) {
4254 SWIG_Error(SWIG_AttributeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
4255 return 1;
4256 }
4257
4258
4259 SWIGINTERN PyObject *WINDOW_DEFAULT_VARIANT_get(void) {
4260 PyObject *pyobj = 0;
4261
4262 {
4263 #if wxUSE_UNICODE
4264 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4265 #else
4266 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4267 #endif
4268 }
4269 return pyobj;
4270 }
4271
4272
4273 SWIGINTERN PyObject *_wrap_new_SystemOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4274 PyObject *resultobj = 0;
4275 wxSystemOptions *result = 0 ;
4276
4277 if (!SWIG_Python_UnpackTuple(args,"new_SystemOptions",0,0,0)) SWIG_fail;
4278 {
4279 PyThreadState* __tstate = wxPyBeginAllowThreads();
4280 result = (wxSystemOptions *)new wxSystemOptions();
4281 wxPyEndAllowThreads(__tstate);
4282 if (PyErr_Occurred()) SWIG_fail;
4283 }
4284 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSystemOptions, SWIG_POINTER_NEW | 0 );
4285 return resultobj;
4286 fail:
4287 return NULL;
4288 }
4289
4290
4291 SWIGINTERN PyObject *_wrap_SystemOptions_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4292 PyObject *resultobj = 0;
4293 wxString *arg1 = 0 ;
4294 wxString *arg2 = 0 ;
4295 bool temp1 = false ;
4296 bool temp2 = false ;
4297 PyObject * obj0 = 0 ;
4298 PyObject * obj1 = 0 ;
4299 char * kwnames[] = {
4300 (char *) "name",(char *) "value", NULL
4301 };
4302
4303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) SWIG_fail;
4304 {
4305 arg1 = wxString_in_helper(obj0);
4306 if (arg1 == NULL) SWIG_fail;
4307 temp1 = true;
4308 }
4309 {
4310 arg2 = wxString_in_helper(obj1);
4311 if (arg2 == NULL) SWIG_fail;
4312 temp2 = true;
4313 }
4314 {
4315 PyThreadState* __tstate = wxPyBeginAllowThreads();
4316 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
4317 wxPyEndAllowThreads(__tstate);
4318 if (PyErr_Occurred()) SWIG_fail;
4319 }
4320 resultobj = SWIG_Py_Void();
4321 {
4322 if (temp1)
4323 delete arg1;
4324 }
4325 {
4326 if (temp2)
4327 delete arg2;
4328 }
4329 return resultobj;
4330 fail:
4331 {
4332 if (temp1)
4333 delete arg1;
4334 }
4335 {
4336 if (temp2)
4337 delete arg2;
4338 }
4339 return NULL;
4340 }
4341
4342
4343 SWIGINTERN PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4344 PyObject *resultobj = 0;
4345 wxString *arg1 = 0 ;
4346 int arg2 ;
4347 bool temp1 = false ;
4348 int val2 ;
4349 int ecode2 = 0 ;
4350 PyObject * obj0 = 0 ;
4351 PyObject * obj1 = 0 ;
4352 char * kwnames[] = {
4353 (char *) "name",(char *) "value", NULL
4354 };
4355
4356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
4357 {
4358 arg1 = wxString_in_helper(obj0);
4359 if (arg1 == NULL) SWIG_fail;
4360 temp1 = true;
4361 }
4362 ecode2 = SWIG_AsVal_int(obj1, &val2);
4363 if (!SWIG_IsOK(ecode2)) {
4364 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SystemOptions_SetOptionInt" "', expected argument " "2"" of type '" "int""'");
4365 }
4366 arg2 = static_cast< int >(val2);
4367 {
4368 PyThreadState* __tstate = wxPyBeginAllowThreads();
4369 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
4370 wxPyEndAllowThreads(__tstate);
4371 if (PyErr_Occurred()) SWIG_fail;
4372 }
4373 resultobj = SWIG_Py_Void();
4374 {
4375 if (temp1)
4376 delete arg1;
4377 }
4378 return resultobj;
4379 fail:
4380 {
4381 if (temp1)
4382 delete arg1;
4383 }
4384 return NULL;
4385 }
4386
4387
4388 SWIGINTERN PyObject *_wrap_SystemOptions_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4389 PyObject *resultobj = 0;
4390 wxString *arg1 = 0 ;
4391 wxString result;
4392 bool temp1 = false ;
4393 PyObject * obj0 = 0 ;
4394 char * kwnames[] = {
4395 (char *) "name", NULL
4396 };
4397
4398 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) SWIG_fail;
4399 {
4400 arg1 = wxString_in_helper(obj0);
4401 if (arg1 == NULL) SWIG_fail;
4402 temp1 = true;
4403 }
4404 {
4405 PyThreadState* __tstate = wxPyBeginAllowThreads();
4406 result = wxSystemOptions::GetOption((wxString const &)*arg1);
4407 wxPyEndAllowThreads(__tstate);
4408 if (PyErr_Occurred()) SWIG_fail;
4409 }
4410 {
4411 #if wxUSE_UNICODE
4412 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4413 #else
4414 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4415 #endif
4416 }
4417 {
4418 if (temp1)
4419 delete arg1;
4420 }
4421 return resultobj;
4422 fail:
4423 {
4424 if (temp1)
4425 delete arg1;
4426 }
4427 return NULL;
4428 }
4429
4430
4431 SWIGINTERN PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4432 PyObject *resultobj = 0;
4433 wxString *arg1 = 0 ;
4434 int result;
4435 bool temp1 = false ;
4436 PyObject * obj0 = 0 ;
4437 char * kwnames[] = {
4438 (char *) "name", NULL
4439 };
4440
4441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) SWIG_fail;
4442 {
4443 arg1 = wxString_in_helper(obj0);
4444 if (arg1 == NULL) SWIG_fail;
4445 temp1 = true;
4446 }
4447 {
4448 PyThreadState* __tstate = wxPyBeginAllowThreads();
4449 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
4450 wxPyEndAllowThreads(__tstate);
4451 if (PyErr_Occurred()) SWIG_fail;
4452 }
4453 resultobj = SWIG_From_int(static_cast< int >(result));
4454 {
4455 if (temp1)
4456 delete arg1;
4457 }
4458 return resultobj;
4459 fail:
4460 {
4461 if (temp1)
4462 delete arg1;
4463 }
4464 return NULL;
4465 }
4466
4467
4468 SWIGINTERN PyObject *_wrap_SystemOptions_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4469 PyObject *resultobj = 0;
4470 wxString *arg1 = 0 ;
4471 bool result;
4472 bool temp1 = false ;
4473 PyObject * obj0 = 0 ;
4474 char * kwnames[] = {
4475 (char *) "name", NULL
4476 };
4477
4478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) SWIG_fail;
4479 {
4480 arg1 = wxString_in_helper(obj0);
4481 if (arg1 == NULL) SWIG_fail;
4482 temp1 = true;
4483 }
4484 {
4485 PyThreadState* __tstate = wxPyBeginAllowThreads();
4486 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
4487 wxPyEndAllowThreads(__tstate);
4488 if (PyErr_Occurred()) SWIG_fail;
4489 }
4490 {
4491 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4492 }
4493 {
4494 if (temp1)
4495 delete arg1;
4496 }
4497 return resultobj;
4498 fail:
4499 {
4500 if (temp1)
4501 delete arg1;
4502 }
4503 return NULL;
4504 }
4505
4506
4507 SWIGINTERN PyObject *_wrap_SystemOptions_IsFalse(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4508 PyObject *resultobj = 0;
4509 wxString *arg1 = 0 ;
4510 bool result;
4511 bool temp1 = false ;
4512 PyObject * obj0 = 0 ;
4513 char * kwnames[] = {
4514 (char *) "name", NULL
4515 };
4516
4517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_IsFalse",kwnames,&obj0)) SWIG_fail;
4518 {
4519 arg1 = wxString_in_helper(obj0);
4520 if (arg1 == NULL) SWIG_fail;
4521 temp1 = true;
4522 }
4523 {
4524 PyThreadState* __tstate = wxPyBeginAllowThreads();
4525 result = (bool)wxSystemOptions::IsFalse((wxString const &)*arg1);
4526 wxPyEndAllowThreads(__tstate);
4527 if (PyErr_Occurred()) SWIG_fail;
4528 }
4529 {
4530 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4531 }
4532 {
4533 if (temp1)
4534 delete arg1;
4535 }
4536 return resultobj;
4537 fail:
4538 {
4539 if (temp1)
4540 delete arg1;
4541 }
4542 return NULL;
4543 }
4544
4545
4546 SWIGINTERN PyObject *SystemOptions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4547 PyObject *obj;
4548 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4549 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemOptions, SWIG_NewClientData(obj));
4550 return SWIG_Py_Void();
4551 }
4552
4553 SWIGINTERN PyObject *SystemOptions_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4554 return SWIG_Python_InitShadowInstance(args);
4555 }
4556
4557 SWIGINTERN int FileSelectorPromptStr_set(PyObject *) {
4558 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorPromptStr is read-only.");
4559 return 1;
4560 }
4561
4562
4563 SWIGINTERN PyObject *FileSelectorPromptStr_get(void) {
4564 PyObject *pyobj = 0;
4565
4566 {
4567 #if wxUSE_UNICODE
4568 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4569 #else
4570 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4571 #endif
4572 }
4573 return pyobj;
4574 }
4575
4576
4577 SWIGINTERN int FileSelectorDefaultWildcardStr_set(PyObject *) {
4578 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
4579 return 1;
4580 }
4581
4582
4583 SWIGINTERN PyObject *FileSelectorDefaultWildcardStr_get(void) {
4584 PyObject *pyobj = 0;
4585
4586 {
4587 #if wxUSE_UNICODE
4588 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4589 #else
4590 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4591 #endif
4592 }
4593 return pyobj;
4594 }
4595
4596
4597 SWIGINTERN int DirSelectorPromptStr_set(PyObject *) {
4598 SWIG_Error(SWIG_AttributeError,"Variable DirSelectorPromptStr is read-only.");
4599 return 1;
4600 }
4601
4602
4603 SWIGINTERN PyObject *DirSelectorPromptStr_get(void) {
4604 PyObject *pyobj = 0;
4605
4606 {
4607 #if wxUSE_UNICODE
4608 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4609 #else
4610 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4611 #endif
4612 }
4613 return pyobj;
4614 }
4615
4616
4617 SWIGINTERN PyObject *_wrap_NewId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4618 PyObject *resultobj = 0;
4619 long result;
4620
4621 if (!SWIG_Python_UnpackTuple(args,"NewId",0,0,0)) SWIG_fail;
4622 {
4623 PyThreadState* __tstate = wxPyBeginAllowThreads();
4624 result = (long)wxNewId();
4625 wxPyEndAllowThreads(__tstate);
4626 if (PyErr_Occurred()) SWIG_fail;
4627 }
4628 resultobj = SWIG_From_long(static_cast< long >(result));
4629 return resultobj;
4630 fail:
4631 return NULL;
4632 }
4633
4634
4635 SWIGINTERN PyObject *_wrap_RegisterId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4636 PyObject *resultobj = 0;
4637 long arg1 ;
4638 long val1 ;
4639 int ecode1 = 0 ;
4640 PyObject * obj0 = 0 ;
4641 char * kwnames[] = {
4642 (char *) "id", NULL
4643 };
4644
4645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) SWIG_fail;
4646 ecode1 = SWIG_AsVal_long(obj0, &val1);
4647 if (!SWIG_IsOK(ecode1)) {
4648 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "RegisterId" "', expected argument " "1"" of type '" "long""'");
4649 }
4650 arg1 = static_cast< long >(val1);
4651 {
4652 PyThreadState* __tstate = wxPyBeginAllowThreads();
4653 wxRegisterId(arg1);
4654 wxPyEndAllowThreads(__tstate);
4655 if (PyErr_Occurred()) SWIG_fail;
4656 }
4657 resultobj = SWIG_Py_Void();
4658 return resultobj;
4659 fail:
4660 return NULL;
4661 }
4662
4663
4664 SWIGINTERN PyObject *_wrap_GetCurrentId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4665 PyObject *resultobj = 0;
4666 long result;
4667
4668 if (!SWIG_Python_UnpackTuple(args,"GetCurrentId",0,0,0)) SWIG_fail;
4669 {
4670 PyThreadState* __tstate = wxPyBeginAllowThreads();
4671 result = (long)wxGetCurrentId();
4672 wxPyEndAllowThreads(__tstate);
4673 if (PyErr_Occurred()) SWIG_fail;
4674 }
4675 resultobj = SWIG_From_long(static_cast< long >(result));
4676 return resultobj;
4677 fail:
4678 return NULL;
4679 }
4680
4681
4682 SWIGINTERN PyObject *_wrap_IsStockID(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4683 PyObject *resultobj = 0;
4684 int arg1 ;
4685 bool result;
4686 int val1 ;
4687 int ecode1 = 0 ;
4688 PyObject * obj0 = 0 ;
4689 char * kwnames[] = {
4690 (char *) "id", NULL
4691 };
4692
4693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) SWIG_fail;
4694 ecode1 = SWIG_AsVal_int(obj0, &val1);
4695 if (!SWIG_IsOK(ecode1)) {
4696 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockID" "', expected argument " "1"" of type '" "int""'");
4697 }
4698 arg1 = static_cast< int >(val1);
4699 {
4700 PyThreadState* __tstate = wxPyBeginAllowThreads();
4701 result = (bool)wxIsStockID(arg1);
4702 wxPyEndAllowThreads(__tstate);
4703 if (PyErr_Occurred()) SWIG_fail;
4704 }
4705 {
4706 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4707 }
4708 return resultobj;
4709 fail:
4710 return NULL;
4711 }
4712
4713
4714 SWIGINTERN PyObject *_wrap_IsStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4715 PyObject *resultobj = 0;
4716 int arg1 ;
4717 wxString *arg2 = 0 ;
4718 bool result;
4719 int val1 ;
4720 int ecode1 = 0 ;
4721 bool temp2 = false ;
4722 PyObject * obj0 = 0 ;
4723 PyObject * obj1 = 0 ;
4724 char * kwnames[] = {
4725 (char *) "id",(char *) "label", NULL
4726 };
4727
4728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) SWIG_fail;
4729 ecode1 = SWIG_AsVal_int(obj0, &val1);
4730 if (!SWIG_IsOK(ecode1)) {
4731 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockLabel" "', expected argument " "1"" of type '" "int""'");
4732 }
4733 arg1 = static_cast< int >(val1);
4734 {
4735 arg2 = wxString_in_helper(obj1);
4736 if (arg2 == NULL) SWIG_fail;
4737 temp2 = true;
4738 }
4739 {
4740 PyThreadState* __tstate = wxPyBeginAllowThreads();
4741 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
4742 wxPyEndAllowThreads(__tstate);
4743 if (PyErr_Occurred()) SWIG_fail;
4744 }
4745 {
4746 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4747 }
4748 {
4749 if (temp2)
4750 delete arg2;
4751 }
4752 return resultobj;
4753 fail:
4754 {
4755 if (temp2)
4756 delete arg2;
4757 }
4758 return NULL;
4759 }
4760
4761
4762 SWIGINTERN PyObject *_wrap_GetStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4763 PyObject *resultobj = 0;
4764 int arg1 ;
4765 bool arg2 = (bool) true ;
4766 wxString arg3 = (wxString) wxPyEmptyString ;
4767 wxString result;
4768 int val1 ;
4769 int ecode1 = 0 ;
4770 bool val2 ;
4771 int ecode2 = 0 ;
4772 PyObject * obj0 = 0 ;
4773 PyObject * obj1 = 0 ;
4774 PyObject * obj2 = 0 ;
4775 char * kwnames[] = {
4776 (char *) "id",(char *) "withCodes",(char *) "accelerator", NULL
4777 };
4778
4779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GetStockLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4780 ecode1 = SWIG_AsVal_int(obj0, &val1);
4781 if (!SWIG_IsOK(ecode1)) {
4782 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetStockLabel" "', expected argument " "1"" of type '" "int""'");
4783 }
4784 arg1 = static_cast< int >(val1);
4785 if (obj1) {
4786 ecode2 = SWIG_AsVal_bool(obj1, &val2);
4787 if (!SWIG_IsOK(ecode2)) {
4788 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetStockLabel" "', expected argument " "2"" of type '" "bool""'");
4789 }
4790 arg2 = static_cast< bool >(val2);
4791 }
4792 if (obj2) {
4793 {
4794 wxString* sptr = wxString_in_helper(obj2);
4795 if (sptr == NULL) SWIG_fail;
4796 arg3 = *sptr;
4797 delete sptr;
4798 }
4799 }
4800 {
4801 PyThreadState* __tstate = wxPyBeginAllowThreads();
4802 result = wxGetStockLabel(arg1,arg2,arg3);
4803 wxPyEndAllowThreads(__tstate);
4804 if (PyErr_Occurred()) SWIG_fail;
4805 }
4806 {
4807 #if wxUSE_UNICODE
4808 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4809 #else
4810 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4811 #endif
4812 }
4813 return resultobj;
4814 fail:
4815 return NULL;
4816 }
4817
4818
4819 SWIGINTERN PyObject *_wrap_Bell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4820 PyObject *resultobj = 0;
4821
4822 if (!SWIG_Python_UnpackTuple(args,"Bell",0,0,0)) SWIG_fail;
4823 {
4824 if (!wxPyCheckForApp()) SWIG_fail;
4825 PyThreadState* __tstate = wxPyBeginAllowThreads();
4826 wxBell();
4827 wxPyEndAllowThreads(__tstate);
4828 if (PyErr_Occurred()) SWIG_fail;
4829 }
4830 resultobj = SWIG_Py_Void();
4831 return resultobj;
4832 fail:
4833 return NULL;
4834 }
4835
4836
4837 SWIGINTERN PyObject *_wrap_EndBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4838 PyObject *resultobj = 0;
4839
4840 if (!SWIG_Python_UnpackTuple(args,"EndBusyCursor",0,0,0)) SWIG_fail;
4841 {
4842 if (!wxPyCheckForApp()) SWIG_fail;
4843 PyThreadState* __tstate = wxPyBeginAllowThreads();
4844 wxEndBusyCursor();
4845 wxPyEndAllowThreads(__tstate);
4846 if (PyErr_Occurred()) SWIG_fail;
4847 }
4848 resultobj = SWIG_Py_Void();
4849 return resultobj;
4850 fail:
4851 return NULL;
4852 }
4853
4854
4855 SWIGINTERN PyObject *_wrap_GetElapsedTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4856 PyObject *resultobj = 0;
4857 bool arg1 = (bool) true ;
4858 long result;
4859 bool val1 ;
4860 int ecode1 = 0 ;
4861 PyObject * obj0 = 0 ;
4862 char * kwnames[] = {
4863 (char *) "resetTimer", NULL
4864 };
4865
4866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) SWIG_fail;
4867 if (obj0) {
4868 ecode1 = SWIG_AsVal_bool(obj0, &val1);
4869 if (!SWIG_IsOK(ecode1)) {
4870 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetElapsedTime" "', expected argument " "1"" of type '" "bool""'");
4871 }
4872 arg1 = static_cast< bool >(val1);
4873 }
4874 {
4875 PyThreadState* __tstate = wxPyBeginAllowThreads();
4876 result = (long)wxGetElapsedTime(arg1);
4877 wxPyEndAllowThreads(__tstate);
4878 if (PyErr_Occurred()) SWIG_fail;
4879 }
4880 resultobj = SWIG_From_long(static_cast< long >(result));
4881 return resultobj;
4882 fail:
4883 return NULL;
4884 }
4885
4886
4887 SWIGINTERN PyObject *_wrap_IsBusy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4888 PyObject *resultobj = 0;
4889 bool result;
4890
4891 if (!SWIG_Python_UnpackTuple(args,"IsBusy",0,0,0)) SWIG_fail;
4892 {
4893 PyThreadState* __tstate = wxPyBeginAllowThreads();
4894 result = (bool)wxIsBusy();
4895 wxPyEndAllowThreads(__tstate);
4896 if (PyErr_Occurred()) SWIG_fail;
4897 }
4898 {
4899 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4900 }
4901 return resultobj;
4902 fail:
4903 return NULL;
4904 }
4905
4906
4907 SWIGINTERN PyObject *_wrap_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4908 PyObject *resultobj = 0;
4909 wxString result;
4910
4911 if (!SWIG_Python_UnpackTuple(args,"Now",0,0,0)) SWIG_fail;
4912 {
4913 PyThreadState* __tstate = wxPyBeginAllowThreads();
4914 result = wxNow();
4915 wxPyEndAllowThreads(__tstate);
4916 if (PyErr_Occurred()) SWIG_fail;
4917 }
4918 {
4919 #if wxUSE_UNICODE
4920 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4921 #else
4922 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4923 #endif
4924 }
4925 return resultobj;
4926 fail:
4927 return NULL;
4928 }
4929
4930
4931 SWIGINTERN PyObject *_wrap_Shell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4932 PyObject *resultobj = 0;
4933 wxString const &arg1_defvalue = wxPyEmptyString ;
4934 wxString *arg1 = (wxString *) &arg1_defvalue ;
4935 bool result;
4936 bool temp1 = false ;
4937 PyObject * obj0 = 0 ;
4938 char * kwnames[] = {
4939 (char *) "command", NULL
4940 };
4941
4942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) SWIG_fail;
4943 if (obj0) {
4944 {
4945 arg1 = wxString_in_helper(obj0);
4946 if (arg1 == NULL) SWIG_fail;
4947 temp1 = true;
4948 }
4949 }
4950 {
4951 PyThreadState* __tstate = wxPyBeginAllowThreads();
4952 result = (bool)wxShell((wxString const &)*arg1);
4953 wxPyEndAllowThreads(__tstate);
4954 if (PyErr_Occurred()) SWIG_fail;
4955 }
4956 {
4957 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4958 }
4959 {
4960 if (temp1)
4961 delete arg1;
4962 }
4963 return resultobj;
4964 fail:
4965 {
4966 if (temp1)
4967 delete arg1;
4968 }
4969 return NULL;
4970 }
4971
4972
4973 SWIGINTERN PyObject *_wrap_StartTimer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4974 PyObject *resultobj = 0;
4975
4976 if (!SWIG_Python_UnpackTuple(args,"StartTimer",0,0,0)) SWIG_fail;
4977 {
4978 PyThreadState* __tstate = wxPyBeginAllowThreads();
4979 wxStartTimer();
4980 wxPyEndAllowThreads(__tstate);
4981 if (PyErr_Occurred()) SWIG_fail;
4982 }
4983 resultobj = SWIG_Py_Void();
4984 return resultobj;
4985 fail:
4986 return NULL;
4987 }
4988
4989
4990 SWIGINTERN PyObject *_wrap_GetOsVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4991 PyObject *resultobj = 0;
4992 int *arg1 = (int *) 0 ;
4993 int *arg2 = (int *) 0 ;
4994 int result;
4995 int temp1 ;
4996 int res1 = SWIG_TMPOBJ ;
4997 int temp2 ;
4998 int res2 = SWIG_TMPOBJ ;
4999
5000 arg1 = &temp1;
5001 arg2 = &temp2;
5002 if (!SWIG_Python_UnpackTuple(args,"GetOsVersion",0,0,0)) SWIG_fail;
5003 {
5004 PyThreadState* __tstate = wxPyBeginAllowThreads();
5005 result = (int)wxGetOsVersion(arg1,arg2);
5006 wxPyEndAllowThreads(__tstate);
5007 if (PyErr_Occurred()) SWIG_fail;
5008 }
5009 resultobj = SWIG_From_int(static_cast< int >(result));
5010 if (SWIG_IsTmpObj(res1)) {
5011 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
5012 } else {
5013 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5014 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
5015 }
5016 if (SWIG_IsTmpObj(res2)) {
5017 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
5018 } else {
5019 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5020 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
5021 }
5022 return resultobj;
5023 fail:
5024 return NULL;
5025 }
5026
5027
5028 SWIGINTERN PyObject *_wrap_GetOsDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5029 PyObject *resultobj = 0;
5030 wxString result;
5031
5032 if (!SWIG_Python_UnpackTuple(args,"GetOsDescription",0,0,0)) SWIG_fail;
5033 {
5034 PyThreadState* __tstate = wxPyBeginAllowThreads();
5035 result = wxGetOsDescription();
5036 wxPyEndAllowThreads(__tstate);
5037 if (PyErr_Occurred()) SWIG_fail;
5038 }
5039 {
5040 #if wxUSE_UNICODE
5041 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5042 #else
5043 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5044 #endif
5045 }
5046 return resultobj;
5047 fail:
5048 return NULL;
5049 }
5050
5051
5052 SWIGINTERN PyObject *_wrap_GetFreeMemory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5053 PyObject *resultobj = 0;
5054 wxMemorySize result;
5055
5056 if (!SWIG_Python_UnpackTuple(args,"GetFreeMemory",0,0,0)) SWIG_fail;
5057 {
5058 PyThreadState* __tstate = wxPyBeginAllowThreads();
5059 result = wxGetFreeMemory();
5060 wxPyEndAllowThreads(__tstate);
5061 if (PyErr_Occurred()) SWIG_fail;
5062 }
5063 resultobj = SWIG_NewPointerObj((new wxMemorySize(static_cast< const wxMemorySize& >(result))), SWIGTYPE_p_wxMemorySize, SWIG_POINTER_OWN | 0 );
5064 return resultobj;
5065 fail:
5066 return NULL;
5067 }
5068
5069
5070 SWIGINTERN PyObject *_wrap_Shutdown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5071 PyObject *resultobj = 0;
5072 wxShutdownFlags arg1 ;
5073 bool result;
5074 int val1 ;
5075 int ecode1 = 0 ;
5076 PyObject * obj0 = 0 ;
5077 char * kwnames[] = {
5078 (char *) "wFlags", NULL
5079 };
5080
5081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) SWIG_fail;
5082 ecode1 = SWIG_AsVal_int(obj0, &val1);
5083 if (!SWIG_IsOK(ecode1)) {
5084 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Shutdown" "', expected argument " "1"" of type '" "wxShutdownFlags""'");
5085 }
5086 arg1 = static_cast< wxShutdownFlags >(val1);
5087 {
5088 if (!wxPyCheckForApp()) SWIG_fail;
5089 PyThreadState* __tstate = wxPyBeginAllowThreads();
5090 result = (bool)wxShutdown(arg1);
5091 wxPyEndAllowThreads(__tstate);
5092 if (PyErr_Occurred()) SWIG_fail;
5093 }
5094 {
5095 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5096 }
5097 return resultobj;
5098 fail:
5099 return NULL;
5100 }
5101
5102
5103 SWIGINTERN PyObject *_wrap_Sleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5104 PyObject *resultobj = 0;
5105 int arg1 ;
5106 int val1 ;
5107 int ecode1 = 0 ;
5108 PyObject * obj0 = 0 ;
5109 char * kwnames[] = {
5110 (char *) "secs", NULL
5111 };
5112
5113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) SWIG_fail;
5114 ecode1 = SWIG_AsVal_int(obj0, &val1);
5115 if (!SWIG_IsOK(ecode1)) {
5116 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Sleep" "', expected argument " "1"" of type '" "int""'");
5117 }
5118 arg1 = static_cast< int >(val1);
5119 {
5120 PyThreadState* __tstate = wxPyBeginAllowThreads();
5121 wxSleep(arg1);
5122 wxPyEndAllowThreads(__tstate);
5123 if (PyErr_Occurred()) SWIG_fail;
5124 }
5125 resultobj = SWIG_Py_Void();
5126 return resultobj;
5127 fail:
5128 return NULL;
5129 }
5130
5131
5132 SWIGINTERN PyObject *_wrap_MilliSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5133 PyObject *resultobj = 0;
5134 unsigned long arg1 ;
5135 unsigned long val1 ;
5136 int ecode1 = 0 ;
5137 PyObject * obj0 = 0 ;
5138 char * kwnames[] = {
5139 (char *) "milliseconds", NULL
5140 };
5141
5142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) SWIG_fail;
5143 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5144 if (!SWIG_IsOK(ecode1)) {
5145 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MilliSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5146 }
5147 arg1 = static_cast< unsigned long >(val1);
5148 {
5149 PyThreadState* __tstate = wxPyBeginAllowThreads();
5150 wxMilliSleep(arg1);
5151 wxPyEndAllowThreads(__tstate);
5152 if (PyErr_Occurred()) SWIG_fail;
5153 }
5154 resultobj = SWIG_Py_Void();
5155 return resultobj;
5156 fail:
5157 return NULL;
5158 }
5159
5160
5161 SWIGINTERN PyObject *_wrap_MicroSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5162 PyObject *resultobj = 0;
5163 unsigned long arg1 ;
5164 unsigned long val1 ;
5165 int ecode1 = 0 ;
5166 PyObject * obj0 = 0 ;
5167 char * kwnames[] = {
5168 (char *) "microseconds", NULL
5169 };
5170
5171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) SWIG_fail;
5172 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5173 if (!SWIG_IsOK(ecode1)) {
5174 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MicroSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5175 }
5176 arg1 = static_cast< unsigned long >(val1);
5177 {
5178 PyThreadState* __tstate = wxPyBeginAllowThreads();
5179 wxMicroSleep(arg1);
5180 wxPyEndAllowThreads(__tstate);
5181 if (PyErr_Occurred()) SWIG_fail;
5182 }
5183 resultobj = SWIG_Py_Void();
5184 return resultobj;
5185 fail:
5186 return NULL;
5187 }
5188
5189
5190 SWIGINTERN PyObject *_wrap_EnableTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5191 PyObject *resultobj = 0;
5192 bool arg1 ;
5193 bool val1 ;
5194 int ecode1 = 0 ;
5195 PyObject * obj0 = 0 ;
5196 char * kwnames[] = {
5197 (char *) "enable", NULL
5198 };
5199
5200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) SWIG_fail;
5201 ecode1 = SWIG_AsVal_bool(obj0, &val1);
5202 if (!SWIG_IsOK(ecode1)) {
5203 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "EnableTopLevelWindows" "', expected argument " "1"" of type '" "bool""'");
5204 }
5205 arg1 = static_cast< bool >(val1);
5206 {
5207 PyThreadState* __tstate = wxPyBeginAllowThreads();
5208 wxEnableTopLevelWindows(arg1);
5209 wxPyEndAllowThreads(__tstate);
5210 if (PyErr_Occurred()) SWIG_fail;
5211 }
5212 resultobj = SWIG_Py_Void();
5213 return resultobj;
5214 fail:
5215 return NULL;
5216 }
5217
5218
5219 SWIGINTERN PyObject *_wrap_StripMenuCodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5220 PyObject *resultobj = 0;
5221 wxString *arg1 = 0 ;
5222 wxString result;
5223 bool temp1 = false ;
5224 PyObject * obj0 = 0 ;
5225 char * kwnames[] = {
5226 (char *) "_in", NULL
5227 };
5228
5229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) SWIG_fail;
5230 {
5231 arg1 = wxString_in_helper(obj0);
5232 if (arg1 == NULL) SWIG_fail;
5233 temp1 = true;
5234 }
5235 {
5236 PyThreadState* __tstate = wxPyBeginAllowThreads();
5237 result = wxStripMenuCodes((wxString const &)*arg1);
5238 wxPyEndAllowThreads(__tstate);
5239 if (PyErr_Occurred()) SWIG_fail;
5240 }
5241 {
5242 #if wxUSE_UNICODE
5243 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5244 #else
5245 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5246 #endif
5247 }
5248 {
5249 if (temp1)
5250 delete arg1;
5251 }
5252 return resultobj;
5253 fail:
5254 {
5255 if (temp1)
5256 delete arg1;
5257 }
5258 return NULL;
5259 }
5260
5261
5262 SWIGINTERN PyObject *_wrap_GetEmailAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5263 PyObject *resultobj = 0;
5264 wxString result;
5265
5266 if (!SWIG_Python_UnpackTuple(args,"GetEmailAddress",0,0,0)) SWIG_fail;
5267 {
5268 PyThreadState* __tstate = wxPyBeginAllowThreads();
5269 result = wxGetEmailAddress();
5270 wxPyEndAllowThreads(__tstate);
5271 if (PyErr_Occurred()) SWIG_fail;
5272 }
5273 {
5274 #if wxUSE_UNICODE
5275 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5276 #else
5277 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5278 #endif
5279 }
5280 return resultobj;
5281 fail:
5282 return NULL;
5283 }
5284
5285
5286 SWIGINTERN PyObject *_wrap_GetHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5287 PyObject *resultobj = 0;
5288 wxString result;
5289
5290 if (!SWIG_Python_UnpackTuple(args,"GetHostName",0,0,0)) SWIG_fail;
5291 {
5292 PyThreadState* __tstate = wxPyBeginAllowThreads();
5293 result = wxGetHostName();
5294 wxPyEndAllowThreads(__tstate);
5295 if (PyErr_Occurred()) SWIG_fail;
5296 }
5297 {
5298 #if wxUSE_UNICODE
5299 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5300 #else
5301 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5302 #endif
5303 }
5304 return resultobj;
5305 fail:
5306 return NULL;
5307 }
5308
5309
5310 SWIGINTERN PyObject *_wrap_GetFullHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5311 PyObject *resultobj = 0;
5312 wxString result;
5313
5314 if (!SWIG_Python_UnpackTuple(args,"GetFullHostName",0,0,0)) SWIG_fail;
5315 {
5316 PyThreadState* __tstate = wxPyBeginAllowThreads();
5317 result = wxGetFullHostName();
5318 wxPyEndAllowThreads(__tstate);
5319 if (PyErr_Occurred()) SWIG_fail;
5320 }
5321 {
5322 #if wxUSE_UNICODE
5323 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5324 #else
5325 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5326 #endif
5327 }
5328 return resultobj;
5329 fail:
5330 return NULL;
5331 }
5332
5333
5334 SWIGINTERN PyObject *_wrap_GetUserId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5335 PyObject *resultobj = 0;
5336 wxString result;
5337
5338 if (!SWIG_Python_UnpackTuple(args,"GetUserId",0,0,0)) SWIG_fail;
5339 {
5340 PyThreadState* __tstate = wxPyBeginAllowThreads();
5341 result = wxGetUserId();
5342 wxPyEndAllowThreads(__tstate);
5343 if (PyErr_Occurred()) SWIG_fail;
5344 }
5345 {
5346 #if wxUSE_UNICODE
5347 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5348 #else
5349 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5350 #endif
5351 }
5352 return resultobj;
5353 fail:
5354 return NULL;
5355 }
5356
5357
5358 SWIGINTERN PyObject *_wrap_GetUserName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5359 PyObject *resultobj = 0;
5360 wxString result;
5361
5362 if (!SWIG_Python_UnpackTuple(args,"GetUserName",0,0,0)) SWIG_fail;
5363 {
5364 PyThreadState* __tstate = wxPyBeginAllowThreads();
5365 result = wxGetUserName();
5366 wxPyEndAllowThreads(__tstate);
5367 if (PyErr_Occurred()) SWIG_fail;
5368 }
5369 {
5370 #if wxUSE_UNICODE
5371 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5372 #else
5373 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5374 #endif
5375 }
5376 return resultobj;
5377 fail:
5378 return NULL;
5379 }
5380
5381
5382 SWIGINTERN PyObject *_wrap_GetHomeDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5383 PyObject *resultobj = 0;
5384 wxString result;
5385
5386 if (!SWIG_Python_UnpackTuple(args,"GetHomeDir",0,0,0)) SWIG_fail;
5387 {
5388 PyThreadState* __tstate = wxPyBeginAllowThreads();
5389 result = wxGetHomeDir();
5390 wxPyEndAllowThreads(__tstate);
5391 if (PyErr_Occurred()) SWIG_fail;
5392 }
5393 {
5394 #if wxUSE_UNICODE
5395 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5396 #else
5397 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5398 #endif
5399 }
5400 return resultobj;
5401 fail:
5402 return NULL;
5403 }
5404
5405
5406 SWIGINTERN PyObject *_wrap_GetUserHome(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5407 PyObject *resultobj = 0;
5408 wxString const &arg1_defvalue = wxPyEmptyString ;
5409 wxString *arg1 = (wxString *) &arg1_defvalue ;
5410 wxString result;
5411 bool temp1 = false ;
5412 PyObject * obj0 = 0 ;
5413 char * kwnames[] = {
5414 (char *) "user", NULL
5415 };
5416
5417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) SWIG_fail;
5418 if (obj0) {
5419 {
5420 arg1 = wxString_in_helper(obj0);
5421 if (arg1 == NULL) SWIG_fail;
5422 temp1 = true;
5423 }
5424 }
5425 {
5426 PyThreadState* __tstate = wxPyBeginAllowThreads();
5427 result = wxGetUserHome((wxString const &)*arg1);
5428 wxPyEndAllowThreads(__tstate);
5429 if (PyErr_Occurred()) SWIG_fail;
5430 }
5431 {
5432 #if wxUSE_UNICODE
5433 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5434 #else
5435 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5436 #endif
5437 }
5438 {
5439 if (temp1)
5440 delete arg1;
5441 }
5442 return resultobj;
5443 fail:
5444 {
5445 if (temp1)
5446 delete arg1;
5447 }
5448 return NULL;
5449 }
5450
5451
5452 SWIGINTERN PyObject *_wrap_GetProcessId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5453 PyObject *resultobj = 0;
5454 unsigned long result;
5455
5456 if (!SWIG_Python_UnpackTuple(args,"GetProcessId",0,0,0)) SWIG_fail;
5457 {
5458 PyThreadState* __tstate = wxPyBeginAllowThreads();
5459 result = (unsigned long)wxGetProcessId();
5460 wxPyEndAllowThreads(__tstate);
5461 if (PyErr_Occurred()) SWIG_fail;
5462 }
5463 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
5464 return resultobj;
5465 fail:
5466 return NULL;
5467 }
5468
5469
5470 SWIGINTERN PyObject *_wrap_Trap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5471 PyObject *resultobj = 0;
5472
5473 if (!SWIG_Python_UnpackTuple(args,"Trap",0,0,0)) SWIG_fail;
5474 {
5475 PyThreadState* __tstate = wxPyBeginAllowThreads();
5476 wxTrap();
5477 wxPyEndAllowThreads(__tstate);
5478 if (PyErr_Occurred()) SWIG_fail;
5479 }
5480 resultobj = SWIG_Py_Void();
5481 return resultobj;
5482 fail:
5483 return NULL;
5484 }
5485
5486
5487 SWIGINTERN PyObject *_wrap_FileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5488 PyObject *resultobj = 0;
5489 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
5490 wxString *arg1 = (wxString *) &arg1_defvalue ;
5491 wxString const &arg2_defvalue = wxPyEmptyString ;
5492 wxString *arg2 = (wxString *) &arg2_defvalue ;
5493 wxString const &arg3_defvalue = wxPyEmptyString ;
5494 wxString *arg3 = (wxString *) &arg3_defvalue ;
5495 wxString const &arg4_defvalue = wxPyEmptyString ;
5496 wxString *arg4 = (wxString *) &arg4_defvalue ;
5497 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
5498 wxString *arg5 = (wxString *) &arg5_defvalue ;
5499 int arg6 = (int) 0 ;
5500 wxWindow *arg7 = (wxWindow *) NULL ;
5501 int arg8 = (int) -1 ;
5502 int arg9 = (int) -1 ;
5503 wxString result;
5504 bool temp1 = false ;
5505 bool temp2 = false ;
5506 bool temp3 = false ;
5507 bool temp4 = false ;
5508 bool temp5 = false ;
5509 int val6 ;
5510 int ecode6 = 0 ;
5511 void *argp7 = 0 ;
5512 int res7 = 0 ;
5513 int val8 ;
5514 int ecode8 = 0 ;
5515 int val9 ;
5516 int ecode9 = 0 ;
5517 PyObject * obj0 = 0 ;
5518 PyObject * obj1 = 0 ;
5519 PyObject * obj2 = 0 ;
5520 PyObject * obj3 = 0 ;
5521 PyObject * obj4 = 0 ;
5522 PyObject * obj5 = 0 ;
5523 PyObject * obj6 = 0 ;
5524 PyObject * obj7 = 0 ;
5525 PyObject * obj8 = 0 ;
5526 char * kwnames[] = {
5527 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
5528 };
5529
5530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
5531 if (obj0) {
5532 {
5533 arg1 = wxString_in_helper(obj0);
5534 if (arg1 == NULL) SWIG_fail;
5535 temp1 = true;
5536 }
5537 }
5538 if (obj1) {
5539 {
5540 arg2 = wxString_in_helper(obj1);
5541 if (arg2 == NULL) SWIG_fail;
5542 temp2 = true;
5543 }
5544 }
5545 if (obj2) {
5546 {
5547 arg3 = wxString_in_helper(obj2);
5548 if (arg3 == NULL) SWIG_fail;
5549 temp3 = true;
5550 }
5551 }
5552 if (obj3) {
5553 {
5554 arg4 = wxString_in_helper(obj3);
5555 if (arg4 == NULL) SWIG_fail;
5556 temp4 = true;
5557 }
5558 }
5559 if (obj4) {
5560 {
5561 arg5 = wxString_in_helper(obj4);
5562 if (arg5 == NULL) SWIG_fail;
5563 temp5 = true;
5564 }
5565 }
5566 if (obj5) {
5567 ecode6 = SWIG_AsVal_int(obj5, &val6);
5568 if (!SWIG_IsOK(ecode6)) {
5569 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "FileSelector" "', expected argument " "6"" of type '" "int""'");
5570 }
5571 arg6 = static_cast< int >(val6);
5572 }
5573 if (obj6) {
5574 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_wxWindow, 0 | 0 );
5575 if (!SWIG_IsOK(res7)) {
5576 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "FileSelector" "', expected argument " "7"" of type '" "wxWindow *""'");
5577 }
5578 arg7 = reinterpret_cast< wxWindow * >(argp7);
5579 }
5580 if (obj7) {
5581 ecode8 = SWIG_AsVal_int(obj7, &val8);
5582 if (!SWIG_IsOK(ecode8)) {
5583 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "FileSelector" "', expected argument " "8"" of type '" "int""'");
5584 }
5585 arg8 = static_cast< int >(val8);
5586 }
5587 if (obj8) {
5588 ecode9 = SWIG_AsVal_int(obj8, &val9);
5589 if (!SWIG_IsOK(ecode9)) {
5590 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "FileSelector" "', expected argument " "9"" of type '" "int""'");
5591 }
5592 arg9 = static_cast< int >(val9);
5593 }
5594 {
5595 if (!wxPyCheckForApp()) SWIG_fail;
5596 PyThreadState* __tstate = wxPyBeginAllowThreads();
5597 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
5598 wxPyEndAllowThreads(__tstate);
5599 if (PyErr_Occurred()) SWIG_fail;
5600 }
5601 {
5602 #if wxUSE_UNICODE
5603 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5604 #else
5605 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5606 #endif
5607 }
5608 {
5609 if (temp1)
5610 delete arg1;
5611 }
5612 {
5613 if (temp2)
5614 delete arg2;
5615 }
5616 {
5617 if (temp3)
5618 delete arg3;
5619 }
5620 {
5621 if (temp4)
5622 delete arg4;
5623 }
5624 {
5625 if (temp5)
5626 delete arg5;
5627 }
5628 return resultobj;
5629 fail:
5630 {
5631 if (temp1)
5632 delete arg1;
5633 }
5634 {
5635 if (temp2)
5636 delete arg2;
5637 }
5638 {
5639 if (temp3)
5640 delete arg3;
5641 }
5642 {
5643 if (temp4)
5644 delete arg4;
5645 }
5646 {
5647 if (temp5)
5648 delete arg5;
5649 }
5650 return NULL;
5651 }
5652
5653
5654 SWIGINTERN PyObject *_wrap_LoadFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5655 PyObject *resultobj = 0;
5656 wxString *arg1 = 0 ;
5657 wxString *arg2 = 0 ;
5658 wxString const &arg3_defvalue = wxPyEmptyString ;
5659 wxString *arg3 = (wxString *) &arg3_defvalue ;
5660 wxWindow *arg4 = (wxWindow *) NULL ;
5661 wxString result;
5662 bool temp1 = false ;
5663 bool temp2 = false ;
5664 bool temp3 = false ;
5665 void *argp4 = 0 ;
5666 int res4 = 0 ;
5667 PyObject * obj0 = 0 ;
5668 PyObject * obj1 = 0 ;
5669 PyObject * obj2 = 0 ;
5670 PyObject * obj3 = 0 ;
5671 char * kwnames[] = {
5672 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5673 };
5674
5675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5676 {
5677 arg1 = wxString_in_helper(obj0);
5678 if (arg1 == NULL) SWIG_fail;
5679 temp1 = true;
5680 }
5681 {
5682 arg2 = wxString_in_helper(obj1);
5683 if (arg2 == NULL) SWIG_fail;
5684 temp2 = true;
5685 }
5686 if (obj2) {
5687 {
5688 arg3 = wxString_in_helper(obj2);
5689 if (arg3 == NULL) SWIG_fail;
5690 temp3 = true;
5691 }
5692 }
5693 if (obj3) {
5694 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5695 if (!SWIG_IsOK(res4)) {
5696 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LoadFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5697 }
5698 arg4 = reinterpret_cast< wxWindow * >(argp4);
5699 }
5700 {
5701 if (!wxPyCheckForApp()) SWIG_fail;
5702 PyThreadState* __tstate = wxPyBeginAllowThreads();
5703 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5704 wxPyEndAllowThreads(__tstate);
5705 if (PyErr_Occurred()) SWIG_fail;
5706 }
5707 {
5708 #if wxUSE_UNICODE
5709 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5710 #else
5711 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5712 #endif
5713 }
5714 {
5715 if (temp1)
5716 delete arg1;
5717 }
5718 {
5719 if (temp2)
5720 delete arg2;
5721 }
5722 {
5723 if (temp3)
5724 delete arg3;
5725 }
5726 return resultobj;
5727 fail:
5728 {
5729 if (temp1)
5730 delete arg1;
5731 }
5732 {
5733 if (temp2)
5734 delete arg2;
5735 }
5736 {
5737 if (temp3)
5738 delete arg3;
5739 }
5740 return NULL;
5741 }
5742
5743
5744 SWIGINTERN PyObject *_wrap_SaveFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5745 PyObject *resultobj = 0;
5746 wxString *arg1 = 0 ;
5747 wxString *arg2 = 0 ;
5748 wxString const &arg3_defvalue = wxPyEmptyString ;
5749 wxString *arg3 = (wxString *) &arg3_defvalue ;
5750 wxWindow *arg4 = (wxWindow *) NULL ;
5751 wxString result;
5752 bool temp1 = false ;
5753 bool temp2 = false ;
5754 bool temp3 = false ;
5755 void *argp4 = 0 ;
5756 int res4 = 0 ;
5757 PyObject * obj0 = 0 ;
5758 PyObject * obj1 = 0 ;
5759 PyObject * obj2 = 0 ;
5760 PyObject * obj3 = 0 ;
5761 char * kwnames[] = {
5762 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5763 };
5764
5765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5766 {
5767 arg1 = wxString_in_helper(obj0);
5768 if (arg1 == NULL) SWIG_fail;
5769 temp1 = true;
5770 }
5771 {
5772 arg2 = wxString_in_helper(obj1);
5773 if (arg2 == NULL) SWIG_fail;
5774 temp2 = true;
5775 }
5776 if (obj2) {
5777 {
5778 arg3 = wxString_in_helper(obj2);
5779 if (arg3 == NULL) SWIG_fail;
5780 temp3 = true;
5781 }
5782 }
5783 if (obj3) {
5784 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5785 if (!SWIG_IsOK(res4)) {
5786 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SaveFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5787 }
5788 arg4 = reinterpret_cast< wxWindow * >(argp4);
5789 }
5790 {
5791 if (!wxPyCheckForApp()) SWIG_fail;
5792 PyThreadState* __tstate = wxPyBeginAllowThreads();
5793 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5794 wxPyEndAllowThreads(__tstate);
5795 if (PyErr_Occurred()) SWIG_fail;
5796 }
5797 {
5798 #if wxUSE_UNICODE
5799 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5800 #else
5801 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5802 #endif
5803 }
5804 {
5805 if (temp1)
5806 delete arg1;
5807 }
5808 {
5809 if (temp2)
5810 delete arg2;
5811 }
5812 {
5813 if (temp3)
5814 delete arg3;
5815 }
5816 return resultobj;
5817 fail:
5818 {
5819 if (temp1)
5820 delete arg1;
5821 }
5822 {
5823 if (temp2)
5824 delete arg2;
5825 }
5826 {
5827 if (temp3)
5828 delete arg3;
5829 }
5830 return NULL;
5831 }
5832
5833
5834 SWIGINTERN PyObject *_wrap_DirSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5835 PyObject *resultobj = 0;
5836 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
5837 wxString *arg1 = (wxString *) &arg1_defvalue ;
5838 wxString const &arg2_defvalue = wxPyEmptyString ;
5839 wxString *arg2 = (wxString *) &arg2_defvalue ;
5840 long arg3 = (long) wxDD_DEFAULT_STYLE ;
5841 wxPoint const &arg4_defvalue = wxDefaultPosition ;
5842 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
5843 wxWindow *arg5 = (wxWindow *) NULL ;
5844 wxString result;
5845 bool temp1 = false ;
5846 bool temp2 = false ;
5847 long val3 ;
5848 int ecode3 = 0 ;
5849 wxPoint temp4 ;
5850 void *argp5 = 0 ;
5851 int res5 = 0 ;
5852 PyObject * obj0 = 0 ;
5853 PyObject * obj1 = 0 ;
5854 PyObject * obj2 = 0 ;
5855 PyObject * obj3 = 0 ;
5856 PyObject * obj4 = 0 ;
5857 char * kwnames[] = {
5858 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
5859 };
5860
5861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
5862 if (obj0) {
5863 {
5864 arg1 = wxString_in_helper(obj0);
5865 if (arg1 == NULL) SWIG_fail;
5866 temp1 = true;
5867 }
5868 }
5869 if (obj1) {
5870 {
5871 arg2 = wxString_in_helper(obj1);
5872 if (arg2 == NULL) SWIG_fail;
5873 temp2 = true;
5874 }
5875 }
5876 if (obj2) {
5877 ecode3 = SWIG_AsVal_long(obj2, &val3);
5878 if (!SWIG_IsOK(ecode3)) {
5879 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DirSelector" "', expected argument " "3"" of type '" "long""'");
5880 }
5881 arg3 = static_cast< long >(val3);
5882 }
5883 if (obj3) {
5884 {
5885 arg4 = &temp4;
5886 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
5887 }
5888 }
5889 if (obj4) {
5890 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
5891 if (!SWIG_IsOK(res5)) {
5892 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DirSelector" "', expected argument " "5"" of type '" "wxWindow *""'");
5893 }
5894 arg5 = reinterpret_cast< wxWindow * >(argp5);
5895 }
5896 {
5897 if (!wxPyCheckForApp()) SWIG_fail;
5898 PyThreadState* __tstate = wxPyBeginAllowThreads();
5899 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
5900 wxPyEndAllowThreads(__tstate);
5901 if (PyErr_Occurred()) SWIG_fail;
5902 }
5903 {
5904 #if wxUSE_UNICODE
5905 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5906 #else
5907 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5908 #endif
5909 }
5910 {
5911 if (temp1)
5912 delete arg1;
5913 }
5914 {
5915 if (temp2)
5916 delete arg2;
5917 }
5918 return resultobj;
5919 fail:
5920 {
5921 if (temp1)
5922 delete arg1;
5923 }
5924 {
5925 if (temp2)
5926 delete arg2;
5927 }
5928 return NULL;
5929 }
5930
5931
5932 SWIGINTERN PyObject *_wrap_GetTextFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5933 PyObject *resultobj = 0;
5934 wxString *arg1 = 0 ;
5935 wxString const &arg2_defvalue = wxPyEmptyString ;
5936 wxString *arg2 = (wxString *) &arg2_defvalue ;
5937 wxString const &arg3_defvalue = wxPyEmptyString ;
5938 wxString *arg3 = (wxString *) &arg3_defvalue ;
5939 wxWindow *arg4 = (wxWindow *) NULL ;
5940 int arg5 = (int) -1 ;
5941 int arg6 = (int) -1 ;
5942 bool arg7 = (bool) true ;
5943 wxString result;
5944 bool temp1 = false ;
5945 bool temp2 = false ;
5946 bool temp3 = false ;
5947 void *argp4 = 0 ;
5948 int res4 = 0 ;
5949 int val5 ;
5950 int ecode5 = 0 ;
5951 int val6 ;
5952 int ecode6 = 0 ;
5953 bool val7 ;
5954 int ecode7 = 0 ;
5955 PyObject * obj0 = 0 ;
5956 PyObject * obj1 = 0 ;
5957 PyObject * obj2 = 0 ;
5958 PyObject * obj3 = 0 ;
5959 PyObject * obj4 = 0 ;
5960 PyObject * obj5 = 0 ;
5961 PyObject * obj6 = 0 ;
5962 char * kwnames[] = {
5963 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
5964 };
5965
5966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
5967 {
5968 arg1 = wxString_in_helper(obj0);
5969 if (arg1 == NULL) SWIG_fail;
5970 temp1 = true;
5971 }
5972 if (obj1) {
5973 {
5974 arg2 = wxString_in_helper(obj1);
5975 if (arg2 == NULL) SWIG_fail;
5976 temp2 = true;
5977 }
5978 }
5979 if (obj2) {
5980 {
5981 arg3 = wxString_in_helper(obj2);
5982 if (arg3 == NULL) SWIG_fail;
5983 temp3 = true;
5984 }
5985 }
5986 if (obj3) {
5987 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5988 if (!SWIG_IsOK(res4)) {
5989 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetTextFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
5990 }
5991 arg4 = reinterpret_cast< wxWindow * >(argp4);
5992 }
5993 if (obj4) {
5994 ecode5 = SWIG_AsVal_int(obj4, &val5);
5995 if (!SWIG_IsOK(ecode5)) {
5996 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetTextFromUser" "', expected argument " "5"" of type '" "int""'");
5997 }
5998 arg5 = static_cast< int >(val5);
5999 }
6000 if (obj5) {
6001 ecode6 = SWIG_AsVal_int(obj5, &val6);
6002 if (!SWIG_IsOK(ecode6)) {
6003 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetTextFromUser" "', expected argument " "6"" of type '" "int""'");
6004 }
6005 arg6 = static_cast< int >(val6);
6006 }
6007 if (obj6) {
6008 ecode7 = SWIG_AsVal_bool(obj6, &val7);
6009 if (!SWIG_IsOK(ecode7)) {
6010 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetTextFromUser" "', expected argument " "7"" of type '" "bool""'");
6011 }
6012 arg7 = static_cast< bool >(val7);
6013 }
6014 {
6015 if (!wxPyCheckForApp()) SWIG_fail;
6016 PyThreadState* __tstate = wxPyBeginAllowThreads();
6017 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
6018 wxPyEndAllowThreads(__tstate);
6019 if (PyErr_Occurred()) SWIG_fail;
6020 }
6021 {
6022 #if wxUSE_UNICODE
6023 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6024 #else
6025 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6026 #endif
6027 }
6028 {
6029 if (temp1)
6030 delete arg1;
6031 }
6032 {
6033 if (temp2)
6034 delete arg2;
6035 }
6036 {
6037 if (temp3)
6038 delete arg3;
6039 }
6040 return resultobj;
6041 fail:
6042 {
6043 if (temp1)
6044 delete arg1;
6045 }
6046 {
6047 if (temp2)
6048 delete arg2;
6049 }
6050 {
6051 if (temp3)
6052 delete arg3;
6053 }
6054 return NULL;
6055 }
6056
6057
6058 SWIGINTERN PyObject *_wrap_GetPasswordFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6059 PyObject *resultobj = 0;
6060 wxString *arg1 = 0 ;
6061 wxString const &arg2_defvalue = wxPyEmptyString ;
6062 wxString *arg2 = (wxString *) &arg2_defvalue ;
6063 wxString const &arg3_defvalue = wxPyEmptyString ;
6064 wxString *arg3 = (wxString *) &arg3_defvalue ;
6065 wxWindow *arg4 = (wxWindow *) NULL ;
6066 wxString result;
6067 bool temp1 = false ;
6068 bool temp2 = false ;
6069 bool temp3 = false ;
6070 void *argp4 = 0 ;
6071 int res4 = 0 ;
6072 PyObject * obj0 = 0 ;
6073 PyObject * obj1 = 0 ;
6074 PyObject * obj2 = 0 ;
6075 PyObject * obj3 = 0 ;
6076 char * kwnames[] = {
6077 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
6078 };
6079
6080 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6081 {
6082 arg1 = wxString_in_helper(obj0);
6083 if (arg1 == NULL) SWIG_fail;
6084 temp1 = true;
6085 }
6086 if (obj1) {
6087 {
6088 arg2 = wxString_in_helper(obj1);
6089 if (arg2 == NULL) SWIG_fail;
6090 temp2 = true;
6091 }
6092 }
6093 if (obj2) {
6094 {
6095 arg3 = wxString_in_helper(obj2);
6096 if (arg3 == NULL) SWIG_fail;
6097 temp3 = true;
6098 }
6099 }
6100 if (obj3) {
6101 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6102 if (!SWIG_IsOK(res4)) {
6103 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetPasswordFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6104 }
6105 arg4 = reinterpret_cast< wxWindow * >(argp4);
6106 }
6107 {
6108 if (!wxPyCheckForApp()) SWIG_fail;
6109 PyThreadState* __tstate = wxPyBeginAllowThreads();
6110 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
6111 wxPyEndAllowThreads(__tstate);
6112 if (PyErr_Occurred()) SWIG_fail;
6113 }
6114 {
6115 #if wxUSE_UNICODE
6116 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6117 #else
6118 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6119 #endif
6120 }
6121 {
6122 if (temp1)
6123 delete arg1;
6124 }
6125 {
6126 if (temp2)
6127 delete arg2;
6128 }
6129 {
6130 if (temp3)
6131 delete arg3;
6132 }
6133 return resultobj;
6134 fail:
6135 {
6136 if (temp1)
6137 delete arg1;
6138 }
6139 {
6140 if (temp2)
6141 delete arg2;
6142 }
6143 {
6144 if (temp3)
6145 delete arg3;
6146 }
6147 return NULL;
6148 }
6149
6150
6151 SWIGINTERN PyObject *_wrap_GetSingleChoice(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6152 PyObject *resultobj = 0;
6153 wxString *arg1 = 0 ;
6154 wxString *arg2 = 0 ;
6155 int arg3 ;
6156 wxString *arg4 = (wxString *) 0 ;
6157 wxWindow *arg5 = (wxWindow *) NULL ;
6158 int arg6 = (int) -1 ;
6159 int arg7 = (int) -1 ;
6160 bool arg8 = (bool) true ;
6161 int arg9 = (int) 150 ;
6162 int arg10 = (int) 200 ;
6163 wxString result;
6164 bool temp1 = false ;
6165 bool temp2 = false ;
6166 void *argp5 = 0 ;
6167 int res5 = 0 ;
6168 int val6 ;
6169 int ecode6 = 0 ;
6170 int val7 ;
6171 int ecode7 = 0 ;
6172 bool val8 ;
6173 int ecode8 = 0 ;
6174 int val9 ;
6175 int ecode9 = 0 ;
6176 int val10 ;
6177 int ecode10 = 0 ;
6178 PyObject * obj0 = 0 ;
6179 PyObject * obj1 = 0 ;
6180 PyObject * obj2 = 0 ;
6181 PyObject * obj3 = 0 ;
6182 PyObject * obj4 = 0 ;
6183 PyObject * obj5 = 0 ;
6184 PyObject * obj6 = 0 ;
6185 PyObject * obj7 = 0 ;
6186 PyObject * obj8 = 0 ;
6187 char * kwnames[] = {
6188 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6189 };
6190
6191 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6192 {
6193 arg1 = wxString_in_helper(obj0);
6194 if (arg1 == NULL) SWIG_fail;
6195 temp1 = true;
6196 }
6197 {
6198 arg2 = wxString_in_helper(obj1);
6199 if (arg2 == NULL) SWIG_fail;
6200 temp2 = true;
6201 }
6202 {
6203 arg3 = PyList_Size(obj2);
6204 arg4 = wxString_LIST_helper(obj2);
6205 if (arg4 == NULL) SWIG_fail;
6206 }
6207 if (obj3) {
6208 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6209 if (!SWIG_IsOK(res5)) {
6210 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoice" "', expected argument " "5"" of type '" "wxWindow *""'");
6211 }
6212 arg5 = reinterpret_cast< wxWindow * >(argp5);
6213 }
6214 if (obj4) {
6215 ecode6 = SWIG_AsVal_int(obj4, &val6);
6216 if (!SWIG_IsOK(ecode6)) {
6217 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoice" "', expected argument " "6"" of type '" "int""'");
6218 }
6219 arg6 = static_cast< int >(val6);
6220 }
6221 if (obj5) {
6222 ecode7 = SWIG_AsVal_int(obj5, &val7);
6223 if (!SWIG_IsOK(ecode7)) {
6224 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoice" "', expected argument " "7"" of type '" "int""'");
6225 }
6226 arg7 = static_cast< int >(val7);
6227 }
6228 if (obj6) {
6229 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6230 if (!SWIG_IsOK(ecode8)) {
6231 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoice" "', expected argument " "8"" of type '" "bool""'");
6232 }
6233 arg8 = static_cast< bool >(val8);
6234 }
6235 if (obj7) {
6236 ecode9 = SWIG_AsVal_int(obj7, &val9);
6237 if (!SWIG_IsOK(ecode9)) {
6238 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoice" "', expected argument " "9"" of type '" "int""'");
6239 }
6240 arg9 = static_cast< int >(val9);
6241 }
6242 if (obj8) {
6243 ecode10 = SWIG_AsVal_int(obj8, &val10);
6244 if (!SWIG_IsOK(ecode10)) {
6245 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoice" "', expected argument " "10"" of type '" "int""'");
6246 }
6247 arg10 = static_cast< int >(val10);
6248 }
6249 {
6250 if (!wxPyCheckForApp()) SWIG_fail;
6251 PyThreadState* __tstate = wxPyBeginAllowThreads();
6252 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6253 wxPyEndAllowThreads(__tstate);
6254 if (PyErr_Occurred()) SWIG_fail;
6255 }
6256 {
6257 #if wxUSE_UNICODE
6258 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6259 #else
6260 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6261 #endif
6262 }
6263 {
6264 if (temp1)
6265 delete arg1;
6266 }
6267 {
6268 if (temp2)
6269 delete arg2;
6270 }
6271 {
6272 if (arg4) delete [] arg4;
6273 }
6274 return resultobj;
6275 fail:
6276 {
6277 if (temp1)
6278 delete arg1;
6279 }
6280 {
6281 if (temp2)
6282 delete arg2;
6283 }
6284 {
6285 if (arg4) delete [] arg4;
6286 }
6287 return NULL;
6288 }
6289
6290
6291 SWIGINTERN PyObject *_wrap_GetSingleChoiceIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6292 PyObject *resultobj = 0;
6293 wxString *arg1 = 0 ;
6294 wxString *arg2 = 0 ;
6295 int arg3 ;
6296 wxString *arg4 = (wxString *) 0 ;
6297 wxWindow *arg5 = (wxWindow *) NULL ;
6298 int arg6 = (int) -1 ;
6299 int arg7 = (int) -1 ;
6300 bool arg8 = (bool) true ;
6301 int arg9 = (int) 150 ;
6302 int arg10 = (int) 200 ;
6303 int result;
6304 bool temp1 = false ;
6305 bool temp2 = false ;
6306 void *argp5 = 0 ;
6307 int res5 = 0 ;
6308 int val6 ;
6309 int ecode6 = 0 ;
6310 int val7 ;
6311 int ecode7 = 0 ;
6312 bool val8 ;
6313 int ecode8 = 0 ;
6314 int val9 ;
6315 int ecode9 = 0 ;
6316 int val10 ;
6317 int ecode10 = 0 ;
6318 PyObject * obj0 = 0 ;
6319 PyObject * obj1 = 0 ;
6320 PyObject * obj2 = 0 ;
6321 PyObject * obj3 = 0 ;
6322 PyObject * obj4 = 0 ;
6323 PyObject * obj5 = 0 ;
6324 PyObject * obj6 = 0 ;
6325 PyObject * obj7 = 0 ;
6326 PyObject * obj8 = 0 ;
6327 char * kwnames[] = {
6328 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6329 };
6330
6331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6332 {
6333 arg1 = wxString_in_helper(obj0);
6334 if (arg1 == NULL) SWIG_fail;
6335 temp1 = true;
6336 }
6337 {
6338 arg2 = wxString_in_helper(obj1);
6339 if (arg2 == NULL) SWIG_fail;
6340 temp2 = true;
6341 }
6342 {
6343 arg3 = PyList_Size(obj2);
6344 arg4 = wxString_LIST_helper(obj2);
6345 if (arg4 == NULL) SWIG_fail;
6346 }
6347 if (obj3) {
6348 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6349 if (!SWIG_IsOK(res5)) {
6350 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoiceIndex" "', expected argument " "5"" of type '" "wxWindow *""'");
6351 }
6352 arg5 = reinterpret_cast< wxWindow * >(argp5);
6353 }
6354 if (obj4) {
6355 ecode6 = SWIG_AsVal_int(obj4, &val6);
6356 if (!SWIG_IsOK(ecode6)) {
6357 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoiceIndex" "', expected argument " "6"" of type '" "int""'");
6358 }
6359 arg6 = static_cast< int >(val6);
6360 }
6361 if (obj5) {
6362 ecode7 = SWIG_AsVal_int(obj5, &val7);
6363 if (!SWIG_IsOK(ecode7)) {
6364 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoiceIndex" "', expected argument " "7"" of type '" "int""'");
6365 }
6366 arg7 = static_cast< int >(val7);
6367 }
6368 if (obj6) {
6369 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6370 if (!SWIG_IsOK(ecode8)) {
6371 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoiceIndex" "', expected argument " "8"" of type '" "bool""'");
6372 }
6373 arg8 = static_cast< bool >(val8);
6374 }
6375 if (obj7) {
6376 ecode9 = SWIG_AsVal_int(obj7, &val9);
6377 if (!SWIG_IsOK(ecode9)) {
6378 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoiceIndex" "', expected argument " "9"" of type '" "int""'");
6379 }
6380 arg9 = static_cast< int >(val9);
6381 }
6382 if (obj8) {
6383 ecode10 = SWIG_AsVal_int(obj8, &val10);
6384 if (!SWIG_IsOK(ecode10)) {
6385 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoiceIndex" "', expected argument " "10"" of type '" "int""'");
6386 }
6387 arg10 = static_cast< int >(val10);
6388 }
6389 {
6390 if (!wxPyCheckForApp()) SWIG_fail;
6391 PyThreadState* __tstate = wxPyBeginAllowThreads();
6392 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6393 wxPyEndAllowThreads(__tstate);
6394 if (PyErr_Occurred()) SWIG_fail;
6395 }
6396 resultobj = SWIG_From_int(static_cast< int >(result));
6397 {
6398 if (temp1)
6399 delete arg1;
6400 }
6401 {
6402 if (temp2)
6403 delete arg2;
6404 }
6405 {
6406 if (arg4) delete [] arg4;
6407 }
6408 return resultobj;
6409 fail:
6410 {
6411 if (temp1)
6412 delete arg1;
6413 }
6414 {
6415 if (temp2)
6416 delete arg2;
6417 }
6418 {
6419 if (arg4) delete [] arg4;
6420 }
6421 return NULL;
6422 }
6423
6424
6425 SWIGINTERN PyObject *_wrap_MessageBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6426 PyObject *resultobj = 0;
6427 wxString *arg1 = 0 ;
6428 wxString const &arg2_defvalue = wxPyEmptyString ;
6429 wxString *arg2 = (wxString *) &arg2_defvalue ;
6430 int arg3 = (int) wxOK|wxCENTRE ;
6431 wxWindow *arg4 = (wxWindow *) NULL ;
6432 int arg5 = (int) -1 ;
6433 int arg6 = (int) -1 ;
6434 int result;
6435 bool temp1 = false ;
6436 bool temp2 = false ;
6437 int val3 ;
6438 int ecode3 = 0 ;
6439 void *argp4 = 0 ;
6440 int res4 = 0 ;
6441 int val5 ;
6442 int ecode5 = 0 ;
6443 int val6 ;
6444 int ecode6 = 0 ;
6445 PyObject * obj0 = 0 ;
6446 PyObject * obj1 = 0 ;
6447 PyObject * obj2 = 0 ;
6448 PyObject * obj3 = 0 ;
6449 PyObject * obj4 = 0 ;
6450 PyObject * obj5 = 0 ;
6451 char * kwnames[] = {
6452 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
6453 };
6454
6455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
6456 {
6457 arg1 = wxString_in_helper(obj0);
6458 if (arg1 == NULL) SWIG_fail;
6459 temp1 = true;
6460 }
6461 if (obj1) {
6462 {
6463 arg2 = wxString_in_helper(obj1);
6464 if (arg2 == NULL) SWIG_fail;
6465 temp2 = true;
6466 }
6467 }
6468 if (obj2) {
6469 ecode3 = SWIG_AsVal_int(obj2, &val3);
6470 if (!SWIG_IsOK(ecode3)) {
6471 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MessageBox" "', expected argument " "3"" of type '" "int""'");
6472 }
6473 arg3 = static_cast< int >(val3);
6474 }
6475 if (obj3) {
6476 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6477 if (!SWIG_IsOK(res4)) {
6478 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MessageBox" "', expected argument " "4"" of type '" "wxWindow *""'");
6479 }
6480 arg4 = reinterpret_cast< wxWindow * >(argp4);
6481 }
6482 if (obj4) {
6483 ecode5 = SWIG_AsVal_int(obj4, &val5);
6484 if (!SWIG_IsOK(ecode5)) {
6485 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "MessageBox" "', expected argument " "5"" of type '" "int""'");
6486 }
6487 arg5 = static_cast< int >(val5);
6488 }
6489 if (obj5) {
6490 ecode6 = SWIG_AsVal_int(obj5, &val6);
6491 if (!SWIG_IsOK(ecode6)) {
6492 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "MessageBox" "', expected argument " "6"" of type '" "int""'");
6493 }
6494 arg6 = static_cast< int >(val6);
6495 }
6496 {
6497 if (!wxPyCheckForApp()) SWIG_fail;
6498 PyThreadState* __tstate = wxPyBeginAllowThreads();
6499 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
6500 wxPyEndAllowThreads(__tstate);
6501 if (PyErr_Occurred()) SWIG_fail;
6502 }
6503 resultobj = SWIG_From_int(static_cast< int >(result));
6504 {
6505 if (temp1)
6506 delete arg1;
6507 }
6508 {
6509 if (temp2)
6510 delete arg2;
6511 }
6512 return resultobj;
6513 fail:
6514 {
6515 if (temp1)
6516 delete arg1;
6517 }
6518 {
6519 if (temp2)
6520 delete arg2;
6521 }
6522 return NULL;
6523 }
6524
6525
6526 SWIGINTERN PyObject *_wrap_ColourDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6527 PyObject *resultobj = 0;
6528 bool result;
6529
6530 if (!SWIG_Python_UnpackTuple(args,"ColourDisplay",0,0,0)) SWIG_fail;
6531 {
6532 if (!wxPyCheckForApp()) SWIG_fail;
6533 PyThreadState* __tstate = wxPyBeginAllowThreads();
6534 result = (bool)wxColourDisplay();
6535 wxPyEndAllowThreads(__tstate);
6536 if (PyErr_Occurred()) SWIG_fail;
6537 }
6538 {
6539 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6540 }
6541 return resultobj;
6542 fail:
6543 return NULL;
6544 }
6545
6546
6547 SWIGINTERN PyObject *_wrap_DisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6548 PyObject *resultobj = 0;
6549 int result;
6550
6551 if (!SWIG_Python_UnpackTuple(args,"DisplayDepth",0,0,0)) SWIG_fail;
6552 {
6553 if (!wxPyCheckForApp()) SWIG_fail;
6554 PyThreadState* __tstate = wxPyBeginAllowThreads();
6555 result = (int)wxDisplayDepth();
6556 wxPyEndAllowThreads(__tstate);
6557 if (PyErr_Occurred()) SWIG_fail;
6558 }
6559 resultobj = SWIG_From_int(static_cast< int >(result));
6560 return resultobj;
6561 fail:
6562 return NULL;
6563 }
6564
6565
6566 SWIGINTERN PyObject *_wrap_GetDisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6567 PyObject *resultobj = 0;
6568 int result;
6569
6570 if (!SWIG_Python_UnpackTuple(args,"GetDisplayDepth",0,0,0)) SWIG_fail;
6571 {
6572 if (!wxPyCheckForApp()) SWIG_fail;
6573 PyThreadState* __tstate = wxPyBeginAllowThreads();
6574 result = (int)wxGetDisplayDepth();
6575 wxPyEndAllowThreads(__tstate);
6576 if (PyErr_Occurred()) SWIG_fail;
6577 }
6578 resultobj = SWIG_From_int(static_cast< int >(result));
6579 return resultobj;
6580 fail:
6581 return NULL;
6582 }
6583
6584
6585 SWIGINTERN PyObject *_wrap_DisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6586 PyObject *resultobj = 0;
6587 int *arg1 = (int *) 0 ;
6588 int *arg2 = (int *) 0 ;
6589 int temp1 ;
6590 int res1 = SWIG_TMPOBJ ;
6591 int temp2 ;
6592 int res2 = SWIG_TMPOBJ ;
6593
6594 arg1 = &temp1;
6595 arg2 = &temp2;
6596 if (!SWIG_Python_UnpackTuple(args,"DisplaySize",0,0,0)) SWIG_fail;
6597 {
6598 if (!wxPyCheckForApp()) SWIG_fail;
6599 PyThreadState* __tstate = wxPyBeginAllowThreads();
6600 wxDisplaySize(arg1,arg2);
6601 wxPyEndAllowThreads(__tstate);
6602 if (PyErr_Occurred()) SWIG_fail;
6603 }
6604 resultobj = SWIG_Py_Void();
6605 if (SWIG_IsTmpObj(res1)) {
6606 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6607 } else {
6608 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6609 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6610 }
6611 if (SWIG_IsTmpObj(res2)) {
6612 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6613 } else {
6614 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6615 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6616 }
6617 return resultobj;
6618 fail:
6619 return NULL;
6620 }
6621
6622
6623 SWIGINTERN PyObject *_wrap_GetDisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6624 PyObject *resultobj = 0;
6625 wxSize result;
6626
6627 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySize",0,0,0)) SWIG_fail;
6628 {
6629 if (!wxPyCheckForApp()) SWIG_fail;
6630 PyThreadState* __tstate = wxPyBeginAllowThreads();
6631 result = wxGetDisplaySize();
6632 wxPyEndAllowThreads(__tstate);
6633 if (PyErr_Occurred()) SWIG_fail;
6634 }
6635 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6636 return resultobj;
6637 fail:
6638 return NULL;
6639 }
6640
6641
6642 SWIGINTERN PyObject *_wrap_DisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6643 PyObject *resultobj = 0;
6644 int *arg1 = (int *) 0 ;
6645 int *arg2 = (int *) 0 ;
6646 int temp1 ;
6647 int res1 = SWIG_TMPOBJ ;
6648 int temp2 ;
6649 int res2 = SWIG_TMPOBJ ;
6650
6651 arg1 = &temp1;
6652 arg2 = &temp2;
6653 if (!SWIG_Python_UnpackTuple(args,"DisplaySizeMM",0,0,0)) SWIG_fail;
6654 {
6655 if (!wxPyCheckForApp()) SWIG_fail;
6656 PyThreadState* __tstate = wxPyBeginAllowThreads();
6657 wxDisplaySizeMM(arg1,arg2);
6658 wxPyEndAllowThreads(__tstate);
6659 if (PyErr_Occurred()) SWIG_fail;
6660 }
6661 resultobj = SWIG_Py_Void();
6662 if (SWIG_IsTmpObj(res1)) {
6663 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6664 } else {
6665 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6666 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6667 }
6668 if (SWIG_IsTmpObj(res2)) {
6669 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6670 } else {
6671 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6672 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6673 }
6674 return resultobj;
6675 fail:
6676 return NULL;
6677 }
6678
6679
6680 SWIGINTERN PyObject *_wrap_GetDisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6681 PyObject *resultobj = 0;
6682 wxSize result;
6683
6684 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySizeMM",0,0,0)) SWIG_fail;
6685 {
6686 if (!wxPyCheckForApp()) SWIG_fail;
6687 PyThreadState* __tstate = wxPyBeginAllowThreads();
6688 result = wxGetDisplaySizeMM();
6689 wxPyEndAllowThreads(__tstate);
6690 if (PyErr_Occurred()) SWIG_fail;
6691 }
6692 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6693 return resultobj;
6694 fail:
6695 return NULL;
6696 }
6697
6698
6699 SWIGINTERN PyObject *_wrap_ClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6700 PyObject *resultobj = 0;
6701 int *arg1 = (int *) 0 ;
6702 int *arg2 = (int *) 0 ;
6703 int *arg3 = (int *) 0 ;
6704 int *arg4 = (int *) 0 ;
6705 int temp1 ;
6706 int res1 = SWIG_TMPOBJ ;
6707 int temp2 ;
6708 int res2 = SWIG_TMPOBJ ;
6709 int temp3 ;
6710 int res3 = SWIG_TMPOBJ ;
6711 int temp4 ;
6712 int res4 = SWIG_TMPOBJ ;
6713
6714 arg1 = &temp1;
6715 arg2 = &temp2;
6716 arg3 = &temp3;
6717 arg4 = &temp4;
6718 if (!SWIG_Python_UnpackTuple(args,"ClientDisplayRect",0,0,0)) SWIG_fail;
6719 {
6720 if (!wxPyCheckForApp()) SWIG_fail;
6721 PyThreadState* __tstate = wxPyBeginAllowThreads();
6722 wxClientDisplayRect(arg1,arg2,arg3,arg4);
6723 wxPyEndAllowThreads(__tstate);
6724 if (PyErr_Occurred()) SWIG_fail;
6725 }
6726 resultobj = SWIG_Py_Void();
6727 if (SWIG_IsTmpObj(res1)) {
6728 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6729 } else {
6730 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6731 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6732 }
6733 if (SWIG_IsTmpObj(res2)) {
6734 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6735 } else {
6736 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6737 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6738 }
6739 if (SWIG_IsTmpObj(res3)) {
6740 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6741 } else {
6742 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6743 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6744 }
6745 if (SWIG_IsTmpObj(res4)) {
6746 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
6747 } else {
6748 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6749 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
6750 }
6751 return resultobj;
6752 fail:
6753 return NULL;
6754 }
6755
6756
6757 SWIGINTERN PyObject *_wrap_GetClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6758 PyObject *resultobj = 0;
6759 wxRect result;
6760
6761 if (!SWIG_Python_UnpackTuple(args,"GetClientDisplayRect",0,0,0)) SWIG_fail;
6762 {
6763 if (!wxPyCheckForApp()) SWIG_fail;
6764 PyThreadState* __tstate = wxPyBeginAllowThreads();
6765 result = wxGetClientDisplayRect();
6766 wxPyEndAllowThreads(__tstate);
6767 if (PyErr_Occurred()) SWIG_fail;
6768 }
6769 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6770 return resultobj;
6771 fail:
6772 return NULL;
6773 }
6774
6775
6776 SWIGINTERN PyObject *_wrap_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6777 PyObject *resultobj = 0;
6778 wxCursor *arg1 = 0 ;
6779 void *argp1 = 0 ;
6780 int res1 = 0 ;
6781 PyObject * obj0 = 0 ;
6782 char * kwnames[] = {
6783 (char *) "cursor", NULL
6784 };
6785
6786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) SWIG_fail;
6787 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxCursor, 0 );
6788 if (!SWIG_IsOK(res1)) {
6789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
6790 }
6791 if (!argp1) {
6792 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
6793 }
6794 arg1 = reinterpret_cast< wxCursor * >(argp1);
6795 {
6796 if (!wxPyCheckForApp()) SWIG_fail;
6797 PyThreadState* __tstate = wxPyBeginAllowThreads();
6798 wxSetCursor(*arg1);
6799 wxPyEndAllowThreads(__tstate);
6800 if (PyErr_Occurred()) SWIG_fail;
6801 }
6802 resultobj = SWIG_Py_Void();
6803 return resultobj;
6804 fail:
6805 return NULL;
6806 }
6807
6808
6809 SWIGINTERN PyObject *_wrap_GetXDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6810 PyObject *resultobj = 0;
6811 void *result = 0 ;
6812
6813 if (!SWIG_Python_UnpackTuple(args,"GetXDisplay",0,0,0)) SWIG_fail;
6814 {
6815 if (!wxPyCheckForApp()) SWIG_fail;
6816 PyThreadState* __tstate = wxPyBeginAllowThreads();
6817 result = (void *)wxGetXDisplay();
6818 wxPyEndAllowThreads(__tstate);
6819 if (PyErr_Occurred()) SWIG_fail;
6820 }
6821 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
6822 return resultobj;
6823 fail:
6824 return NULL;
6825 }
6826
6827
6828 SWIGINTERN PyObject *_wrap_BeginBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6829 PyObject *resultobj = 0;
6830 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
6831 void *argp1 = 0 ;
6832 int res1 = 0 ;
6833 PyObject * obj0 = 0 ;
6834 char * kwnames[] = {
6835 (char *) "cursor", NULL
6836 };
6837
6838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) SWIG_fail;
6839 if (obj0) {
6840 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
6841 if (!SWIG_IsOK(res1)) {
6842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeginBusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
6843 }
6844 arg1 = reinterpret_cast< wxCursor * >(argp1);
6845 }
6846 {
6847 if (!wxPyCheckForApp()) SWIG_fail;
6848 PyThreadState* __tstate = wxPyBeginAllowThreads();
6849 wxBeginBusyCursor(arg1);
6850 wxPyEndAllowThreads(__tstate);
6851 if (PyErr_Occurred()) SWIG_fail;
6852 }
6853 resultobj = SWIG_Py_Void();
6854 return resultobj;
6855 fail:
6856 return NULL;
6857 }
6858
6859
6860 SWIGINTERN PyObject *_wrap_GetMousePosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6861 PyObject *resultobj = 0;
6862 wxPoint result;
6863
6864 if (!SWIG_Python_UnpackTuple(args,"GetMousePosition",0,0,0)) SWIG_fail;
6865 {
6866 if (!wxPyCheckForApp()) SWIG_fail;
6867 PyThreadState* __tstate = wxPyBeginAllowThreads();
6868 result = wxGetMousePosition();
6869 wxPyEndAllowThreads(__tstate);
6870 if (PyErr_Occurred()) SWIG_fail;
6871 }
6872 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6873 return resultobj;
6874 fail:
6875 return NULL;
6876 }
6877
6878
6879 SWIGINTERN PyObject *_wrap_FindWindowAtPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6880 PyObject *resultobj = 0;
6881 wxWindow *result = 0 ;
6882
6883 if (!SWIG_Python_UnpackTuple(args,"FindWindowAtPointer",0,0,0)) SWIG_fail;
6884 {
6885 if (!wxPyCheckForApp()) SWIG_fail;
6886 PyThreadState* __tstate = wxPyBeginAllowThreads();
6887 result = (wxWindow *)FindWindowAtPointer();
6888 wxPyEndAllowThreads(__tstate);
6889 if (PyErr_Occurred()) SWIG_fail;
6890 }
6891 {
6892 resultobj = wxPyMake_wxObject(result, 0);
6893 }
6894 return resultobj;
6895 fail:
6896 return NULL;
6897 }
6898
6899
6900 SWIGINTERN PyObject *_wrap_GetActiveWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6901 PyObject *resultobj = 0;
6902 wxWindow *result = 0 ;
6903
6904 if (!SWIG_Python_UnpackTuple(args,"GetActiveWindow",0,0,0)) SWIG_fail;
6905 {
6906 if (!wxPyCheckForApp()) SWIG_fail;
6907 PyThreadState* __tstate = wxPyBeginAllowThreads();
6908 result = (wxWindow *)wxGetActiveWindow();
6909 wxPyEndAllowThreads(__tstate);
6910 if (PyErr_Occurred()) SWIG_fail;
6911 }
6912 {
6913 resultobj = wxPyMake_wxObject(result, 0);
6914 }
6915 return resultobj;
6916 fail:
6917 return NULL;
6918 }
6919
6920
6921 SWIGINTERN PyObject *_wrap_GenericFindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6922 PyObject *resultobj = 0;
6923 wxPoint *arg1 = 0 ;
6924 wxWindow *result = 0 ;
6925 wxPoint temp1 ;
6926 PyObject * obj0 = 0 ;
6927 char * kwnames[] = {
6928 (char *) "pt", NULL
6929 };
6930
6931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
6932 {
6933 arg1 = &temp1;
6934 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6935 }
6936 {
6937 if (!wxPyCheckForApp()) SWIG_fail;
6938 PyThreadState* __tstate = wxPyBeginAllowThreads();
6939 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
6940 wxPyEndAllowThreads(__tstate);
6941 if (PyErr_Occurred()) SWIG_fail;
6942 }
6943 {
6944 resultobj = wxPyMake_wxObject(result, 0);
6945 }
6946 return resultobj;
6947 fail:
6948 return NULL;
6949 }
6950
6951
6952 SWIGINTERN PyObject *_wrap_FindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6953 PyObject *resultobj = 0;
6954 wxPoint *arg1 = 0 ;
6955 wxWindow *result = 0 ;
6956 wxPoint temp1 ;
6957 PyObject * obj0 = 0 ;
6958 char * kwnames[] = {
6959 (char *) "pt", NULL
6960 };
6961
6962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
6963 {
6964 arg1 = &temp1;
6965 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6966 }
6967 {
6968 if (!wxPyCheckForApp()) SWIG_fail;
6969 PyThreadState* __tstate = wxPyBeginAllowThreads();
6970 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
6971 wxPyEndAllowThreads(__tstate);
6972 if (PyErr_Occurred()) SWIG_fail;
6973 }
6974 {
6975 resultobj = wxPyMake_wxObject(result, 0);
6976 }
6977 return resultobj;
6978 fail:
6979 return NULL;
6980 }
6981
6982
6983 SWIGINTERN PyObject *_wrap_GetTopLevelParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6984 PyObject *resultobj = 0;
6985 wxWindow *arg1 = (wxWindow *) 0 ;
6986 wxWindow *result = 0 ;
6987 void *argp1 = 0 ;
6988 int res1 = 0 ;
6989 PyObject * obj0 = 0 ;
6990 char * kwnames[] = {
6991 (char *) "win", NULL
6992 };
6993
6994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) SWIG_fail;
6995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
6996 if (!SWIG_IsOK(res1)) {
6997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetTopLevelParent" "', expected argument " "1"" of type '" "wxWindow *""'");
6998 }
6999 arg1 = reinterpret_cast< wxWindow * >(argp1);
7000 {
7001 if (!wxPyCheckForApp()) SWIG_fail;
7002 PyThreadState* __tstate = wxPyBeginAllowThreads();
7003 result = (wxWindow *)wxGetTopLevelParent(arg1);
7004 wxPyEndAllowThreads(__tstate);
7005 if (PyErr_Occurred()) SWIG_fail;
7006 }
7007 {
7008 resultobj = wxPyMake_wxObject(result, 0);
7009 }
7010 return resultobj;
7011 fail:
7012 return NULL;
7013 }
7014
7015
7016 SWIGINTERN PyObject *_wrap_LaunchDefaultBrowser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7017 PyObject *resultobj = 0;
7018 wxString *arg1 = 0 ;
7019 bool result;
7020 bool temp1 = false ;
7021 PyObject * obj0 = 0 ;
7022 char * kwnames[] = {
7023 (char *) "url", NULL
7024 };
7025
7026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LaunchDefaultBrowser",kwnames,&obj0)) SWIG_fail;
7027 {
7028 arg1 = wxString_in_helper(obj0);
7029 if (arg1 == NULL) SWIG_fail;
7030 temp1 = true;
7031 }
7032 {
7033 PyThreadState* __tstate = wxPyBeginAllowThreads();
7034 result = (bool)wxLaunchDefaultBrowser((wxString const &)*arg1);
7035 wxPyEndAllowThreads(__tstate);
7036 if (PyErr_Occurred()) SWIG_fail;
7037 }
7038 {
7039 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7040 }
7041 {
7042 if (temp1)
7043 delete arg1;
7044 }
7045 return resultobj;
7046 fail:
7047 {
7048 if (temp1)
7049 delete arg1;
7050 }
7051 return NULL;
7052 }
7053
7054
7055 SWIGINTERN PyObject *_wrap_GetKeyState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7056 PyObject *resultobj = 0;
7057 wxKeyCode arg1 ;
7058 bool result;
7059 int val1 ;
7060 int ecode1 = 0 ;
7061 PyObject * obj0 = 0 ;
7062 char * kwnames[] = {
7063 (char *) "key", NULL
7064 };
7065
7066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) SWIG_fail;
7067 ecode1 = SWIG_AsVal_int(obj0, &val1);
7068 if (!SWIG_IsOK(ecode1)) {
7069 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetKeyState" "', expected argument " "1"" of type '" "wxKeyCode""'");
7070 }
7071 arg1 = static_cast< wxKeyCode >(val1);
7072 {
7073 if (!wxPyCheckForApp()) SWIG_fail;
7074 PyThreadState* __tstate = wxPyBeginAllowThreads();
7075 result = (bool)wxGetKeyState(arg1);
7076 wxPyEndAllowThreads(__tstate);
7077 if (PyErr_Occurred()) SWIG_fail;
7078 }
7079 {
7080 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7081 }
7082 return resultobj;
7083 fail:
7084 return NULL;
7085 }
7086
7087
7088 SWIGINTERN PyObject *_wrap_new_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7089 PyObject *resultobj = 0;
7090 wxMouseState *result = 0 ;
7091
7092 if (!SWIG_Python_UnpackTuple(args,"new_MouseState",0,0,0)) SWIG_fail;
7093 {
7094 PyThreadState* __tstate = wxPyBeginAllowThreads();
7095 result = (wxMouseState *)new wxMouseState();
7096 wxPyEndAllowThreads(__tstate);
7097 if (PyErr_Occurred()) SWIG_fail;
7098 }
7099 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseState, SWIG_POINTER_NEW | 0 );
7100 return resultobj;
7101 fail:
7102 return NULL;
7103 }
7104
7105
7106 SWIGINTERN PyObject *_wrap_delete_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7107 PyObject *resultobj = 0;
7108 wxMouseState *arg1 = (wxMouseState *) 0 ;
7109 void *argp1 = 0 ;
7110 int res1 = 0 ;
7111 PyObject *swig_obj[1] ;
7112
7113 if (!args) SWIG_fail;
7114 swig_obj[0] = args;
7115 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, SWIG_POINTER_DISOWN | 0 );
7116 if (!SWIG_IsOK(res1)) {
7117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MouseState" "', expected argument " "1"" of type '" "wxMouseState *""'");
7118 }
7119 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7120 {
7121 PyThreadState* __tstate = wxPyBeginAllowThreads();
7122 delete arg1;
7123
7124 wxPyEndAllowThreads(__tstate);
7125 if (PyErr_Occurred()) SWIG_fail;
7126 }
7127 resultobj = SWIG_Py_Void();
7128 return resultobj;
7129 fail:
7130 return NULL;
7131 }
7132
7133
7134 SWIGINTERN PyObject *_wrap_MouseState_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7135 PyObject *resultobj = 0;
7136 wxMouseState *arg1 = (wxMouseState *) 0 ;
7137 int result;
7138 void *argp1 = 0 ;
7139 int res1 = 0 ;
7140 PyObject *swig_obj[1] ;
7141
7142 if (!args) SWIG_fail;
7143 swig_obj[0] = args;
7144 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7145 if (!SWIG_IsOK(res1)) {
7146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7147 }
7148 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7149 {
7150 PyThreadState* __tstate = wxPyBeginAllowThreads();
7151 result = (int)(arg1)->GetX();
7152 wxPyEndAllowThreads(__tstate);
7153 if (PyErr_Occurred()) SWIG_fail;
7154 }
7155 resultobj = SWIG_From_int(static_cast< int >(result));
7156 return resultobj;
7157 fail:
7158 return NULL;
7159 }
7160
7161
7162 SWIGINTERN PyObject *_wrap_MouseState_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7163 PyObject *resultobj = 0;
7164 wxMouseState *arg1 = (wxMouseState *) 0 ;
7165 int result;
7166 void *argp1 = 0 ;
7167 int res1 = 0 ;
7168 PyObject *swig_obj[1] ;
7169
7170 if (!args) SWIG_fail;
7171 swig_obj[0] = args;
7172 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7173 if (!SWIG_IsOK(res1)) {
7174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7175 }
7176 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7177 {
7178 PyThreadState* __tstate = wxPyBeginAllowThreads();
7179 result = (int)(arg1)->GetY();
7180 wxPyEndAllowThreads(__tstate);
7181 if (PyErr_Occurred()) SWIG_fail;
7182 }
7183 resultobj = SWIG_From_int(static_cast< int >(result));
7184 return resultobj;
7185 fail:
7186 return NULL;
7187 }
7188
7189
7190 SWIGINTERN PyObject *_wrap_MouseState_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7191 PyObject *resultobj = 0;
7192 wxMouseState *arg1 = (wxMouseState *) 0 ;
7193 bool result;
7194 void *argp1 = 0 ;
7195 int res1 = 0 ;
7196 PyObject *swig_obj[1] ;
7197
7198 if (!args) SWIG_fail;
7199 swig_obj[0] = args;
7200 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7201 if (!SWIG_IsOK(res1)) {
7202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_LeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7203 }
7204 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7205 {
7206 PyThreadState* __tstate = wxPyBeginAllowThreads();
7207 result = (bool)(arg1)->LeftDown();
7208 wxPyEndAllowThreads(__tstate);
7209 if (PyErr_Occurred()) SWIG_fail;
7210 }
7211 {
7212 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7213 }
7214 return resultobj;
7215 fail:
7216 return NULL;
7217 }
7218
7219
7220 SWIGINTERN PyObject *_wrap_MouseState_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7221 PyObject *resultobj = 0;
7222 wxMouseState *arg1 = (wxMouseState *) 0 ;
7223 bool result;
7224 void *argp1 = 0 ;
7225 int res1 = 0 ;
7226 PyObject *swig_obj[1] ;
7227
7228 if (!args) SWIG_fail;
7229 swig_obj[0] = args;
7230 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7231 if (!SWIG_IsOK(res1)) {
7232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7233 }
7234 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7235 {
7236 PyThreadState* __tstate = wxPyBeginAllowThreads();
7237 result = (bool)(arg1)->MiddleDown();
7238 wxPyEndAllowThreads(__tstate);
7239 if (PyErr_Occurred()) SWIG_fail;
7240 }
7241 {
7242 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7243 }
7244 return resultobj;
7245 fail:
7246 return NULL;
7247 }
7248
7249
7250 SWIGINTERN PyObject *_wrap_MouseState_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7251 PyObject *resultobj = 0;
7252 wxMouseState *arg1 = (wxMouseState *) 0 ;
7253 bool result;
7254 void *argp1 = 0 ;
7255 int res1 = 0 ;
7256 PyObject *swig_obj[1] ;
7257
7258 if (!args) SWIG_fail;
7259 swig_obj[0] = args;
7260 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7261 if (!SWIG_IsOK(res1)) {
7262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_RightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7263 }
7264 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7265 {
7266 PyThreadState* __tstate = wxPyBeginAllowThreads();
7267 result = (bool)(arg1)->RightDown();
7268 wxPyEndAllowThreads(__tstate);
7269 if (PyErr_Occurred()) SWIG_fail;
7270 }
7271 {
7272 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7273 }
7274 return resultobj;
7275 fail:
7276 return NULL;
7277 }
7278
7279
7280 SWIGINTERN PyObject *_wrap_MouseState_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7281 PyObject *resultobj = 0;
7282 wxMouseState *arg1 = (wxMouseState *) 0 ;
7283 bool result;
7284 void *argp1 = 0 ;
7285 int res1 = 0 ;
7286 PyObject *swig_obj[1] ;
7287
7288 if (!args) SWIG_fail;
7289 swig_obj[0] = args;
7290 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7291 if (!SWIG_IsOK(res1)) {
7292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7293 }
7294 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7295 {
7296 PyThreadState* __tstate = wxPyBeginAllowThreads();
7297 result = (bool)(arg1)->ControlDown();
7298 wxPyEndAllowThreads(__tstate);
7299 if (PyErr_Occurred()) SWIG_fail;
7300 }
7301 {
7302 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7303 }
7304 return resultobj;
7305 fail:
7306 return NULL;
7307 }
7308
7309
7310 SWIGINTERN PyObject *_wrap_MouseState_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7311 PyObject *resultobj = 0;
7312 wxMouseState *arg1 = (wxMouseState *) 0 ;
7313 bool result;
7314 void *argp1 = 0 ;
7315 int res1 = 0 ;
7316 PyObject *swig_obj[1] ;
7317
7318 if (!args) SWIG_fail;
7319 swig_obj[0] = args;
7320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7321 if (!SWIG_IsOK(res1)) {
7322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7323 }
7324 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7325 {
7326 PyThreadState* __tstate = wxPyBeginAllowThreads();
7327 result = (bool)(arg1)->ShiftDown();
7328 wxPyEndAllowThreads(__tstate);
7329 if (PyErr_Occurred()) SWIG_fail;
7330 }
7331 {
7332 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7333 }
7334 return resultobj;
7335 fail:
7336 return NULL;
7337 }
7338
7339
7340 SWIGINTERN PyObject *_wrap_MouseState_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7341 PyObject *resultobj = 0;
7342 wxMouseState *arg1 = (wxMouseState *) 0 ;
7343 bool result;
7344 void *argp1 = 0 ;
7345 int res1 = 0 ;
7346 PyObject *swig_obj[1] ;
7347
7348 if (!args) SWIG_fail;
7349 swig_obj[0] = args;
7350 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7351 if (!SWIG_IsOK(res1)) {
7352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_AltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7353 }
7354 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7355 {
7356 PyThreadState* __tstate = wxPyBeginAllowThreads();
7357 result = (bool)(arg1)->AltDown();
7358 wxPyEndAllowThreads(__tstate);
7359 if (PyErr_Occurred()) SWIG_fail;
7360 }
7361 {
7362 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7363 }
7364 return resultobj;
7365 fail:
7366 return NULL;
7367 }
7368
7369
7370 SWIGINTERN PyObject *_wrap_MouseState_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7371 PyObject *resultobj = 0;
7372 wxMouseState *arg1 = (wxMouseState *) 0 ;
7373 bool result;
7374 void *argp1 = 0 ;
7375 int res1 = 0 ;
7376 PyObject *swig_obj[1] ;
7377
7378 if (!args) SWIG_fail;
7379 swig_obj[0] = args;
7380 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7381 if (!SWIG_IsOK(res1)) {
7382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7383 }
7384 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7385 {
7386 PyThreadState* __tstate = wxPyBeginAllowThreads();
7387 result = (bool)(arg1)->MetaDown();
7388 wxPyEndAllowThreads(__tstate);
7389 if (PyErr_Occurred()) SWIG_fail;
7390 }
7391 {
7392 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7393 }
7394 return resultobj;
7395 fail:
7396 return NULL;
7397 }
7398
7399
7400 SWIGINTERN PyObject *_wrap_MouseState_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7401 PyObject *resultobj = 0;
7402 wxMouseState *arg1 = (wxMouseState *) 0 ;
7403 bool result;
7404 void *argp1 = 0 ;
7405 int res1 = 0 ;
7406 PyObject *swig_obj[1] ;
7407
7408 if (!args) SWIG_fail;
7409 swig_obj[0] = args;
7410 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7411 if (!SWIG_IsOK(res1)) {
7412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_CmdDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7413 }
7414 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7415 {
7416 PyThreadState* __tstate = wxPyBeginAllowThreads();
7417 result = (bool)(arg1)->CmdDown();
7418 wxPyEndAllowThreads(__tstate);
7419 if (PyErr_Occurred()) SWIG_fail;
7420 }
7421 {
7422 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7423 }
7424 return resultobj;
7425 fail:
7426 return NULL;
7427 }
7428
7429
7430 SWIGINTERN PyObject *_wrap_MouseState_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7431 PyObject *resultobj = 0;
7432 wxMouseState *arg1 = (wxMouseState *) 0 ;
7433 int arg2 ;
7434 void *argp1 = 0 ;
7435 int res1 = 0 ;
7436 int val2 ;
7437 int ecode2 = 0 ;
7438 PyObject * obj0 = 0 ;
7439 PyObject * obj1 = 0 ;
7440 char * kwnames[] = {
7441 (char *) "self",(char *) "x", NULL
7442 };
7443
7444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
7445 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7446 if (!SWIG_IsOK(res1)) {
7447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7448 }
7449 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7450 ecode2 = SWIG_AsVal_int(obj1, &val2);
7451 if (!SWIG_IsOK(ecode2)) {
7452 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetX" "', expected argument " "2"" of type '" "int""'");
7453 }
7454 arg2 = static_cast< int >(val2);
7455 {
7456 PyThreadState* __tstate = wxPyBeginAllowThreads();
7457 (arg1)->SetX(arg2);
7458 wxPyEndAllowThreads(__tstate);
7459 if (PyErr_Occurred()) SWIG_fail;
7460 }
7461 resultobj = SWIG_Py_Void();
7462 return resultobj;
7463 fail:
7464 return NULL;
7465 }
7466
7467
7468 SWIGINTERN PyObject *_wrap_MouseState_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7469 PyObject *resultobj = 0;
7470 wxMouseState *arg1 = (wxMouseState *) 0 ;
7471 int arg2 ;
7472 void *argp1 = 0 ;
7473 int res1 = 0 ;
7474 int val2 ;
7475 int ecode2 = 0 ;
7476 PyObject * obj0 = 0 ;
7477 PyObject * obj1 = 0 ;
7478 char * kwnames[] = {
7479 (char *) "self",(char *) "y", NULL
7480 };
7481
7482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
7483 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7484 if (!SWIG_IsOK(res1)) {
7485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7486 }
7487 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7488 ecode2 = SWIG_AsVal_int(obj1, &val2);
7489 if (!SWIG_IsOK(ecode2)) {
7490 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetY" "', expected argument " "2"" of type '" "int""'");
7491 }
7492 arg2 = static_cast< int >(val2);
7493 {
7494 PyThreadState* __tstate = wxPyBeginAllowThreads();
7495 (arg1)->SetY(arg2);
7496 wxPyEndAllowThreads(__tstate);
7497 if (PyErr_Occurred()) SWIG_fail;
7498 }
7499 resultobj = SWIG_Py_Void();
7500 return resultobj;
7501 fail:
7502 return NULL;
7503 }
7504
7505
7506 SWIGINTERN PyObject *_wrap_MouseState_SetLeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7507 PyObject *resultobj = 0;
7508 wxMouseState *arg1 = (wxMouseState *) 0 ;
7509 bool arg2 ;
7510 void *argp1 = 0 ;
7511 int res1 = 0 ;
7512 bool val2 ;
7513 int ecode2 = 0 ;
7514 PyObject * obj0 = 0 ;
7515 PyObject * obj1 = 0 ;
7516 char * kwnames[] = {
7517 (char *) "self",(char *) "down", NULL
7518 };
7519
7520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetLeftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7521 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7522 if (!SWIG_IsOK(res1)) {
7523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetLeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7524 }
7525 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7526 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7527 if (!SWIG_IsOK(ecode2)) {
7528 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetLeftDown" "', expected argument " "2"" of type '" "bool""'");
7529 }
7530 arg2 = static_cast< bool >(val2);
7531 {
7532 PyThreadState* __tstate = wxPyBeginAllowThreads();
7533 (arg1)->SetLeftDown(arg2);
7534 wxPyEndAllowThreads(__tstate);
7535 if (PyErr_Occurred()) SWIG_fail;
7536 }
7537 resultobj = SWIG_Py_Void();
7538 return resultobj;
7539 fail:
7540 return NULL;
7541 }
7542
7543
7544 SWIGINTERN PyObject *_wrap_MouseState_SetMiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7545 PyObject *resultobj = 0;
7546 wxMouseState *arg1 = (wxMouseState *) 0 ;
7547 bool arg2 ;
7548 void *argp1 = 0 ;
7549 int res1 = 0 ;
7550 bool val2 ;
7551 int ecode2 = 0 ;
7552 PyObject * obj0 = 0 ;
7553 PyObject * obj1 = 0 ;
7554 char * kwnames[] = {
7555 (char *) "self",(char *) "down", NULL
7556 };
7557
7558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMiddleDown",kwnames,&obj0,&obj1)) SWIG_fail;
7559 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7560 if (!SWIG_IsOK(res1)) {
7561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7562 }
7563 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7564 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7565 if (!SWIG_IsOK(ecode2)) {
7566 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMiddleDown" "', expected argument " "2"" of type '" "bool""'");
7567 }
7568 arg2 = static_cast< bool >(val2);
7569 {
7570 PyThreadState* __tstate = wxPyBeginAllowThreads();
7571 (arg1)->SetMiddleDown(arg2);
7572 wxPyEndAllowThreads(__tstate);
7573 if (PyErr_Occurred()) SWIG_fail;
7574 }
7575 resultobj = SWIG_Py_Void();
7576 return resultobj;
7577 fail:
7578 return NULL;
7579 }
7580
7581
7582 SWIGINTERN PyObject *_wrap_MouseState_SetRightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7583 PyObject *resultobj = 0;
7584 wxMouseState *arg1 = (wxMouseState *) 0 ;
7585 bool arg2 ;
7586 void *argp1 = 0 ;
7587 int res1 = 0 ;
7588 bool val2 ;
7589 int ecode2 = 0 ;
7590 PyObject * obj0 = 0 ;
7591 PyObject * obj1 = 0 ;
7592 char * kwnames[] = {
7593 (char *) "self",(char *) "down", NULL
7594 };
7595
7596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetRightDown",kwnames,&obj0,&obj1)) SWIG_fail;
7597 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7598 if (!SWIG_IsOK(res1)) {
7599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetRightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7600 }
7601 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7602 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7603 if (!SWIG_IsOK(ecode2)) {
7604 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetRightDown" "', expected argument " "2"" of type '" "bool""'");
7605 }
7606 arg2 = static_cast< bool >(val2);
7607 {
7608 PyThreadState* __tstate = wxPyBeginAllowThreads();
7609 (arg1)->SetRightDown(arg2);
7610 wxPyEndAllowThreads(__tstate);
7611 if (PyErr_Occurred()) SWIG_fail;
7612 }
7613 resultobj = SWIG_Py_Void();
7614 return resultobj;
7615 fail:
7616 return NULL;
7617 }
7618
7619
7620 SWIGINTERN PyObject *_wrap_MouseState_SetControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7621 PyObject *resultobj = 0;
7622 wxMouseState *arg1 = (wxMouseState *) 0 ;
7623 bool arg2 ;
7624 void *argp1 = 0 ;
7625 int res1 = 0 ;
7626 bool val2 ;
7627 int ecode2 = 0 ;
7628 PyObject * obj0 = 0 ;
7629 PyObject * obj1 = 0 ;
7630 char * kwnames[] = {
7631 (char *) "self",(char *) "down", NULL
7632 };
7633
7634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetControlDown",kwnames,&obj0,&obj1)) SWIG_fail;
7635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7636 if (!SWIG_IsOK(res1)) {
7637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7638 }
7639 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7640 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7641 if (!SWIG_IsOK(ecode2)) {
7642 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetControlDown" "', expected argument " "2"" of type '" "bool""'");
7643 }
7644 arg2 = static_cast< bool >(val2);
7645 {
7646 PyThreadState* __tstate = wxPyBeginAllowThreads();
7647 (arg1)->SetControlDown(arg2);
7648 wxPyEndAllowThreads(__tstate);
7649 if (PyErr_Occurred()) SWIG_fail;
7650 }
7651 resultobj = SWIG_Py_Void();
7652 return resultobj;
7653 fail:
7654 return NULL;
7655 }
7656
7657
7658 SWIGINTERN PyObject *_wrap_MouseState_SetShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7659 PyObject *resultobj = 0;
7660 wxMouseState *arg1 = (wxMouseState *) 0 ;
7661 bool arg2 ;
7662 void *argp1 = 0 ;
7663 int res1 = 0 ;
7664 bool val2 ;
7665 int ecode2 = 0 ;
7666 PyObject * obj0 = 0 ;
7667 PyObject * obj1 = 0 ;
7668 char * kwnames[] = {
7669 (char *) "self",(char *) "down", NULL
7670 };
7671
7672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetShiftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7673 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7674 if (!SWIG_IsOK(res1)) {
7675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7676 }
7677 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7678 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7679 if (!SWIG_IsOK(ecode2)) {
7680 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetShiftDown" "', expected argument " "2"" of type '" "bool""'");
7681 }
7682 arg2 = static_cast< bool >(val2);
7683 {
7684 PyThreadState* __tstate = wxPyBeginAllowThreads();
7685 (arg1)->SetShiftDown(arg2);
7686 wxPyEndAllowThreads(__tstate);
7687 if (PyErr_Occurred()) SWIG_fail;
7688 }
7689 resultobj = SWIG_Py_Void();
7690 return resultobj;
7691 fail:
7692 return NULL;
7693 }
7694
7695
7696 SWIGINTERN PyObject *_wrap_MouseState_SetAltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7697 PyObject *resultobj = 0;
7698 wxMouseState *arg1 = (wxMouseState *) 0 ;
7699 bool arg2 ;
7700 void *argp1 = 0 ;
7701 int res1 = 0 ;
7702 bool val2 ;
7703 int ecode2 = 0 ;
7704 PyObject * obj0 = 0 ;
7705 PyObject * obj1 = 0 ;
7706 char * kwnames[] = {
7707 (char *) "self",(char *) "down", NULL
7708 };
7709
7710 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetAltDown",kwnames,&obj0,&obj1)) SWIG_fail;
7711 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7712 if (!SWIG_IsOK(res1)) {
7713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetAltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7714 }
7715 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7716 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7717 if (!SWIG_IsOK(ecode2)) {
7718 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetAltDown" "', expected argument " "2"" of type '" "bool""'");
7719 }
7720 arg2 = static_cast< bool >(val2);
7721 {
7722 PyThreadState* __tstate = wxPyBeginAllowThreads();
7723 (arg1)->SetAltDown(arg2);
7724 wxPyEndAllowThreads(__tstate);
7725 if (PyErr_Occurred()) SWIG_fail;
7726 }
7727 resultobj = SWIG_Py_Void();
7728 return resultobj;
7729 fail:
7730 return NULL;
7731 }
7732
7733
7734 SWIGINTERN PyObject *_wrap_MouseState_SetMetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7735 PyObject *resultobj = 0;
7736 wxMouseState *arg1 = (wxMouseState *) 0 ;
7737 bool arg2 ;
7738 void *argp1 = 0 ;
7739 int res1 = 0 ;
7740 bool val2 ;
7741 int ecode2 = 0 ;
7742 PyObject * obj0 = 0 ;
7743 PyObject * obj1 = 0 ;
7744 char * kwnames[] = {
7745 (char *) "self",(char *) "down", NULL
7746 };
7747
7748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMetaDown",kwnames,&obj0,&obj1)) SWIG_fail;
7749 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7750 if (!SWIG_IsOK(res1)) {
7751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7752 }
7753 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7754 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7755 if (!SWIG_IsOK(ecode2)) {
7756 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMetaDown" "', expected argument " "2"" of type '" "bool""'");
7757 }
7758 arg2 = static_cast< bool >(val2);
7759 {
7760 PyThreadState* __tstate = wxPyBeginAllowThreads();
7761 (arg1)->SetMetaDown(arg2);
7762 wxPyEndAllowThreads(__tstate);
7763 if (PyErr_Occurred()) SWIG_fail;
7764 }
7765 resultobj = SWIG_Py_Void();
7766 return resultobj;
7767 fail:
7768 return NULL;
7769 }
7770
7771
7772 SWIGINTERN PyObject *MouseState_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7773 PyObject *obj;
7774 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7775 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseState, SWIG_NewClientData(obj));
7776 return SWIG_Py_Void();
7777 }
7778
7779 SWIGINTERN PyObject *MouseState_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7780 return SWIG_Python_InitShadowInstance(args);
7781 }
7782
7783 SWIGINTERN PyObject *_wrap_GetMouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7784 PyObject *resultobj = 0;
7785 wxMouseState result;
7786
7787 if (!SWIG_Python_UnpackTuple(args,"GetMouseState",0,0,0)) SWIG_fail;
7788 {
7789 PyThreadState* __tstate = wxPyBeginAllowThreads();
7790 result = wxGetMouseState();
7791 wxPyEndAllowThreads(__tstate);
7792 if (PyErr_Occurred()) SWIG_fail;
7793 }
7794 resultobj = SWIG_NewPointerObj((new wxMouseState(static_cast< const wxMouseState& >(result))), SWIGTYPE_p_wxMouseState, SWIG_POINTER_OWN | 0 );
7795 return resultobj;
7796 fail:
7797 return NULL;
7798 }
7799
7800
7801 SWIGINTERN PyObject *_wrap_WakeUpMainThread(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7802 PyObject *resultobj = 0;
7803
7804 if (!SWIG_Python_UnpackTuple(args,"WakeUpMainThread",0,0,0)) SWIG_fail;
7805 {
7806 if (!wxPyCheckForApp()) SWIG_fail;
7807 PyThreadState* __tstate = wxPyBeginAllowThreads();
7808 wxWakeUpMainThread();
7809 wxPyEndAllowThreads(__tstate);
7810 if (PyErr_Occurred()) SWIG_fail;
7811 }
7812 resultobj = SWIG_Py_Void();
7813 return resultobj;
7814 fail:
7815 return NULL;
7816 }
7817
7818
7819 SWIGINTERN PyObject *_wrap_MutexGuiEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7820 PyObject *resultobj = 0;
7821
7822 if (!SWIG_Python_UnpackTuple(args,"MutexGuiEnter",0,0,0)) SWIG_fail;
7823 {
7824 if (!wxPyCheckForApp()) SWIG_fail;
7825 PyThreadState* __tstate = wxPyBeginAllowThreads();
7826 wxMutexGuiEnter();
7827 wxPyEndAllowThreads(__tstate);
7828 if (PyErr_Occurred()) SWIG_fail;
7829 }
7830 resultobj = SWIG_Py_Void();
7831 return resultobj;
7832 fail:
7833 return NULL;
7834 }
7835
7836
7837 SWIGINTERN PyObject *_wrap_MutexGuiLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7838 PyObject *resultobj = 0;
7839
7840 if (!SWIG_Python_UnpackTuple(args,"MutexGuiLeave",0,0,0)) SWIG_fail;
7841 {
7842 if (!wxPyCheckForApp()) SWIG_fail;
7843 PyThreadState* __tstate = wxPyBeginAllowThreads();
7844 wxMutexGuiLeave();
7845 wxPyEndAllowThreads(__tstate);
7846 if (PyErr_Occurred()) SWIG_fail;
7847 }
7848 resultobj = SWIG_Py_Void();
7849 return resultobj;
7850 fail:
7851 return NULL;
7852 }
7853
7854
7855 SWIGINTERN PyObject *_wrap_new_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7856 PyObject *resultobj = 0;
7857 wxMutexGuiLocker *result = 0 ;
7858
7859 if (!SWIG_Python_UnpackTuple(args,"new_MutexGuiLocker",0,0,0)) SWIG_fail;
7860 {
7861 if (!wxPyCheckForApp()) SWIG_fail;
7862 PyThreadState* __tstate = wxPyBeginAllowThreads();
7863 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
7864 wxPyEndAllowThreads(__tstate);
7865 if (PyErr_Occurred()) SWIG_fail;
7866 }
7867 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_NEW | 0 );
7868 return resultobj;
7869 fail:
7870 return NULL;
7871 }
7872
7873
7874 SWIGINTERN PyObject *_wrap_delete_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7875 PyObject *resultobj = 0;
7876 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
7877 void *argp1 = 0 ;
7878 int res1 = 0 ;
7879 PyObject *swig_obj[1] ;
7880
7881 if (!args) SWIG_fail;
7882 swig_obj[0] = args;
7883 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_DISOWN | 0 );
7884 if (!SWIG_IsOK(res1)) {
7885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MutexGuiLocker" "', expected argument " "1"" of type '" "wxMutexGuiLocker *""'");
7886 }
7887 arg1 = reinterpret_cast< wxMutexGuiLocker * >(argp1);
7888 {
7889 PyThreadState* __tstate = wxPyBeginAllowThreads();
7890 delete arg1;
7891
7892 wxPyEndAllowThreads(__tstate);
7893 if (PyErr_Occurred()) SWIG_fail;
7894 }
7895 resultobj = SWIG_Py_Void();
7896 return resultobj;
7897 fail:
7898 return NULL;
7899 }
7900
7901
7902 SWIGINTERN PyObject *MutexGuiLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7903 PyObject *obj;
7904 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7905 SWIG_TypeNewClientData(SWIGTYPE_p_wxMutexGuiLocker, SWIG_NewClientData(obj));
7906 return SWIG_Py_Void();
7907 }
7908
7909 SWIGINTERN PyObject *MutexGuiLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7910 return SWIG_Python_InitShadowInstance(args);
7911 }
7912
7913 SWIGINTERN PyObject *_wrap_Thread_IsMain(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7914 PyObject *resultobj = 0;
7915 bool result;
7916
7917 if (!SWIG_Python_UnpackTuple(args,"Thread_IsMain",0,0,0)) SWIG_fail;
7918 {
7919 PyThreadState* __tstate = wxPyBeginAllowThreads();
7920 result = (bool)wxThread_IsMain();
7921 wxPyEndAllowThreads(__tstate);
7922 if (PyErr_Occurred()) SWIG_fail;
7923 }
7924 {
7925 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7926 }
7927 return resultobj;
7928 fail:
7929 return NULL;
7930 }
7931
7932
7933 SWIGINTERN PyObject *_wrap_new_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7934 PyObject *resultobj = 0;
7935 wxString *arg1 = 0 ;
7936 wxToolTip *result = 0 ;
7937 bool temp1 = false ;
7938 PyObject * obj0 = 0 ;
7939 char * kwnames[] = {
7940 (char *) "tip", NULL
7941 };
7942
7943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) SWIG_fail;
7944 {
7945 arg1 = wxString_in_helper(obj0);
7946 if (arg1 == NULL) SWIG_fail;
7947 temp1 = true;
7948 }
7949 {
7950 if (!wxPyCheckForApp()) SWIG_fail;
7951 PyThreadState* __tstate = wxPyBeginAllowThreads();
7952 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
7953 wxPyEndAllowThreads(__tstate);
7954 if (PyErr_Occurred()) SWIG_fail;
7955 }
7956 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxToolTip, SWIG_POINTER_NEW | 0 );
7957 {
7958 if (temp1)
7959 delete arg1;
7960 }
7961 return resultobj;
7962 fail:
7963 {
7964 if (temp1)
7965 delete arg1;
7966 }
7967 return NULL;
7968 }
7969
7970
7971 SWIGINTERN PyObject *_wrap_delete_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7972 PyObject *resultobj = 0;
7973 wxToolTip *arg1 = (wxToolTip *) 0 ;
7974 void *argp1 = 0 ;
7975 int res1 = 0 ;
7976 PyObject *swig_obj[1] ;
7977
7978 if (!args) SWIG_fail;
7979 swig_obj[0] = args;
7980 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
7981 if (!SWIG_IsOK(res1)) {
7982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ToolTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
7983 }
7984 arg1 = reinterpret_cast< wxToolTip * >(argp1);
7985 {
7986 PyThreadState* __tstate = wxPyBeginAllowThreads();
7987 delete arg1;
7988
7989 wxPyEndAllowThreads(__tstate);
7990 if (PyErr_Occurred()) SWIG_fail;
7991 }
7992 resultobj = SWIG_Py_Void();
7993 return resultobj;
7994 fail:
7995 return NULL;
7996 }
7997
7998
7999 SWIGINTERN PyObject *_wrap_ToolTip_SetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8000 PyObject *resultobj = 0;
8001 wxToolTip *arg1 = (wxToolTip *) 0 ;
8002 wxString *arg2 = 0 ;
8003 void *argp1 = 0 ;
8004 int res1 = 0 ;
8005 bool temp2 = false ;
8006 PyObject * obj0 = 0 ;
8007 PyObject * obj1 = 0 ;
8008 char * kwnames[] = {
8009 (char *) "self",(char *) "tip", NULL
8010 };
8011
8012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) SWIG_fail;
8013 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8014 if (!SWIG_IsOK(res1)) {
8015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_SetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8016 }
8017 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8018 {
8019 arg2 = wxString_in_helper(obj1);
8020 if (arg2 == NULL) SWIG_fail;
8021 temp2 = true;
8022 }
8023 {
8024 PyThreadState* __tstate = wxPyBeginAllowThreads();
8025 (arg1)->SetTip((wxString const &)*arg2);
8026 wxPyEndAllowThreads(__tstate);
8027 if (PyErr_Occurred()) SWIG_fail;
8028 }
8029 resultobj = SWIG_Py_Void();
8030 {
8031 if (temp2)
8032 delete arg2;
8033 }
8034 return resultobj;
8035 fail:
8036 {
8037 if (temp2)
8038 delete arg2;
8039 }
8040 return NULL;
8041 }
8042
8043
8044 SWIGINTERN PyObject *_wrap_ToolTip_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8045 PyObject *resultobj = 0;
8046 wxToolTip *arg1 = (wxToolTip *) 0 ;
8047 wxString result;
8048 void *argp1 = 0 ;
8049 int res1 = 0 ;
8050 PyObject *swig_obj[1] ;
8051
8052 if (!args) SWIG_fail;
8053 swig_obj[0] = args;
8054 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8055 if (!SWIG_IsOK(res1)) {
8056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8057 }
8058 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8059 {
8060 PyThreadState* __tstate = wxPyBeginAllowThreads();
8061 result = (arg1)->GetTip();
8062 wxPyEndAllowThreads(__tstate);
8063 if (PyErr_Occurred()) SWIG_fail;
8064 }
8065 {
8066 #if wxUSE_UNICODE
8067 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8068 #else
8069 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8070 #endif
8071 }
8072 return resultobj;
8073 fail:
8074 return NULL;
8075 }
8076
8077
8078 SWIGINTERN PyObject *_wrap_ToolTip_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8079 PyObject *resultobj = 0;
8080 wxToolTip *arg1 = (wxToolTip *) 0 ;
8081 wxWindow *result = 0 ;
8082 void *argp1 = 0 ;
8083 int res1 = 0 ;
8084 PyObject *swig_obj[1] ;
8085
8086 if (!args) SWIG_fail;
8087 swig_obj[0] = args;
8088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8089 if (!SWIG_IsOK(res1)) {
8090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetWindow" "', expected argument " "1"" of type '" "wxToolTip *""'");
8091 }
8092 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8093 {
8094 PyThreadState* __tstate = wxPyBeginAllowThreads();
8095 result = (wxWindow *)(arg1)->GetWindow();
8096 wxPyEndAllowThreads(__tstate);
8097 if (PyErr_Occurred()) SWIG_fail;
8098 }
8099 {
8100 resultobj = wxPyMake_wxObject(result, 0);
8101 }
8102 return resultobj;
8103 fail:
8104 return NULL;
8105 }
8106
8107
8108 SWIGINTERN PyObject *_wrap_ToolTip_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8109 PyObject *resultobj = 0;
8110 bool arg1 ;
8111 bool val1 ;
8112 int ecode1 = 0 ;
8113 PyObject * obj0 = 0 ;
8114 char * kwnames[] = {
8115 (char *) "flag", NULL
8116 };
8117
8118 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) SWIG_fail;
8119 ecode1 = SWIG_AsVal_bool(obj0, &val1);
8120 if (!SWIG_IsOK(ecode1)) {
8121 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_Enable" "', expected argument " "1"" of type '" "bool""'");
8122 }
8123 arg1 = static_cast< bool >(val1);
8124 {
8125 PyThreadState* __tstate = wxPyBeginAllowThreads();
8126 wxToolTip::Enable(arg1);
8127 wxPyEndAllowThreads(__tstate);
8128 if (PyErr_Occurred()) SWIG_fail;
8129 }
8130 resultobj = SWIG_Py_Void();
8131 return resultobj;
8132 fail:
8133 return NULL;
8134 }
8135
8136
8137 SWIGINTERN PyObject *_wrap_ToolTip_SetDelay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8138 PyObject *resultobj = 0;
8139 long arg1 ;
8140 long val1 ;
8141 int ecode1 = 0 ;
8142 PyObject * obj0 = 0 ;
8143 char * kwnames[] = {
8144 (char *) "milliseconds", NULL
8145 };
8146
8147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) SWIG_fail;
8148 ecode1 = SWIG_AsVal_long(obj0, &val1);
8149 if (!SWIG_IsOK(ecode1)) {
8150 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_SetDelay" "', expected argument " "1"" of type '" "long""'");
8151 }
8152 arg1 = static_cast< long >(val1);
8153 {
8154 PyThreadState* __tstate = wxPyBeginAllowThreads();
8155 wxToolTip::SetDelay(arg1);
8156 wxPyEndAllowThreads(__tstate);
8157 if (PyErr_Occurred()) SWIG_fail;
8158 }
8159 resultobj = SWIG_Py_Void();
8160 return resultobj;
8161 fail:
8162 return NULL;
8163 }
8164
8165
8166 SWIGINTERN PyObject *ToolTip_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8167 PyObject *obj;
8168 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8169 SWIG_TypeNewClientData(SWIGTYPE_p_wxToolTip, SWIG_NewClientData(obj));
8170 return SWIG_Py_Void();
8171 }
8172
8173 SWIGINTERN PyObject *ToolTip_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8174 return SWIG_Python_InitShadowInstance(args);
8175 }
8176
8177 SWIGINTERN PyObject *_wrap_new_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8178 PyObject *resultobj = 0;
8179 wxWindow *arg1 = (wxWindow *) 0 ;
8180 wxSize *arg2 = 0 ;
8181 wxCaret *result = 0 ;
8182 void *argp1 = 0 ;
8183 int res1 = 0 ;
8184 wxSize temp2 ;
8185 PyObject * obj0 = 0 ;
8186 PyObject * obj1 = 0 ;
8187 char * kwnames[] = {
8188 (char *) "window",(char *) "size", NULL
8189 };
8190
8191 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) SWIG_fail;
8192 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
8193 if (!SWIG_IsOK(res1)) {
8194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Caret" "', expected argument " "1"" of type '" "wxWindow *""'");
8195 }
8196 arg1 = reinterpret_cast< wxWindow * >(argp1);
8197 {
8198 arg2 = &temp2;
8199 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8200 }
8201 {
8202 if (!wxPyCheckForApp()) SWIG_fail;
8203 PyThreadState* __tstate = wxPyBeginAllowThreads();
8204 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
8205 wxPyEndAllowThreads(__tstate);
8206 if (PyErr_Occurred()) SWIG_fail;
8207 }
8208 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, SWIG_POINTER_NEW | 0 );
8209 return resultobj;
8210 fail:
8211 return NULL;
8212 }
8213
8214
8215 SWIGINTERN PyObject *_wrap_delete_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8216 PyObject *resultobj = 0;
8217 wxCaret *arg1 = (wxCaret *) 0 ;
8218 void *argp1 = 0 ;
8219 int res1 = 0 ;
8220 PyObject *swig_obj[1] ;
8221
8222 if (!args) SWIG_fail;
8223 swig_obj[0] = args;
8224 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
8225 if (!SWIG_IsOK(res1)) {
8226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Caret" "', expected argument " "1"" of type '" "wxCaret *""'");
8227 }
8228 arg1 = reinterpret_cast< wxCaret * >(argp1);
8229 {
8230 PyThreadState* __tstate = wxPyBeginAllowThreads();
8231 delete arg1;
8232
8233 wxPyEndAllowThreads(__tstate);
8234 if (PyErr_Occurred()) SWIG_fail;
8235 }
8236 resultobj = SWIG_Py_Void();
8237 return resultobj;
8238 fail:
8239 return NULL;
8240 }
8241
8242
8243 SWIGINTERN PyObject *_wrap_Caret_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8244 PyObject *resultobj = 0;
8245 wxCaret *arg1 = (wxCaret *) 0 ;
8246 void *argp1 = 0 ;
8247 int res1 = 0 ;
8248 PyObject *swig_obj[1] ;
8249
8250 if (!args) SWIG_fail;
8251 swig_obj[0] = args;
8252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8253 if (!SWIG_IsOK(res1)) {
8254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Destroy" "', expected argument " "1"" of type '" "wxCaret *""'");
8255 }
8256 arg1 = reinterpret_cast< wxCaret * >(argp1);
8257 {
8258 PyThreadState* __tstate = wxPyBeginAllowThreads();
8259 wxCaret_Destroy(arg1);
8260 wxPyEndAllowThreads(__tstate);
8261 if (PyErr_Occurred()) SWIG_fail;
8262 }
8263 resultobj = SWIG_Py_Void();
8264 return resultobj;
8265 fail:
8266 return NULL;
8267 }
8268
8269
8270 SWIGINTERN PyObject *_wrap_Caret_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8271 PyObject *resultobj = 0;
8272 wxCaret *arg1 = (wxCaret *) 0 ;
8273 bool result;
8274 void *argp1 = 0 ;
8275 int res1 = 0 ;
8276 PyObject *swig_obj[1] ;
8277
8278 if (!args) SWIG_fail;
8279 swig_obj[0] = args;
8280 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8281 if (!SWIG_IsOK(res1)) {
8282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsOk" "', expected argument " "1"" of type '" "wxCaret *""'");
8283 }
8284 arg1 = reinterpret_cast< wxCaret * >(argp1);
8285 {
8286 PyThreadState* __tstate = wxPyBeginAllowThreads();
8287 result = (bool)(arg1)->IsOk();
8288 wxPyEndAllowThreads(__tstate);
8289 if (PyErr_Occurred()) SWIG_fail;
8290 }
8291 {
8292 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8293 }
8294 return resultobj;
8295 fail:
8296 return NULL;
8297 }
8298
8299
8300 SWIGINTERN PyObject *_wrap_Caret_IsVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8301 PyObject *resultobj = 0;
8302 wxCaret *arg1 = (wxCaret *) 0 ;
8303 bool result;
8304 void *argp1 = 0 ;
8305 int res1 = 0 ;
8306 PyObject *swig_obj[1] ;
8307
8308 if (!args) SWIG_fail;
8309 swig_obj[0] = args;
8310 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8311 if (!SWIG_IsOK(res1)) {
8312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsVisible" "', expected argument " "1"" of type '" "wxCaret *""'");
8313 }
8314 arg1 = reinterpret_cast< wxCaret * >(argp1);
8315 {
8316 PyThreadState* __tstate = wxPyBeginAllowThreads();
8317 result = (bool)(arg1)->IsVisible();
8318 wxPyEndAllowThreads(__tstate);
8319 if (PyErr_Occurred()) SWIG_fail;
8320 }
8321 {
8322 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8323 }
8324 return resultobj;
8325 fail:
8326 return NULL;
8327 }
8328
8329
8330 SWIGINTERN PyObject *_wrap_Caret_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8331 PyObject *resultobj = 0;
8332 wxCaret *arg1 = (wxCaret *) 0 ;
8333 wxPoint result;
8334 void *argp1 = 0 ;
8335 int res1 = 0 ;
8336 PyObject *swig_obj[1] ;
8337
8338 if (!args) SWIG_fail;
8339 swig_obj[0] = args;
8340 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8341 if (!SWIG_IsOK(res1)) {
8342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPosition" "', expected argument " "1"" of type '" "wxCaret *""'");
8343 }
8344 arg1 = reinterpret_cast< wxCaret * >(argp1);
8345 {
8346 PyThreadState* __tstate = wxPyBeginAllowThreads();
8347 result = (arg1)->GetPosition();
8348 wxPyEndAllowThreads(__tstate);
8349 if (PyErr_Occurred()) SWIG_fail;
8350 }
8351 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
8352 return resultobj;
8353 fail:
8354 return NULL;
8355 }
8356
8357
8358 SWIGINTERN PyObject *_wrap_Caret_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8359 PyObject *resultobj = 0;
8360 wxCaret *arg1 = (wxCaret *) 0 ;
8361 int *arg2 = (int *) 0 ;
8362 int *arg3 = (int *) 0 ;
8363 void *argp1 = 0 ;
8364 int res1 = 0 ;
8365 int temp2 ;
8366 int res2 = SWIG_TMPOBJ ;
8367 int temp3 ;
8368 int res3 = SWIG_TMPOBJ ;
8369 PyObject *swig_obj[1] ;
8370
8371 arg2 = &temp2;
8372 arg3 = &temp3;
8373 if (!args) SWIG_fail;
8374 swig_obj[0] = args;
8375 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8376 if (!SWIG_IsOK(res1)) {
8377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPositionTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8378 }
8379 arg1 = reinterpret_cast< wxCaret * >(argp1);
8380 {
8381 PyThreadState* __tstate = wxPyBeginAllowThreads();
8382 (arg1)->GetPosition(arg2,arg3);
8383 wxPyEndAllowThreads(__tstate);
8384 if (PyErr_Occurred()) SWIG_fail;
8385 }
8386 resultobj = SWIG_Py_Void();
8387 if (SWIG_IsTmpObj(res2)) {
8388 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8389 } else {
8390 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8391 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8392 }
8393 if (SWIG_IsTmpObj(res3)) {
8394 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8395 } else {
8396 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8397 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8398 }
8399 return resultobj;
8400 fail:
8401 return NULL;
8402 }
8403
8404
8405 SWIGINTERN PyObject *_wrap_Caret_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8406 PyObject *resultobj = 0;
8407 wxCaret *arg1 = (wxCaret *) 0 ;
8408 wxSize result;
8409 void *argp1 = 0 ;
8410 int res1 = 0 ;
8411 PyObject *swig_obj[1] ;
8412
8413 if (!args) SWIG_fail;
8414 swig_obj[0] = args;
8415 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8416 if (!SWIG_IsOK(res1)) {
8417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8418 }
8419 arg1 = reinterpret_cast< wxCaret * >(argp1);
8420 {
8421 PyThreadState* __tstate = wxPyBeginAllowThreads();
8422 result = (arg1)->GetSize();
8423 wxPyEndAllowThreads(__tstate);
8424 if (PyErr_Occurred()) SWIG_fail;
8425 }
8426 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
8427 return resultobj;
8428 fail:
8429 return NULL;
8430 }
8431
8432
8433 SWIGINTERN PyObject *_wrap_Caret_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8434 PyObject *resultobj = 0;
8435 wxCaret *arg1 = (wxCaret *) 0 ;
8436 int *arg2 = (int *) 0 ;
8437 int *arg3 = (int *) 0 ;
8438 void *argp1 = 0 ;
8439 int res1 = 0 ;
8440 int temp2 ;
8441 int res2 = SWIG_TMPOBJ ;
8442 int temp3 ;
8443 int res3 = SWIG_TMPOBJ ;
8444 PyObject *swig_obj[1] ;
8445
8446 arg2 = &temp2;
8447 arg3 = &temp3;
8448 if (!args) SWIG_fail;
8449 swig_obj[0] = args;
8450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8451 if (!SWIG_IsOK(res1)) {
8452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSizeTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8453 }
8454 arg1 = reinterpret_cast< wxCaret * >(argp1);
8455 {
8456 PyThreadState* __tstate = wxPyBeginAllowThreads();
8457 (arg1)->GetSize(arg2,arg3);
8458 wxPyEndAllowThreads(__tstate);
8459 if (PyErr_Occurred()) SWIG_fail;
8460 }
8461 resultobj = SWIG_Py_Void();
8462 if (SWIG_IsTmpObj(res2)) {
8463 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8464 } else {
8465 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8466 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8467 }
8468 if (SWIG_IsTmpObj(res3)) {
8469 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8470 } else {
8471 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8472 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8473 }
8474 return resultobj;
8475 fail:
8476 return NULL;
8477 }
8478
8479
8480 SWIGINTERN PyObject *_wrap_Caret_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8481 PyObject *resultobj = 0;
8482 wxCaret *arg1 = (wxCaret *) 0 ;
8483 wxWindow *result = 0 ;
8484 void *argp1 = 0 ;
8485 int res1 = 0 ;
8486 PyObject *swig_obj[1] ;
8487
8488 if (!args) SWIG_fail;
8489 swig_obj[0] = args;
8490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8491 if (!SWIG_IsOK(res1)) {
8492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetWindow" "', expected argument " "1"" of type '" "wxCaret *""'");
8493 }
8494 arg1 = reinterpret_cast< wxCaret * >(argp1);
8495 {
8496 PyThreadState* __tstate = wxPyBeginAllowThreads();
8497 result = (wxWindow *)(arg1)->GetWindow();
8498 wxPyEndAllowThreads(__tstate);
8499 if (PyErr_Occurred()) SWIG_fail;
8500 }
8501 {
8502 resultobj = wxPyMake_wxObject(result, 0);
8503 }
8504 return resultobj;
8505 fail:
8506 return NULL;
8507 }
8508
8509
8510 SWIGINTERN PyObject *_wrap_Caret_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8511 PyObject *resultobj = 0;
8512 wxCaret *arg1 = (wxCaret *) 0 ;
8513 int arg2 ;
8514 int arg3 ;
8515 void *argp1 = 0 ;
8516 int res1 = 0 ;
8517 int val2 ;
8518 int ecode2 = 0 ;
8519 int val3 ;
8520 int ecode3 = 0 ;
8521 PyObject * obj0 = 0 ;
8522 PyObject * obj1 = 0 ;
8523 PyObject * obj2 = 0 ;
8524 char * kwnames[] = {
8525 (char *) "self",(char *) "x",(char *) "y", NULL
8526 };
8527
8528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8529 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8530 if (!SWIG_IsOK(res1)) {
8531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_MoveXY" "', expected argument " "1"" of type '" "wxCaret *""'");
8532 }
8533 arg1 = reinterpret_cast< wxCaret * >(argp1);
8534 ecode2 = SWIG_AsVal_int(obj1, &val2);
8535 if (!SWIG_IsOK(ecode2)) {
8536 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_MoveXY" "', expected argument " "2"" of type '" "int""'");
8537 }
8538 arg2 = static_cast< int >(val2);
8539 ecode3 = SWIG_AsVal_int(obj2, &val3);
8540 if (!SWIG_IsOK(ecode3)) {
8541 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_MoveXY" "', expected argument " "3"" of type '" "int""'");
8542 }
8543 arg3 = static_cast< int >(val3);
8544 {
8545 PyThreadState* __tstate = wxPyBeginAllowThreads();
8546 (arg1)->Move(arg2,arg3);
8547 wxPyEndAllowThreads(__tstate);
8548 if (PyErr_Occurred()) SWIG_fail;
8549 }
8550 resultobj = SWIG_Py_Void();
8551 return resultobj;
8552 fail:
8553 return NULL;
8554 }
8555
8556
8557 SWIGINTERN PyObject *_wrap_Caret_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8558 PyObject *resultobj = 0;
8559 wxCaret *arg1 = (wxCaret *) 0 ;
8560 wxPoint *arg2 = 0 ;
8561 void *argp1 = 0 ;
8562 int res1 = 0 ;
8563 wxPoint temp2 ;
8564 PyObject * obj0 = 0 ;
8565 PyObject * obj1 = 0 ;
8566 char * kwnames[] = {
8567 (char *) "self",(char *) "pt", NULL
8568 };
8569
8570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) SWIG_fail;
8571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8572 if (!SWIG_IsOK(res1)) {
8573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Move" "', expected argument " "1"" of type '" "wxCaret *""'");
8574 }
8575 arg1 = reinterpret_cast< wxCaret * >(argp1);
8576 {
8577 arg2 = &temp2;
8578 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
8579 }
8580 {
8581 PyThreadState* __tstate = wxPyBeginAllowThreads();
8582 (arg1)->Move((wxPoint const &)*arg2);
8583 wxPyEndAllowThreads(__tstate);
8584 if (PyErr_Occurred()) SWIG_fail;
8585 }
8586 resultobj = SWIG_Py_Void();
8587 return resultobj;
8588 fail:
8589 return NULL;
8590 }
8591
8592
8593 SWIGINTERN PyObject *_wrap_Caret_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8594 PyObject *resultobj = 0;
8595 wxCaret *arg1 = (wxCaret *) 0 ;
8596 int arg2 ;
8597 int arg3 ;
8598 void *argp1 = 0 ;
8599 int res1 = 0 ;
8600 int val2 ;
8601 int ecode2 = 0 ;
8602 int val3 ;
8603 int ecode3 = 0 ;
8604 PyObject * obj0 = 0 ;
8605 PyObject * obj1 = 0 ;
8606 PyObject * obj2 = 0 ;
8607 char * kwnames[] = {
8608 (char *) "self",(char *) "width",(char *) "height", NULL
8609 };
8610
8611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8613 if (!SWIG_IsOK(res1)) {
8614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSizeWH" "', expected argument " "1"" of type '" "wxCaret *""'");
8615 }
8616 arg1 = reinterpret_cast< wxCaret * >(argp1);
8617 ecode2 = SWIG_AsVal_int(obj1, &val2);
8618 if (!SWIG_IsOK(ecode2)) {
8619 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
8620 }
8621 arg2 = static_cast< int >(val2);
8622 ecode3 = SWIG_AsVal_int(obj2, &val3);
8623 if (!SWIG_IsOK(ecode3)) {
8624 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
8625 }
8626 arg3 = static_cast< int >(val3);
8627 {
8628 PyThreadState* __tstate = wxPyBeginAllowThreads();
8629 (arg1)->SetSize(arg2,arg3);
8630 wxPyEndAllowThreads(__tstate);
8631 if (PyErr_Occurred()) SWIG_fail;
8632 }
8633 resultobj = SWIG_Py_Void();
8634 return resultobj;
8635 fail:
8636 return NULL;
8637 }
8638
8639
8640 SWIGINTERN PyObject *_wrap_Caret_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8641 PyObject *resultobj = 0;
8642 wxCaret *arg1 = (wxCaret *) 0 ;
8643 wxSize *arg2 = 0 ;
8644 void *argp1 = 0 ;
8645 int res1 = 0 ;
8646 wxSize temp2 ;
8647 PyObject * obj0 = 0 ;
8648 PyObject * obj1 = 0 ;
8649 char * kwnames[] = {
8650 (char *) "self",(char *) "size", NULL
8651 };
8652
8653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
8654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8655 if (!SWIG_IsOK(res1)) {
8656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8657 }
8658 arg1 = reinterpret_cast< wxCaret * >(argp1);
8659 {
8660 arg2 = &temp2;
8661 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8662 }
8663 {
8664 PyThreadState* __tstate = wxPyBeginAllowThreads();
8665 (arg1)->SetSize((wxSize const &)*arg2);
8666 wxPyEndAllowThreads(__tstate);
8667 if (PyErr_Occurred()) SWIG_fail;
8668 }
8669 resultobj = SWIG_Py_Void();
8670 return resultobj;
8671 fail:
8672 return NULL;
8673 }
8674
8675
8676 SWIGINTERN PyObject *_wrap_Caret_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8677 PyObject *resultobj = 0;
8678 wxCaret *arg1 = (wxCaret *) 0 ;
8679 int arg2 = (int) true ;
8680 void *argp1 = 0 ;
8681 int res1 = 0 ;
8682 int val2 ;
8683 int ecode2 = 0 ;
8684 PyObject * obj0 = 0 ;
8685 PyObject * obj1 = 0 ;
8686 char * kwnames[] = {
8687 (char *) "self",(char *) "show", NULL
8688 };
8689
8690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) SWIG_fail;
8691 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8692 if (!SWIG_IsOK(res1)) {
8693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Show" "', expected argument " "1"" of type '" "wxCaret *""'");
8694 }
8695 arg1 = reinterpret_cast< wxCaret * >(argp1);
8696 if (obj1) {
8697 ecode2 = SWIG_AsVal_int(obj1, &val2);
8698 if (!SWIG_IsOK(ecode2)) {
8699 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_Show" "', expected argument " "2"" of type '" "int""'");
8700 }
8701 arg2 = static_cast< int >(val2);
8702 }
8703 {
8704 PyThreadState* __tstate = wxPyBeginAllowThreads();
8705 (arg1)->Show(arg2);
8706 wxPyEndAllowThreads(__tstate);
8707 if (PyErr_Occurred()) SWIG_fail;
8708 }
8709 resultobj = SWIG_Py_Void();
8710 return resultobj;
8711 fail:
8712 return NULL;
8713 }
8714
8715
8716 SWIGINTERN PyObject *_wrap_Caret_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8717 PyObject *resultobj = 0;
8718 wxCaret *arg1 = (wxCaret *) 0 ;
8719 void *argp1 = 0 ;
8720 int res1 = 0 ;
8721 PyObject *swig_obj[1] ;
8722
8723 if (!args) SWIG_fail;
8724 swig_obj[0] = args;
8725 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8726 if (!SWIG_IsOK(res1)) {
8727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Hide" "', expected argument " "1"" of type '" "wxCaret *""'");
8728 }
8729 arg1 = reinterpret_cast< wxCaret * >(argp1);
8730 {
8731 PyThreadState* __tstate = wxPyBeginAllowThreads();
8732 (arg1)->Hide();
8733 wxPyEndAllowThreads(__tstate);
8734 if (PyErr_Occurred()) SWIG_fail;
8735 }
8736 resultobj = SWIG_Py_Void();
8737 return resultobj;
8738 fail:
8739 return NULL;
8740 }
8741
8742
8743 SWIGINTERN PyObject *_wrap_Caret_GetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8744 PyObject *resultobj = 0;
8745 int result;
8746
8747 if (!SWIG_Python_UnpackTuple(args,"Caret_GetBlinkTime",0,0,0)) SWIG_fail;
8748 {
8749 PyThreadState* __tstate = wxPyBeginAllowThreads();
8750 result = (int)wxCaret::GetBlinkTime();
8751 wxPyEndAllowThreads(__tstate);
8752 if (PyErr_Occurred()) SWIG_fail;
8753 }
8754 resultobj = SWIG_From_int(static_cast< int >(result));
8755 return resultobj;
8756 fail:
8757 return NULL;
8758 }
8759
8760
8761 SWIGINTERN PyObject *_wrap_Caret_SetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8762 PyObject *resultobj = 0;
8763 int arg1 ;
8764 int val1 ;
8765 int ecode1 = 0 ;
8766 PyObject * obj0 = 0 ;
8767 char * kwnames[] = {
8768 (char *) "milliseconds", NULL
8769 };
8770
8771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) SWIG_fail;
8772 ecode1 = SWIG_AsVal_int(obj0, &val1);
8773 if (!SWIG_IsOK(ecode1)) {
8774 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Caret_SetBlinkTime" "', expected argument " "1"" of type '" "int""'");
8775 }
8776 arg1 = static_cast< int >(val1);
8777 {
8778 PyThreadState* __tstate = wxPyBeginAllowThreads();
8779 wxCaret::SetBlinkTime(arg1);
8780 wxPyEndAllowThreads(__tstate);
8781 if (PyErr_Occurred()) SWIG_fail;
8782 }
8783 resultobj = SWIG_Py_Void();
8784 return resultobj;
8785 fail:
8786 return NULL;
8787 }
8788
8789
8790 SWIGINTERN PyObject *Caret_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8791 PyObject *obj;
8792 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8793 SWIG_TypeNewClientData(SWIGTYPE_p_wxCaret, SWIG_NewClientData(obj));
8794 return SWIG_Py_Void();
8795 }
8796
8797 SWIGINTERN PyObject *Caret_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8798 return SWIG_Python_InitShadowInstance(args);
8799 }
8800
8801 SWIGINTERN PyObject *_wrap_new_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8802 PyObject *resultobj = 0;
8803 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
8804 wxBusyCursor *result = 0 ;
8805 void *argp1 = 0 ;
8806 int res1 = 0 ;
8807 PyObject * obj0 = 0 ;
8808 char * kwnames[] = {
8809 (char *) "cursor", NULL
8810 };
8811
8812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) SWIG_fail;
8813 if (obj0) {
8814 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
8815 if (!SWIG_IsOK(res1)) {
8816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
8817 }
8818 arg1 = reinterpret_cast< wxCursor * >(argp1);
8819 }
8820 {
8821 if (!wxPyCheckForApp()) SWIG_fail;
8822 PyThreadState* __tstate = wxPyBeginAllowThreads();
8823 result = (wxBusyCursor *)new wxBusyCursor(arg1);
8824 wxPyEndAllowThreads(__tstate);
8825 if (PyErr_Occurred()) SWIG_fail;
8826 }
8827 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_NEW | 0 );
8828 return resultobj;
8829 fail:
8830 return NULL;
8831 }
8832
8833
8834 SWIGINTERN PyObject *_wrap_delete_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8835 PyObject *resultobj = 0;
8836 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
8837 void *argp1 = 0 ;
8838 int res1 = 0 ;
8839 PyObject *swig_obj[1] ;
8840
8841 if (!args) SWIG_fail;
8842 swig_obj[0] = args;
8843 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_DISOWN | 0 );
8844 if (!SWIG_IsOK(res1)) {
8845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyCursor" "', expected argument " "1"" of type '" "wxBusyCursor *""'");
8846 }
8847 arg1 = reinterpret_cast< wxBusyCursor * >(argp1);
8848 {
8849 PyThreadState* __tstate = wxPyBeginAllowThreads();
8850 delete arg1;
8851
8852 wxPyEndAllowThreads(__tstate);
8853 if (PyErr_Occurred()) SWIG_fail;
8854 }
8855 resultobj = SWIG_Py_Void();
8856 return resultobj;
8857 fail:
8858 return NULL;
8859 }
8860
8861
8862 SWIGINTERN PyObject *BusyCursor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8863 PyObject *obj;
8864 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8865 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyCursor, SWIG_NewClientData(obj));
8866 return SWIG_Py_Void();
8867 }
8868
8869 SWIGINTERN PyObject *BusyCursor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8870 return SWIG_Python_InitShadowInstance(args);
8871 }
8872
8873 SWIGINTERN PyObject *_wrap_new_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8874 PyObject *resultobj = 0;
8875 wxWindow *arg1 = (wxWindow *) NULL ;
8876 wxWindowDisabler *result = 0 ;
8877 void *argp1 = 0 ;
8878 int res1 = 0 ;
8879 PyObject * obj0 = 0 ;
8880 char * kwnames[] = {
8881 (char *) "winToSkip", NULL
8882 };
8883
8884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) SWIG_fail;
8885 if (obj0) {
8886 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
8887 if (!SWIG_IsOK(res1)) {
8888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDisabler" "', expected argument " "1"" of type '" "wxWindow *""'");
8889 }
8890 arg1 = reinterpret_cast< wxWindow * >(argp1);
8891 }
8892 {
8893 if (!wxPyCheckForApp()) SWIG_fail;
8894 PyThreadState* __tstate = wxPyBeginAllowThreads();
8895 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
8896 wxPyEndAllowThreads(__tstate);
8897 if (PyErr_Occurred()) SWIG_fail;
8898 }
8899 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_NEW | 0 );
8900 return resultobj;
8901 fail:
8902 return NULL;
8903 }
8904
8905
8906 SWIGINTERN PyObject *_wrap_delete_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8907 PyObject *resultobj = 0;
8908 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
8909 void *argp1 = 0 ;
8910 int res1 = 0 ;
8911 PyObject *swig_obj[1] ;
8912
8913 if (!args) SWIG_fail;
8914 swig_obj[0] = args;
8915 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_DISOWN | 0 );
8916 if (!SWIG_IsOK(res1)) {
8917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_WindowDisabler" "', expected argument " "1"" of type '" "wxWindowDisabler *""'");
8918 }
8919 arg1 = reinterpret_cast< wxWindowDisabler * >(argp1);
8920 {
8921 PyThreadState* __tstate = wxPyBeginAllowThreads();
8922 delete arg1;
8923
8924 wxPyEndAllowThreads(__tstate);
8925 if (PyErr_Occurred()) SWIG_fail;
8926 }
8927 resultobj = SWIG_Py_Void();
8928 return resultobj;
8929 fail:
8930 return NULL;
8931 }
8932
8933
8934 SWIGINTERN PyObject *WindowDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8935 PyObject *obj;
8936 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8937 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDisabler, SWIG_NewClientData(obj));
8938 return SWIG_Py_Void();
8939 }
8940
8941 SWIGINTERN PyObject *WindowDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8942 return SWIG_Python_InitShadowInstance(args);
8943 }
8944
8945 SWIGINTERN PyObject *_wrap_new_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8946 PyObject *resultobj = 0;
8947 wxString *arg1 = 0 ;
8948 wxBusyInfo *result = 0 ;
8949 bool temp1 = false ;
8950 PyObject * obj0 = 0 ;
8951 char * kwnames[] = {
8952 (char *) "message", NULL
8953 };
8954
8955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) SWIG_fail;
8956 {
8957 arg1 = wxString_in_helper(obj0);
8958 if (arg1 == NULL) SWIG_fail;
8959 temp1 = true;
8960 }
8961 {
8962 if (!wxPyCheckForApp()) SWIG_fail;
8963 PyThreadState* __tstate = wxPyBeginAllowThreads();
8964 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
8965 wxPyEndAllowThreads(__tstate);
8966 if (PyErr_Occurred()) SWIG_fail;
8967 }
8968 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_NEW | 0 );
8969 {
8970 if (temp1)
8971 delete arg1;
8972 }
8973 return resultobj;
8974 fail:
8975 {
8976 if (temp1)
8977 delete arg1;
8978 }
8979 return NULL;
8980 }
8981
8982
8983 SWIGINTERN PyObject *_wrap_delete_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8984 PyObject *resultobj = 0;
8985 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
8986 void *argp1 = 0 ;
8987 int res1 = 0 ;
8988 PyObject *swig_obj[1] ;
8989
8990 if (!args) SWIG_fail;
8991 swig_obj[0] = args;
8992 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_DISOWN | 0 );
8993 if (!SWIG_IsOK(res1)) {
8994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyInfo" "', expected argument " "1"" of type '" "wxBusyInfo *""'");
8995 }
8996 arg1 = reinterpret_cast< wxBusyInfo * >(argp1);
8997 {
8998 PyThreadState* __tstate = wxPyBeginAllowThreads();
8999 delete arg1;
9000
9001 wxPyEndAllowThreads(__tstate);
9002 if (PyErr_Occurred()) SWIG_fail;
9003 }
9004 resultobj = SWIG_Py_Void();
9005 return resultobj;
9006 fail:
9007 return NULL;
9008 }
9009
9010
9011 SWIGINTERN PyObject *BusyInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9012 PyObject *obj;
9013 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9014 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyInfo, SWIG_NewClientData(obj));
9015 return SWIG_Py_Void();
9016 }
9017
9018 SWIGINTERN PyObject *BusyInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9019 return SWIG_Python_InitShadowInstance(args);
9020 }
9021
9022 SWIGINTERN PyObject *_wrap_new_StopWatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9023 PyObject *resultobj = 0;
9024 wxStopWatch *result = 0 ;
9025
9026 if (!SWIG_Python_UnpackTuple(args,"new_StopWatch",0,0,0)) SWIG_fail;
9027 {
9028 PyThreadState* __tstate = wxPyBeginAllowThreads();
9029 result = (wxStopWatch *)new wxStopWatch();
9030 wxPyEndAllowThreads(__tstate);
9031 if (PyErr_Occurred()) SWIG_fail;
9032 }
9033 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStopWatch, SWIG_POINTER_NEW | 0 );
9034 return resultobj;
9035 fail:
9036 return NULL;
9037 }
9038
9039
9040 SWIGINTERN PyObject *_wrap_StopWatch_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9041 PyObject *resultobj = 0;
9042 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9043 long arg2 = (long) 0 ;
9044 void *argp1 = 0 ;
9045 int res1 = 0 ;
9046 long val2 ;
9047 int ecode2 = 0 ;
9048 PyObject * obj0 = 0 ;
9049 PyObject * obj1 = 0 ;
9050 char * kwnames[] = {
9051 (char *) "self",(char *) "t0", NULL
9052 };
9053
9054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) SWIG_fail;
9055 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9056 if (!SWIG_IsOK(res1)) {
9057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Start" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9058 }
9059 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9060 if (obj1) {
9061 ecode2 = SWIG_AsVal_long(obj1, &val2);
9062 if (!SWIG_IsOK(ecode2)) {
9063 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StopWatch_Start" "', expected argument " "2"" of type '" "long""'");
9064 }
9065 arg2 = static_cast< long >(val2);
9066 }
9067 {
9068 PyThreadState* __tstate = wxPyBeginAllowThreads();
9069 (arg1)->Start(arg2);
9070 wxPyEndAllowThreads(__tstate);
9071 if (PyErr_Occurred()) SWIG_fail;
9072 }
9073 resultobj = SWIG_Py_Void();
9074 return resultobj;
9075 fail:
9076 return NULL;
9077 }
9078
9079
9080 SWIGINTERN PyObject *_wrap_StopWatch_Pause(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9081 PyObject *resultobj = 0;
9082 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9083 void *argp1 = 0 ;
9084 int res1 = 0 ;
9085 PyObject *swig_obj[1] ;
9086
9087 if (!args) SWIG_fail;
9088 swig_obj[0] = args;
9089 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9090 if (!SWIG_IsOK(res1)) {
9091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Pause" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9092 }
9093 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9094 {
9095 PyThreadState* __tstate = wxPyBeginAllowThreads();
9096 (arg1)->Pause();
9097 wxPyEndAllowThreads(__tstate);
9098 if (PyErr_Occurred()) SWIG_fail;
9099 }
9100 resultobj = SWIG_Py_Void();
9101 return resultobj;
9102 fail:
9103 return NULL;
9104 }
9105
9106
9107 SWIGINTERN PyObject *_wrap_StopWatch_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9108 PyObject *resultobj = 0;
9109 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9110 void *argp1 = 0 ;
9111 int res1 = 0 ;
9112 PyObject *swig_obj[1] ;
9113
9114 if (!args) SWIG_fail;
9115 swig_obj[0] = args;
9116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9117 if (!SWIG_IsOK(res1)) {
9118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Resume" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9119 }
9120 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9121 {
9122 PyThreadState* __tstate = wxPyBeginAllowThreads();
9123 (arg1)->Resume();
9124 wxPyEndAllowThreads(__tstate);
9125 if (PyErr_Occurred()) SWIG_fail;
9126 }
9127 resultobj = SWIG_Py_Void();
9128 return resultobj;
9129 fail:
9130 return NULL;
9131 }
9132
9133
9134 SWIGINTERN PyObject *_wrap_StopWatch_Time(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9135 PyObject *resultobj = 0;
9136 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9137 long result;
9138 void *argp1 = 0 ;
9139 int res1 = 0 ;
9140 PyObject *swig_obj[1] ;
9141
9142 if (!args) SWIG_fail;
9143 swig_obj[0] = args;
9144 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9145 if (!SWIG_IsOK(res1)) {
9146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Time" "', expected argument " "1"" of type '" "wxStopWatch const *""'");
9147 }
9148 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9149 {
9150 PyThreadState* __tstate = wxPyBeginAllowThreads();
9151 result = (long)((wxStopWatch const *)arg1)->Time();
9152 wxPyEndAllowThreads(__tstate);
9153 if (PyErr_Occurred()) SWIG_fail;
9154 }
9155 resultobj = SWIG_From_long(static_cast< long >(result));
9156 return resultobj;
9157 fail:
9158 return NULL;
9159 }
9160
9161
9162 SWIGINTERN PyObject *StopWatch_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9163 PyObject *obj;
9164 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9165 SWIG_TypeNewClientData(SWIGTYPE_p_wxStopWatch, SWIG_NewClientData(obj));
9166 return SWIG_Py_Void();
9167 }
9168
9169 SWIGINTERN PyObject *StopWatch_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9170 return SWIG_Python_InitShadowInstance(args);
9171 }
9172
9173 SWIGINTERN PyObject *_wrap_new_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9174 PyObject *resultobj = 0;
9175 int arg1 = (int) 9 ;
9176 int arg2 = (int) wxID_FILE1 ;
9177 wxFileHistory *result = 0 ;
9178 int val1 ;
9179 int ecode1 = 0 ;
9180 int val2 ;
9181 int ecode2 = 0 ;
9182 PyObject * obj0 = 0 ;
9183 PyObject * obj1 = 0 ;
9184 char * kwnames[] = {
9185 (char *) "maxFiles",(char *) "idBase", NULL
9186 };
9187
9188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9189 if (obj0) {
9190 ecode1 = SWIG_AsVal_int(obj0, &val1);
9191 if (!SWIG_IsOK(ecode1)) {
9192 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FileHistory" "', expected argument " "1"" of type '" "int""'");
9193 }
9194 arg1 = static_cast< int >(val1);
9195 }
9196 if (obj1) {
9197 ecode2 = SWIG_AsVal_int(obj1, &val2);
9198 if (!SWIG_IsOK(ecode2)) {
9199 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FileHistory" "', expected argument " "2"" of type '" "int""'");
9200 }
9201 arg2 = static_cast< int >(val2);
9202 }
9203 {
9204 PyThreadState* __tstate = wxPyBeginAllowThreads();
9205 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
9206 wxPyEndAllowThreads(__tstate);
9207 if (PyErr_Occurred()) SWIG_fail;
9208 }
9209 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileHistory, SWIG_POINTER_NEW | 0 );
9210 return resultobj;
9211 fail:
9212 return NULL;
9213 }
9214
9215
9216 SWIGINTERN PyObject *_wrap_delete_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9217 PyObject *resultobj = 0;
9218 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9219 void *argp1 = 0 ;
9220 int res1 = 0 ;
9221 PyObject *swig_obj[1] ;
9222
9223 if (!args) SWIG_fail;
9224 swig_obj[0] = args;
9225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, SWIG_POINTER_DISOWN | 0 );
9226 if (!SWIG_IsOK(res1)) {
9227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9228 }
9229 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9230 {
9231 PyThreadState* __tstate = wxPyBeginAllowThreads();
9232 delete arg1;
9233
9234 wxPyEndAllowThreads(__tstate);
9235 if (PyErr_Occurred()) SWIG_fail;
9236 }
9237 resultobj = SWIG_Py_Void();
9238 return resultobj;
9239 fail:
9240 return NULL;
9241 }
9242
9243
9244 SWIGINTERN PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9245 PyObject *resultobj = 0;
9246 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9247 wxString *arg2 = 0 ;
9248 void *argp1 = 0 ;
9249 int res1 = 0 ;
9250 bool temp2 = false ;
9251 PyObject * obj0 = 0 ;
9252 PyObject * obj1 = 0 ;
9253 char * kwnames[] = {
9254 (char *) "self",(char *) "file", NULL
9255 };
9256
9257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9259 if (!SWIG_IsOK(res1)) {
9260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFileToHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9261 }
9262 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9263 {
9264 arg2 = wxString_in_helper(obj1);
9265 if (arg2 == NULL) SWIG_fail;
9266 temp2 = true;
9267 }
9268 {
9269 PyThreadState* __tstate = wxPyBeginAllowThreads();
9270 (arg1)->AddFileToHistory((wxString const &)*arg2);
9271 wxPyEndAllowThreads(__tstate);
9272 if (PyErr_Occurred()) SWIG_fail;
9273 }
9274 resultobj = SWIG_Py_Void();
9275 {
9276 if (temp2)
9277 delete arg2;
9278 }
9279 return resultobj;
9280 fail:
9281 {
9282 if (temp2)
9283 delete arg2;
9284 }
9285 return NULL;
9286 }
9287
9288
9289 SWIGINTERN PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9290 PyObject *resultobj = 0;
9291 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9292 int arg2 ;
9293 void *argp1 = 0 ;
9294 int res1 = 0 ;
9295 int val2 ;
9296 int ecode2 = 0 ;
9297 PyObject * obj0 = 0 ;
9298 PyObject * obj1 = 0 ;
9299 char * kwnames[] = {
9300 (char *) "self",(char *) "i", NULL
9301 };
9302
9303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9304 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9305 if (!SWIG_IsOK(res1)) {
9306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9307 }
9308 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9309 ecode2 = SWIG_AsVal_int(obj1, &val2);
9310 if (!SWIG_IsOK(ecode2)) {
9311 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "2"" of type '" "int""'");
9312 }
9313 arg2 = static_cast< int >(val2);
9314 {
9315 PyThreadState* __tstate = wxPyBeginAllowThreads();
9316 (arg1)->RemoveFileFromHistory(arg2);
9317 wxPyEndAllowThreads(__tstate);
9318 if (PyErr_Occurred()) SWIG_fail;
9319 }
9320 resultobj = SWIG_Py_Void();
9321 return resultobj;
9322 fail:
9323 return NULL;
9324 }
9325
9326
9327 SWIGINTERN PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9328 PyObject *resultobj = 0;
9329 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9330 int result;
9331 void *argp1 = 0 ;
9332 int res1 = 0 ;
9333 PyObject *swig_obj[1] ;
9334
9335 if (!args) SWIG_fail;
9336 swig_obj[0] = args;
9337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9338 if (!SWIG_IsOK(res1)) {
9339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetMaxFiles" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9340 }
9341 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9342 {
9343 PyThreadState* __tstate = wxPyBeginAllowThreads();
9344 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
9345 wxPyEndAllowThreads(__tstate);
9346 if (PyErr_Occurred()) SWIG_fail;
9347 }
9348 resultobj = SWIG_From_int(static_cast< int >(result));
9349 return resultobj;
9350 fail:
9351 return NULL;
9352 }
9353
9354
9355 SWIGINTERN PyObject *_wrap_FileHistory_UseMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9356 PyObject *resultobj = 0;
9357 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9358 wxMenu *arg2 = (wxMenu *) 0 ;
9359 void *argp1 = 0 ;
9360 int res1 = 0 ;
9361 void *argp2 = 0 ;
9362 int res2 = 0 ;
9363 PyObject * obj0 = 0 ;
9364 PyObject * obj1 = 0 ;
9365 char * kwnames[] = {
9366 (char *) "self",(char *) "menu", NULL
9367 };
9368
9369 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9370 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9371 if (!SWIG_IsOK(res1)) {
9372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_UseMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9373 }
9374 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9375 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9376 if (!SWIG_IsOK(res2)) {
9377 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_UseMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9378 }
9379 arg2 = reinterpret_cast< wxMenu * >(argp2);
9380 {
9381 PyThreadState* __tstate = wxPyBeginAllowThreads();
9382 (arg1)->UseMenu(arg2);
9383 wxPyEndAllowThreads(__tstate);
9384 if (PyErr_Occurred()) SWIG_fail;
9385 }
9386 resultobj = SWIG_Py_Void();
9387 return resultobj;
9388 fail:
9389 return NULL;
9390 }
9391
9392
9393 SWIGINTERN PyObject *_wrap_FileHistory_RemoveMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9394 PyObject *resultobj = 0;
9395 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9396 wxMenu *arg2 = (wxMenu *) 0 ;
9397 void *argp1 = 0 ;
9398 int res1 = 0 ;
9399 void *argp2 = 0 ;
9400 int res2 = 0 ;
9401 PyObject * obj0 = 0 ;
9402 PyObject * obj1 = 0 ;
9403 char * kwnames[] = {
9404 (char *) "self",(char *) "menu", NULL
9405 };
9406
9407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9408 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9409 if (!SWIG_IsOK(res1)) {
9410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9411 }
9412 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9413 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9414 if (!SWIG_IsOK(res2)) {
9415 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_RemoveMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9416 }
9417 arg2 = reinterpret_cast< wxMenu * >(argp2);
9418 {
9419 PyThreadState* __tstate = wxPyBeginAllowThreads();
9420 (arg1)->RemoveMenu(arg2);
9421 wxPyEndAllowThreads(__tstate);
9422 if (PyErr_Occurred()) SWIG_fail;
9423 }
9424 resultobj = SWIG_Py_Void();
9425 return resultobj;
9426 fail:
9427 return NULL;
9428 }
9429
9430
9431 SWIGINTERN PyObject *_wrap_FileHistory_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9432 PyObject *resultobj = 0;
9433 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9434 wxConfigBase *arg2 = 0 ;
9435 void *argp1 = 0 ;
9436 int res1 = 0 ;
9437 void *argp2 = 0 ;
9438 int res2 = 0 ;
9439 PyObject * obj0 = 0 ;
9440 PyObject * obj1 = 0 ;
9441 char * kwnames[] = {
9442 (char *) "self",(char *) "config", NULL
9443 };
9444
9445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) SWIG_fail;
9446 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9447 if (!SWIG_IsOK(res1)) {
9448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Load" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9449 }
9450 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9451 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9452 if (!SWIG_IsOK(res2)) {
9453 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9454 }
9455 if (!argp2) {
9456 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9457 }
9458 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9459 {
9460 PyThreadState* __tstate = wxPyBeginAllowThreads();
9461 (arg1)->Load(*arg2);
9462 wxPyEndAllowThreads(__tstate);
9463 if (PyErr_Occurred()) SWIG_fail;
9464 }
9465 resultobj = SWIG_Py_Void();
9466 return resultobj;
9467 fail:
9468 return NULL;
9469 }
9470
9471
9472 SWIGINTERN PyObject *_wrap_FileHistory_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9473 PyObject *resultobj = 0;
9474 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9475 wxConfigBase *arg2 = 0 ;
9476 void *argp1 = 0 ;
9477 int res1 = 0 ;
9478 void *argp2 = 0 ;
9479 int res2 = 0 ;
9480 PyObject * obj0 = 0 ;
9481 PyObject * obj1 = 0 ;
9482 char * kwnames[] = {
9483 (char *) "self",(char *) "config", NULL
9484 };
9485
9486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) SWIG_fail;
9487 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9488 if (!SWIG_IsOK(res1)) {
9489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Save" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9490 }
9491 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9492 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9493 if (!SWIG_IsOK(res2)) {
9494 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9495 }
9496 if (!argp2) {
9497 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9498 }
9499 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9500 {
9501 PyThreadState* __tstate = wxPyBeginAllowThreads();
9502 (arg1)->Save(*arg2);
9503 wxPyEndAllowThreads(__tstate);
9504 if (PyErr_Occurred()) SWIG_fail;
9505 }
9506 resultobj = SWIG_Py_Void();
9507 return resultobj;
9508 fail:
9509 return NULL;
9510 }
9511
9512
9513 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9514 PyObject *resultobj = 0;
9515 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9516 void *argp1 = 0 ;
9517 int res1 = 0 ;
9518 PyObject *swig_obj[1] ;
9519
9520 if (!args) SWIG_fail;
9521 swig_obj[0] = args;
9522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9523 if (!SWIG_IsOK(res1)) {
9524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9525 }
9526 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9527 {
9528 PyThreadState* __tstate = wxPyBeginAllowThreads();
9529 (arg1)->AddFilesToMenu();
9530 wxPyEndAllowThreads(__tstate);
9531 if (PyErr_Occurred()) SWIG_fail;
9532 }
9533 resultobj = SWIG_Py_Void();
9534 return resultobj;
9535 fail:
9536 return NULL;
9537 }
9538
9539
9540 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9541 PyObject *resultobj = 0;
9542 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9543 wxMenu *arg2 = (wxMenu *) 0 ;
9544 void *argp1 = 0 ;
9545 int res1 = 0 ;
9546 void *argp2 = 0 ;
9547 int res2 = 0 ;
9548 PyObject * obj0 = 0 ;
9549 PyObject * obj1 = 0 ;
9550 char * kwnames[] = {
9551 (char *) "self",(char *) "menu", NULL
9552 };
9553
9554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9555 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9556 if (!SWIG_IsOK(res1)) {
9557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9558 }
9559 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9560 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9561 if (!SWIG_IsOK(res2)) {
9562 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9563 }
9564 arg2 = reinterpret_cast< wxMenu * >(argp2);
9565 {
9566 PyThreadState* __tstate = wxPyBeginAllowThreads();
9567 (arg1)->AddFilesToMenu(arg2);
9568 wxPyEndAllowThreads(__tstate);
9569 if (PyErr_Occurred()) SWIG_fail;
9570 }
9571 resultobj = SWIG_Py_Void();
9572 return resultobj;
9573 fail:
9574 return NULL;
9575 }
9576
9577
9578 SWIGINTERN PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9579 PyObject *resultobj = 0;
9580 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9581 int arg2 ;
9582 wxString result;
9583 void *argp1 = 0 ;
9584 int res1 = 0 ;
9585 int val2 ;
9586 int ecode2 = 0 ;
9587 PyObject * obj0 = 0 ;
9588 PyObject * obj1 = 0 ;
9589 char * kwnames[] = {
9590 (char *) "self",(char *) "i", NULL
9591 };
9592
9593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) SWIG_fail;
9594 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9595 if (!SWIG_IsOK(res1)) {
9596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9597 }
9598 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9599 ecode2 = SWIG_AsVal_int(obj1, &val2);
9600 if (!SWIG_IsOK(ecode2)) {
9601 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "2"" of type '" "int""'");
9602 }
9603 arg2 = static_cast< int >(val2);
9604 {
9605 PyThreadState* __tstate = wxPyBeginAllowThreads();
9606 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
9607 wxPyEndAllowThreads(__tstate);
9608 if (PyErr_Occurred()) SWIG_fail;
9609 }
9610 {
9611 #if wxUSE_UNICODE
9612 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9613 #else
9614 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9615 #endif
9616 }
9617 return resultobj;
9618 fail:
9619 return NULL;
9620 }
9621
9622
9623 SWIGINTERN PyObject *_wrap_FileHistory_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9624 PyObject *resultobj = 0;
9625 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9626 int result;
9627 void *argp1 = 0 ;
9628 int res1 = 0 ;
9629 PyObject *swig_obj[1] ;
9630
9631 if (!args) SWIG_fail;
9632 swig_obj[0] = args;
9633 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9634 if (!SWIG_IsOK(res1)) {
9635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetCount" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9636 }
9637 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9638 {
9639 PyThreadState* __tstate = wxPyBeginAllowThreads();
9640 result = (int)((wxFileHistory const *)arg1)->GetCount();
9641 wxPyEndAllowThreads(__tstate);
9642 if (PyErr_Occurred()) SWIG_fail;
9643 }
9644 resultobj = SWIG_From_int(static_cast< int >(result));
9645 return resultobj;
9646 fail:
9647 return NULL;
9648 }
9649
9650
9651 SWIGINTERN PyObject *FileHistory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9652 PyObject *obj;
9653 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9654 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileHistory, SWIG_NewClientData(obj));
9655 return SWIG_Py_Void();
9656 }
9657
9658 SWIGINTERN PyObject *FileHistory_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9659 return SWIG_Python_InitShadowInstance(args);
9660 }
9661
9662 SWIGINTERN PyObject *_wrap_new_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9663 PyObject *resultobj = 0;
9664 wxString *arg1 = 0 ;
9665 wxString const &arg2_defvalue = wxPyEmptyString ;
9666 wxString *arg2 = (wxString *) &arg2_defvalue ;
9667 wxSingleInstanceChecker *result = 0 ;
9668 bool temp1 = false ;
9669 bool temp2 = false ;
9670 PyObject * obj0 = 0 ;
9671 PyObject * obj1 = 0 ;
9672 char * kwnames[] = {
9673 (char *) "name",(char *) "path", NULL
9674 };
9675
9676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) SWIG_fail;
9677 {
9678 arg1 = wxString_in_helper(obj0);
9679 if (arg1 == NULL) SWIG_fail;
9680 temp1 = true;
9681 }
9682 if (obj1) {
9683 {
9684 arg2 = wxString_in_helper(obj1);
9685 if (arg2 == NULL) SWIG_fail;
9686 temp2 = true;
9687 }
9688 }
9689 {
9690 PyThreadState* __tstate = wxPyBeginAllowThreads();
9691 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
9692 wxPyEndAllowThreads(__tstate);
9693 if (PyErr_Occurred()) SWIG_fail;
9694 }
9695 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_NEW | 0 );
9696 {
9697 if (temp1)
9698 delete arg1;
9699 }
9700 {
9701 if (temp2)
9702 delete arg2;
9703 }
9704 return resultobj;
9705 fail:
9706 {
9707 if (temp1)
9708 delete arg1;
9709 }
9710 {
9711 if (temp2)
9712 delete arg2;
9713 }
9714 return NULL;
9715 }
9716
9717
9718 SWIGINTERN PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9719 PyObject *resultobj = 0;
9720 wxSingleInstanceChecker *result = 0 ;
9721
9722 if (!SWIG_Python_UnpackTuple(args,"new_PreSingleInstanceChecker",0,0,0)) SWIG_fail;
9723 {
9724 PyThreadState* __tstate = wxPyBeginAllowThreads();
9725 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
9726 wxPyEndAllowThreads(__tstate);
9727 if (PyErr_Occurred()) SWIG_fail;
9728 }
9729 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_OWN | 0 );
9730 return resultobj;
9731 fail:
9732 return NULL;
9733 }
9734
9735
9736 SWIGINTERN PyObject *_wrap_delete_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9737 PyObject *resultobj = 0;
9738 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
9739 void *argp1 = 0 ;
9740 int res1 = 0 ;
9741 PyObject *swig_obj[1] ;
9742
9743 if (!args) SWIG_fail;
9744 swig_obj[0] = args;
9745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_DISOWN | 0 );
9746 if (!SWIG_IsOK(res1)) {
9747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SingleInstanceChecker" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
9748 }
9749 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
9750 {
9751 PyThreadState* __tstate = wxPyBeginAllowThreads();
9752 delete arg1;
9753
9754 wxPyEndAllowThreads(__tstate);
9755 if (PyErr_Occurred()) SWIG_fail;
9756 }
9757 resultobj = SWIG_Py_Void();
9758 return resultobj;
9759 fail:
9760 return NULL;
9761 }
9762
9763
9764 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9765 PyObject *resultobj = 0;
9766 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
9767 wxString *arg2 = 0 ;
9768 wxString const &arg3_defvalue = wxPyEmptyString ;
9769 wxString *arg3 = (wxString *) &arg3_defvalue ;
9770 bool result;
9771 void *argp1 = 0 ;
9772 int res1 = 0 ;
9773 bool temp2 = false ;
9774 bool temp3 = false ;
9775 PyObject * obj0 = 0 ;
9776 PyObject * obj1 = 0 ;
9777 PyObject * obj2 = 0 ;
9778 char * kwnames[] = {
9779 (char *) "self",(char *) "name",(char *) "path", NULL
9780 };
9781
9782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9783 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
9784 if (!SWIG_IsOK(res1)) {
9785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_Create" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
9786 }
9787 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
9788 {
9789 arg2 = wxString_in_helper(obj1);
9790 if (arg2 == NULL) SWIG_fail;
9791 temp2 = true;
9792 }
9793 if (obj2) {
9794 {
9795 arg3 = wxString_in_helper(obj2);
9796 if (arg3 == NULL) SWIG_fail;
9797 temp3 = true;
9798 }
9799 }
9800 {
9801 PyThreadState* __tstate = wxPyBeginAllowThreads();
9802 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
9803 wxPyEndAllowThreads(__tstate);
9804 if (PyErr_Occurred()) SWIG_fail;
9805 }
9806 {
9807 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9808 }
9809 {
9810 if (temp2)
9811 delete arg2;
9812 }
9813 {
9814 if (temp3)
9815 delete arg3;
9816 }
9817 return resultobj;
9818 fail:
9819 {
9820 if (temp2)
9821 delete arg2;
9822 }
9823 {
9824 if (temp3)
9825 delete arg3;
9826 }
9827 return NULL;
9828 }
9829
9830
9831 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9832 PyObject *resultobj = 0;
9833 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
9834 bool result;
9835 void *argp1 = 0 ;
9836 int res1 = 0 ;
9837 PyObject *swig_obj[1] ;
9838
9839 if (!args) SWIG_fail;
9840 swig_obj[0] = args;
9841 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
9842 if (!SWIG_IsOK(res1)) {
9843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_IsAnotherRunning" "', expected argument " "1"" of type '" "wxSingleInstanceChecker const *""'");
9844 }
9845 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
9846 {
9847 PyThreadState* __tstate = wxPyBeginAllowThreads();
9848 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
9849 wxPyEndAllowThreads(__tstate);
9850 if (PyErr_Occurred()) SWIG_fail;
9851 }
9852 {
9853 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9854 }
9855 return resultobj;
9856 fail:
9857 return NULL;
9858 }
9859
9860
9861 SWIGINTERN PyObject *SingleInstanceChecker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9862 PyObject *obj;
9863 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9864 SWIG_TypeNewClientData(SWIGTYPE_p_wxSingleInstanceChecker, SWIG_NewClientData(obj));
9865 return SWIG_Py_Void();
9866 }
9867
9868 SWIGINTERN PyObject *SingleInstanceChecker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9869 return SWIG_Python_InitShadowInstance(args);
9870 }
9871
9872 SWIGINTERN PyObject *_wrap_DrawWindowOnDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9873 PyObject *resultobj = 0;
9874 wxWindow *arg1 = (wxWindow *) 0 ;
9875 wxDC *arg2 = 0 ;
9876 bool result;
9877 void *argp1 = 0 ;
9878 int res1 = 0 ;
9879 void *argp2 = 0 ;
9880 int res2 = 0 ;
9881 PyObject * obj0 = 0 ;
9882 PyObject * obj1 = 0 ;
9883 char * kwnames[] = {
9884 (char *) "window",(char *) "dc", NULL
9885 };
9886
9887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DrawWindowOnDC",kwnames,&obj0,&obj1)) SWIG_fail;
9888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
9889 if (!SWIG_IsOK(res1)) {
9890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DrawWindowOnDC" "', expected argument " "1"" of type '" "wxWindow *""'");
9891 }
9892 arg1 = reinterpret_cast< wxWindow * >(argp1);
9893 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
9894 if (!SWIG_IsOK(res2)) {
9895 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
9896 }
9897 if (!argp2) {
9898 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
9899 }
9900 arg2 = reinterpret_cast< wxDC * >(argp2);
9901 {
9902 PyThreadState* __tstate = wxPyBeginAllowThreads();
9903 result = (bool)wxDrawWindowOnDC(arg1,(wxDC const &)*arg2);
9904 wxPyEndAllowThreads(__tstate);
9905 if (PyErr_Occurred()) SWIG_fail;
9906 }
9907 {
9908 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9909 }
9910 return resultobj;
9911 fail:
9912 return NULL;
9913 }
9914
9915
9916 SWIGINTERN PyObject *_wrap_delete_TipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9917 PyObject *resultobj = 0;
9918 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
9919 void *argp1 = 0 ;
9920 int res1 = 0 ;
9921 PyObject *swig_obj[1] ;
9922
9923 if (!args) SWIG_fail;
9924 swig_obj[0] = args;
9925 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, SWIG_POINTER_DISOWN | 0 );
9926 if (!SWIG_IsOK(res1)) {
9927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TipProvider" "', expected argument " "1"" of type '" "wxTipProvider *""'");
9928 }
9929 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
9930 {
9931 PyThreadState* __tstate = wxPyBeginAllowThreads();
9932 delete arg1;
9933
9934 wxPyEndAllowThreads(__tstate);
9935 if (PyErr_Occurred()) SWIG_fail;
9936 }
9937 resultobj = SWIG_Py_Void();
9938 return resultobj;
9939 fail:
9940 return NULL;
9941 }
9942
9943
9944 SWIGINTERN PyObject *_wrap_TipProvider_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9945 PyObject *resultobj = 0;
9946 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
9947 wxString result;
9948 void *argp1 = 0 ;
9949 int res1 = 0 ;
9950 PyObject *swig_obj[1] ;
9951
9952 if (!args) SWIG_fail;
9953 swig_obj[0] = args;
9954 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
9955 if (!SWIG_IsOK(res1)) {
9956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
9957 }
9958 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
9959 {
9960 PyThreadState* __tstate = wxPyBeginAllowThreads();
9961 result = (arg1)->GetTip();
9962 wxPyEndAllowThreads(__tstate);
9963 if (PyErr_Occurred()) SWIG_fail;
9964 }
9965 {
9966 #if wxUSE_UNICODE
9967 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9968 #else
9969 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9970 #endif
9971 }
9972 return resultobj;
9973 fail:
9974 return NULL;
9975 }
9976
9977
9978 SWIGINTERN PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9979 PyObject *resultobj = 0;
9980 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
9981 size_t result;
9982 void *argp1 = 0 ;
9983 int res1 = 0 ;
9984 PyObject *swig_obj[1] ;
9985
9986 if (!args) SWIG_fail;
9987 swig_obj[0] = args;
9988 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
9989 if (!SWIG_IsOK(res1)) {
9990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetCurrentTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
9991 }
9992 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
9993 {
9994 PyThreadState* __tstate = wxPyBeginAllowThreads();
9995 result = (size_t)(arg1)->GetCurrentTip();
9996 wxPyEndAllowThreads(__tstate);
9997 if (PyErr_Occurred()) SWIG_fail;
9998 }
9999 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
10000 return resultobj;
10001 fail:
10002 return NULL;
10003 }
10004
10005
10006 SWIGINTERN PyObject *_wrap_TipProvider_PreprocessTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10007 PyObject *resultobj = 0;
10008 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
10009 wxString *arg2 = 0 ;
10010 wxString result;
10011 void *argp1 = 0 ;
10012 int res1 = 0 ;
10013 bool temp2 = false ;
10014 PyObject * obj0 = 0 ;
10015 PyObject * obj1 = 0 ;
10016 char * kwnames[] = {
10017 (char *) "self",(char *) "tip", NULL
10018 };
10019
10020 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) SWIG_fail;
10021 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
10022 if (!SWIG_IsOK(res1)) {
10023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_PreprocessTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
10024 }
10025 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
10026 {
10027 arg2 = wxString_in_helper(obj1);
10028 if (arg2 == NULL) SWIG_fail;
10029 temp2 = true;
10030 }
10031 {
10032 PyThreadState* __tstate = wxPyBeginAllowThreads();
10033 result = (arg1)->PreprocessTip((wxString const &)*arg2);
10034 wxPyEndAllowThreads(__tstate);
10035 if (PyErr_Occurred()) SWIG_fail;
10036 }
10037 {
10038 #if wxUSE_UNICODE
10039 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10040 #else
10041 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10042 #endif
10043 }
10044 {
10045 if (temp2)
10046 delete arg2;
10047 }
10048 return resultobj;
10049 fail:
10050 {
10051 if (temp2)
10052 delete arg2;
10053 }
10054 return NULL;
10055 }
10056
10057
10058 SWIGINTERN PyObject *TipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10059 PyObject *obj;
10060 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10061 SWIG_TypeNewClientData(SWIGTYPE_p_wxTipProvider, SWIG_NewClientData(obj));
10062 return SWIG_Py_Void();
10063 }
10064
10065 SWIGINTERN PyObject *_wrap_new_PyTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10066 PyObject *resultobj = 0;
10067 size_t arg1 ;
10068 wxPyTipProvider *result = 0 ;
10069 size_t val1 ;
10070 int ecode1 = 0 ;
10071 PyObject * obj0 = 0 ;
10072 char * kwnames[] = {
10073 (char *) "currentTip", NULL
10074 };
10075
10076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) SWIG_fail;
10077 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
10078 if (!SWIG_IsOK(ecode1)) {
10079 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyTipProvider" "', expected argument " "1"" of type '" "size_t""'");
10080 }
10081 arg1 = static_cast< size_t >(val1);
10082 {
10083 PyThreadState* __tstate = wxPyBeginAllowThreads();
10084 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
10085 wxPyEndAllowThreads(__tstate);
10086 if (PyErr_Occurred()) SWIG_fail;
10087 }
10088 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_NEW | 0 );
10089 return resultobj;
10090 fail:
10091 return NULL;
10092 }
10093
10094
10095 SWIGINTERN PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10096 PyObject *resultobj = 0;
10097 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
10098 PyObject *arg2 = (PyObject *) 0 ;
10099 PyObject *arg3 = (PyObject *) 0 ;
10100 void *argp1 = 0 ;
10101 int res1 = 0 ;
10102 PyObject * obj0 = 0 ;
10103 PyObject * obj1 = 0 ;
10104 PyObject * obj2 = 0 ;
10105 char * kwnames[] = {
10106 (char *) "self",(char *) "self",(char *) "_class", NULL
10107 };
10108
10109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTipProvider, 0 | 0 );
10111 if (!SWIG_IsOK(res1)) {
10112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTipProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTipProvider *""'");
10113 }
10114 arg1 = reinterpret_cast< wxPyTipProvider * >(argp1);
10115 arg2 = obj1;
10116 arg3 = obj2;
10117 {
10118 PyThreadState* __tstate = wxPyBeginAllowThreads();
10119 (arg1)->_setCallbackInfo(arg2,arg3);
10120 wxPyEndAllowThreads(__tstate);
10121 if (PyErr_Occurred()) SWIG_fail;
10122 }
10123 resultobj = SWIG_Py_Void();
10124 return resultobj;
10125 fail:
10126 return NULL;
10127 }
10128
10129
10130 SWIGINTERN PyObject *PyTipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10131 PyObject *obj;
10132 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10133 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTipProvider, SWIG_NewClientData(obj));
10134 return SWIG_Py_Void();
10135 }
10136
10137 SWIGINTERN PyObject *PyTipProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10138 return SWIG_Python_InitShadowInstance(args);
10139 }
10140
10141 SWIGINTERN PyObject *_wrap_ShowTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10142 PyObject *resultobj = 0;
10143 wxWindow *arg1 = (wxWindow *) 0 ;
10144 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
10145 bool arg3 = (bool) true ;
10146 bool result;
10147 void *argp1 = 0 ;
10148 int res1 = 0 ;
10149 void *argp2 = 0 ;
10150 int res2 = 0 ;
10151 bool val3 ;
10152 int ecode3 = 0 ;
10153 PyObject * obj0 = 0 ;
10154 PyObject * obj1 = 0 ;
10155 PyObject * obj2 = 0 ;
10156 char * kwnames[] = {
10157 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
10158 };
10159
10160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
10162 if (!SWIG_IsOK(res1)) {
10163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowTip" "', expected argument " "1"" of type '" "wxWindow *""'");
10164 }
10165 arg1 = reinterpret_cast< wxWindow * >(argp1);
10166 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTipProvider, 0 | 0 );
10167 if (!SWIG_IsOK(res2)) {
10168 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShowTip" "', expected argument " "2"" of type '" "wxTipProvider *""'");
10169 }
10170 arg2 = reinterpret_cast< wxTipProvider * >(argp2);
10171 if (obj2) {
10172 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10173 if (!SWIG_IsOK(ecode3)) {
10174 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ShowTip" "', expected argument " "3"" of type '" "bool""'");
10175 }
10176 arg3 = static_cast< bool >(val3);
10177 }
10178 {
10179 if (!wxPyCheckForApp()) SWIG_fail;
10180 PyThreadState* __tstate = wxPyBeginAllowThreads();
10181 result = (bool)wxShowTip(arg1,arg2,arg3);
10182 wxPyEndAllowThreads(__tstate);
10183 if (PyErr_Occurred()) SWIG_fail;
10184 }
10185 {
10186 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10187 }
10188 return resultobj;
10189 fail:
10190 return NULL;
10191 }
10192
10193
10194 SWIGINTERN PyObject *_wrap_CreateFileTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10195 PyObject *resultobj = 0;
10196 wxString *arg1 = 0 ;
10197 size_t arg2 ;
10198 wxTipProvider *result = 0 ;
10199 bool temp1 = false ;
10200 size_t val2 ;
10201 int ecode2 = 0 ;
10202 PyObject * obj0 = 0 ;
10203 PyObject * obj1 = 0 ;
10204 char * kwnames[] = {
10205 (char *) "filename",(char *) "currentTip", NULL
10206 };
10207
10208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) SWIG_fail;
10209 {
10210 arg1 = wxString_in_helper(obj0);
10211 if (arg1 == NULL) SWIG_fail;
10212 temp1 = true;
10213 }
10214 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
10215 if (!SWIG_IsOK(ecode2)) {
10216 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CreateFileTipProvider" "', expected argument " "2"" of type '" "size_t""'");
10217 }
10218 arg2 = static_cast< size_t >(val2);
10219 {
10220 if (!wxPyCheckForApp()) SWIG_fail;
10221 PyThreadState* __tstate = wxPyBeginAllowThreads();
10222 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
10223 wxPyEndAllowThreads(__tstate);
10224 if (PyErr_Occurred()) SWIG_fail;
10225 }
10226 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTipProvider, SWIG_POINTER_OWN | 0 );
10227 {
10228 if (temp1)
10229 delete arg1;
10230 }
10231 return resultobj;
10232 fail:
10233 {
10234 if (temp1)
10235 delete arg1;
10236 }
10237 return NULL;
10238 }
10239
10240
10241 SWIGINTERN PyObject *_wrap_new_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10242 PyObject *resultobj = 0;
10243 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
10244 int arg2 = (int) wxID_ANY ;
10245 wxPyTimer *result = 0 ;
10246 void *argp1 = 0 ;
10247 int res1 = 0 ;
10248 int val2 ;
10249 int ecode2 = 0 ;
10250 PyObject * obj0 = 0 ;
10251 PyObject * obj1 = 0 ;
10252 char * kwnames[] = {
10253 (char *) "owner",(char *) "id", NULL
10254 };
10255
10256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) SWIG_fail;
10257 if (obj0) {
10258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
10259 if (!SWIG_IsOK(res1)) {
10260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Timer" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
10261 }
10262 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
10263 }
10264 if (obj1) {
10265 ecode2 = SWIG_AsVal_int(obj1, &val2);
10266 if (!SWIG_IsOK(ecode2)) {
10267 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Timer" "', expected argument " "2"" of type '" "int""'");
10268 }
10269 arg2 = static_cast< int >(val2);
10270 }
10271 {
10272 if (!wxPyCheckForApp()) SWIG_fail;
10273 PyThreadState* __tstate = wxPyBeginAllowThreads();
10274 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
10275 wxPyEndAllowThreads(__tstate);
10276 if (PyErr_Occurred()) SWIG_fail;
10277 }
10278 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTimer, SWIG_POINTER_NEW | 0 );
10279 return resultobj;
10280 fail:
10281 return NULL;
10282 }
10283
10284
10285 SWIGINTERN PyObject *_wrap_delete_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10286 PyObject *resultobj = 0;
10287 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10288 void *argp1 = 0 ;
10289 int res1 = 0 ;
10290 PyObject *swig_obj[1] ;
10291
10292 if (!args) SWIG_fail;
10293 swig_obj[0] = args;
10294 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, SWIG_POINTER_DISOWN | 0 );
10295 if (!SWIG_IsOK(res1)) {
10296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Timer" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10297 }
10298 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10299 {
10300 PyThreadState* __tstate = wxPyBeginAllowThreads();
10301 delete arg1;
10302
10303 wxPyEndAllowThreads(__tstate);
10304 if (PyErr_Occurred()) SWIG_fail;
10305 }
10306 resultobj = SWIG_Py_Void();
10307 return resultobj;
10308 fail:
10309 return NULL;
10310 }
10311
10312
10313 SWIGINTERN PyObject *_wrap_Timer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10314 PyObject *resultobj = 0;
10315 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10316 PyObject *arg2 = (PyObject *) 0 ;
10317 PyObject *arg3 = (PyObject *) 0 ;
10318 int arg4 = (int) 1 ;
10319 void *argp1 = 0 ;
10320 int res1 = 0 ;
10321 int val4 ;
10322 int ecode4 = 0 ;
10323 PyObject * obj0 = 0 ;
10324 PyObject * obj1 = 0 ;
10325 PyObject * obj2 = 0 ;
10326 PyObject * obj3 = 0 ;
10327 char * kwnames[] = {
10328 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
10329 };
10330
10331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10332 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10333 if (!SWIG_IsOK(res1)) {
10334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10335 }
10336 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10337 arg2 = obj1;
10338 arg3 = obj2;
10339 if (obj3) {
10340 ecode4 = SWIG_AsVal_int(obj3, &val4);
10341 if (!SWIG_IsOK(ecode4)) {
10342 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Timer__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
10343 }
10344 arg4 = static_cast< int >(val4);
10345 }
10346 {
10347 PyThreadState* __tstate = wxPyBeginAllowThreads();
10348 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
10349 wxPyEndAllowThreads(__tstate);
10350 if (PyErr_Occurred()) SWIG_fail;
10351 }
10352 resultobj = SWIG_Py_Void();
10353 return resultobj;
10354 fail:
10355 return NULL;
10356 }
10357
10358
10359 SWIGINTERN PyObject *_wrap_Timer_SetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10360 PyObject *resultobj = 0;
10361 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10362 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
10363 int arg3 = (int) wxID_ANY ;
10364 void *argp1 = 0 ;
10365 int res1 = 0 ;
10366 void *argp2 = 0 ;
10367 int res2 = 0 ;
10368 int val3 ;
10369 int ecode3 = 0 ;
10370 PyObject * obj0 = 0 ;
10371 PyObject * obj1 = 0 ;
10372 PyObject * obj2 = 0 ;
10373 char * kwnames[] = {
10374 (char *) "self",(char *) "owner",(char *) "id", NULL
10375 };
10376
10377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10378 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10379 if (!SWIG_IsOK(res1)) {
10380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_SetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10381 }
10382 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10383 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
10384 if (!SWIG_IsOK(res2)) {
10385 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Timer_SetOwner" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
10386 }
10387 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
10388 if (obj2) {
10389 ecode3 = SWIG_AsVal_int(obj2, &val3);
10390 if (!SWIG_IsOK(ecode3)) {
10391 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_SetOwner" "', expected argument " "3"" of type '" "int""'");
10392 }
10393 arg3 = static_cast< int >(val3);
10394 }
10395 {
10396 PyThreadState* __tstate = wxPyBeginAllowThreads();
10397 (arg1)->SetOwner(arg2,arg3);
10398 wxPyEndAllowThreads(__tstate);
10399 if (PyErr_Occurred()) SWIG_fail;
10400 }
10401 resultobj = SWIG_Py_Void();
10402 return resultobj;
10403 fail:
10404 return NULL;
10405 }
10406
10407
10408 SWIGINTERN PyObject *_wrap_Timer_GetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10409 PyObject *resultobj = 0;
10410 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10411 wxEvtHandler *result = 0 ;
10412 void *argp1 = 0 ;
10413 int res1 = 0 ;
10414 PyObject *swig_obj[1] ;
10415
10416 if (!args) SWIG_fail;
10417 swig_obj[0] = args;
10418 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10419 if (!SWIG_IsOK(res1)) {
10420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10421 }
10422 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10423 {
10424 PyThreadState* __tstate = wxPyBeginAllowThreads();
10425 result = (wxEvtHandler *)(arg1)->GetOwner();
10426 wxPyEndAllowThreads(__tstate);
10427 if (PyErr_Occurred()) SWIG_fail;
10428 }
10429 {
10430 resultobj = wxPyMake_wxObject(result, 0);
10431 }
10432 return resultobj;
10433 fail:
10434 return NULL;
10435 }
10436
10437
10438 SWIGINTERN PyObject *_wrap_Timer_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10439 PyObject *resultobj = 0;
10440 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10441 int arg2 = (int) -1 ;
10442 bool arg3 = (bool) false ;
10443 bool result;
10444 void *argp1 = 0 ;
10445 int res1 = 0 ;
10446 int val2 ;
10447 int ecode2 = 0 ;
10448 bool val3 ;
10449 int ecode3 = 0 ;
10450 PyObject * obj0 = 0 ;
10451 PyObject * obj1 = 0 ;
10452 PyObject * obj2 = 0 ;
10453 char * kwnames[] = {
10454 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
10455 };
10456
10457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10458 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10459 if (!SWIG_IsOK(res1)) {
10460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Start" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10461 }
10462 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10463 if (obj1) {
10464 ecode2 = SWIG_AsVal_int(obj1, &val2);
10465 if (!SWIG_IsOK(ecode2)) {
10466 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Timer_Start" "', expected argument " "2"" of type '" "int""'");
10467 }
10468 arg2 = static_cast< int >(val2);
10469 }
10470 if (obj2) {
10471 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10472 if (!SWIG_IsOK(ecode3)) {
10473 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_Start" "', expected argument " "3"" of type '" "bool""'");
10474 }
10475 arg3 = static_cast< bool >(val3);
10476 }
10477 {
10478 PyThreadState* __tstate = wxPyBeginAllowThreads();
10479 result = (bool)(arg1)->Start(arg2,arg3);
10480 wxPyEndAllowThreads(__tstate);
10481 if (PyErr_Occurred()) SWIG_fail;
10482 }
10483 {
10484 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10485 }
10486 return resultobj;
10487 fail:
10488 return NULL;
10489 }
10490
10491
10492 SWIGINTERN PyObject *_wrap_Timer_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10493 PyObject *resultobj = 0;
10494 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10495 void *argp1 = 0 ;
10496 int res1 = 0 ;
10497 PyObject *swig_obj[1] ;
10498
10499 if (!args) SWIG_fail;
10500 swig_obj[0] = args;
10501 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10502 if (!SWIG_IsOK(res1)) {
10503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Stop" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10504 }
10505 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10506 {
10507 PyThreadState* __tstate = wxPyBeginAllowThreads();
10508 (arg1)->Stop();
10509 wxPyEndAllowThreads(__tstate);
10510 if (PyErr_Occurred()) SWIG_fail;
10511 }
10512 resultobj = SWIG_Py_Void();
10513 return resultobj;
10514 fail:
10515 return NULL;
10516 }
10517
10518
10519 SWIGINTERN PyObject *_wrap_Timer_Notify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10520 PyObject *resultobj = 0;
10521 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10522 void *argp1 = 0 ;
10523 int res1 = 0 ;
10524 PyObject *swig_obj[1] ;
10525
10526 if (!args) SWIG_fail;
10527 swig_obj[0] = args;
10528 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10529 if (!SWIG_IsOK(res1)) {
10530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Notify" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10531 }
10532 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10533 {
10534 PyThreadState* __tstate = wxPyBeginAllowThreads();
10535 (arg1)->Notify();
10536 wxPyEndAllowThreads(__tstate);
10537 if (PyErr_Occurred()) SWIG_fail;
10538 }
10539 resultobj = SWIG_Py_Void();
10540 return resultobj;
10541 fail:
10542 return NULL;
10543 }
10544
10545
10546 SWIGINTERN PyObject *_wrap_Timer_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10547 PyObject *resultobj = 0;
10548 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10549 bool result;
10550 void *argp1 = 0 ;
10551 int res1 = 0 ;
10552 PyObject *swig_obj[1] ;
10553
10554 if (!args) SWIG_fail;
10555 swig_obj[0] = args;
10556 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10557 if (!SWIG_IsOK(res1)) {
10558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsRunning" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
10559 }
10560 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10561 {
10562 PyThreadState* __tstate = wxPyBeginAllowThreads();
10563 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
10564 wxPyEndAllowThreads(__tstate);
10565 if (PyErr_Occurred()) SWIG_fail;
10566 }
10567 {
10568 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10569 }
10570 return resultobj;
10571 fail:
10572 return NULL;
10573 }
10574
10575
10576 SWIGINTERN PyObject *_wrap_Timer_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10577 PyObject *resultobj = 0;
10578 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10579 int result;
10580 void *argp1 = 0 ;
10581 int res1 = 0 ;
10582 PyObject *swig_obj[1] ;
10583
10584 if (!args) SWIG_fail;
10585 swig_obj[0] = args;
10586 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10587 if (!SWIG_IsOK(res1)) {
10588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetInterval" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
10589 }
10590 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10591 {
10592 PyThreadState* __tstate = wxPyBeginAllowThreads();
10593 result = (int)((wxPyTimer const *)arg1)->GetInterval();
10594 wxPyEndAllowThreads(__tstate);
10595 if (PyErr_Occurred()) SWIG_fail;
10596 }
10597 resultobj = SWIG_From_int(static_cast< int >(result));
10598 return resultobj;
10599 fail:
10600 return NULL;
10601 }
10602
10603
10604 SWIGINTERN PyObject *_wrap_Timer_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10605 PyObject *resultobj = 0;
10606 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10607 int result;
10608 void *argp1 = 0 ;
10609 int res1 = 0 ;
10610 PyObject *swig_obj[1] ;
10611
10612 if (!args) SWIG_fail;
10613 swig_obj[0] = args;
10614 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10615 if (!SWIG_IsOK(res1)) {
10616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetId" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
10617 }
10618 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10619 {
10620 PyThreadState* __tstate = wxPyBeginAllowThreads();
10621 result = (int)((wxPyTimer const *)arg1)->GetId();
10622 wxPyEndAllowThreads(__tstate);
10623 if (PyErr_Occurred()) SWIG_fail;
10624 }
10625 resultobj = SWIG_From_int(static_cast< int >(result));
10626 return resultobj;
10627 fail:
10628 return NULL;
10629 }
10630
10631
10632 SWIGINTERN PyObject *_wrap_Timer_IsOneShot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10633 PyObject *resultobj = 0;
10634 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10635 bool result;
10636 void *argp1 = 0 ;
10637 int res1 = 0 ;
10638 PyObject *swig_obj[1] ;
10639
10640 if (!args) SWIG_fail;
10641 swig_obj[0] = args;
10642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10643 if (!SWIG_IsOK(res1)) {
10644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsOneShot" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
10645 }
10646 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10647 {
10648 PyThreadState* __tstate = wxPyBeginAllowThreads();
10649 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
10650 wxPyEndAllowThreads(__tstate);
10651 if (PyErr_Occurred()) SWIG_fail;
10652 }
10653 {
10654 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10655 }
10656 return resultobj;
10657 fail:
10658 return NULL;
10659 }
10660
10661
10662 SWIGINTERN PyObject *Timer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10663 PyObject *obj;
10664 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10665 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTimer, SWIG_NewClientData(obj));
10666 return SWIG_Py_Void();
10667 }
10668
10669 SWIGINTERN PyObject *Timer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10670 return SWIG_Python_InitShadowInstance(args);
10671 }
10672
10673 SWIGINTERN PyObject *_wrap_new_TimerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10674 PyObject *resultobj = 0;
10675 int arg1 = (int) 0 ;
10676 int arg2 = (int) 0 ;
10677 wxTimerEvent *result = 0 ;
10678 int val1 ;
10679 int ecode1 = 0 ;
10680 int val2 ;
10681 int ecode2 = 0 ;
10682 PyObject * obj0 = 0 ;
10683 PyObject * obj1 = 0 ;
10684 char * kwnames[] = {
10685 (char *) "timerid",(char *) "interval", NULL
10686 };
10687
10688 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) SWIG_fail;
10689 if (obj0) {
10690 ecode1 = SWIG_AsVal_int(obj0, &val1);
10691 if (!SWIG_IsOK(ecode1)) {
10692 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimerEvent" "', expected argument " "1"" of type '" "int""'");
10693 }
10694 arg1 = static_cast< int >(val1);
10695 }
10696 if (obj1) {
10697 ecode2 = SWIG_AsVal_int(obj1, &val2);
10698 if (!SWIG_IsOK(ecode2)) {
10699 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerEvent" "', expected argument " "2"" of type '" "int""'");
10700 }
10701 arg2 = static_cast< int >(val2);
10702 }
10703 {
10704 PyThreadState* __tstate = wxPyBeginAllowThreads();
10705 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
10706 wxPyEndAllowThreads(__tstate);
10707 if (PyErr_Occurred()) SWIG_fail;
10708 }
10709 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_NEW | 0 );
10710 return resultobj;
10711 fail:
10712 return NULL;
10713 }
10714
10715
10716 SWIGINTERN PyObject *_wrap_TimerEvent_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10717 PyObject *resultobj = 0;
10718 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
10719 int result;
10720 void *argp1 = 0 ;
10721 int res1 = 0 ;
10722 PyObject *swig_obj[1] ;
10723
10724 if (!args) SWIG_fail;
10725 swig_obj[0] = args;
10726 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerEvent, 0 | 0 );
10727 if (!SWIG_IsOK(res1)) {
10728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerEvent_GetInterval" "', expected argument " "1"" of type '" "wxTimerEvent const *""'");
10729 }
10730 arg1 = reinterpret_cast< wxTimerEvent * >(argp1);
10731 {
10732 PyThreadState* __tstate = wxPyBeginAllowThreads();
10733 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
10734 wxPyEndAllowThreads(__tstate);
10735 if (PyErr_Occurred()) SWIG_fail;
10736 }
10737 resultobj = SWIG_From_int(static_cast< int >(result));
10738 return resultobj;
10739 fail:
10740 return NULL;
10741 }
10742
10743
10744 SWIGINTERN PyObject *TimerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10745 PyObject *obj;
10746 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10747 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerEvent, SWIG_NewClientData(obj));
10748 return SWIG_Py_Void();
10749 }
10750
10751 SWIGINTERN PyObject *TimerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10752 return SWIG_Python_InitShadowInstance(args);
10753 }
10754
10755 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10756 PyObject *resultobj = 0;
10757 wxTimer *arg1 = 0 ;
10758 wxTimerRunner *result = 0 ;
10759 void *argp1 = 0 ;
10760 int res1 = 0 ;
10761
10762 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
10763 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
10764 if (!SWIG_IsOK(res1)) {
10765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
10766 }
10767 if (!argp1) {
10768 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
10769 }
10770 arg1 = reinterpret_cast< wxTimer * >(argp1);
10771 {
10772 if (!wxPyCheckForApp()) SWIG_fail;
10773 PyThreadState* __tstate = wxPyBeginAllowThreads();
10774 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
10775 wxPyEndAllowThreads(__tstate);
10776 if (PyErr_Occurred()) SWIG_fail;
10777 }
10778 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
10779 return resultobj;
10780 fail:
10781 return NULL;
10782 }
10783
10784
10785 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10786 PyObject *resultobj = 0;
10787 wxTimer *arg1 = 0 ;
10788 int arg2 ;
10789 bool arg3 = (bool) false ;
10790 wxTimerRunner *result = 0 ;
10791 void *argp1 = 0 ;
10792 int res1 = 0 ;
10793 int val2 ;
10794 int ecode2 = 0 ;
10795 bool val3 ;
10796 int ecode3 = 0 ;
10797
10798 if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
10799 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
10800 if (!SWIG_IsOK(res1)) {
10801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
10802 }
10803 if (!argp1) {
10804 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
10805 }
10806 arg1 = reinterpret_cast< wxTimer * >(argp1);
10807 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
10808 if (!SWIG_IsOK(ecode2)) {
10809 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerRunner" "', expected argument " "2"" of type '" "int""'");
10810 }
10811 arg2 = static_cast< int >(val2);
10812 if (swig_obj[2]) {
10813 ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
10814 if (!SWIG_IsOK(ecode3)) {
10815 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimerRunner" "', expected argument " "3"" of type '" "bool""'");
10816 }
10817 arg3 = static_cast< bool >(val3);
10818 }
10819 {
10820 if (!wxPyCheckForApp()) SWIG_fail;
10821 PyThreadState* __tstate = wxPyBeginAllowThreads();
10822 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
10823 wxPyEndAllowThreads(__tstate);
10824 if (PyErr_Occurred()) SWIG_fail;
10825 }
10826 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
10827 return resultobj;
10828 fail:
10829 return NULL;
10830 }
10831
10832
10833 SWIGINTERN PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
10834 int argc;
10835 PyObject *argv[4];
10836
10837 if (!(argc = SWIG_Python_UnpackTuple(args,"new_TimerRunner",0,3,argv))) SWIG_fail;
10838 --argc;
10839 if (argc == 1) {
10840 return _wrap_new_TimerRunner__SWIG_0(self, argc, argv);
10841 }
10842 if ((argc >= 2) && (argc <= 3)) {
10843 return _wrap_new_TimerRunner__SWIG_1(self, argc, argv);
10844 }
10845
10846 fail:
10847 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
10848 return NULL;
10849 }
10850
10851
10852 SWIGINTERN PyObject *_wrap_delete_TimerRunner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10853 PyObject *resultobj = 0;
10854 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
10855 void *argp1 = 0 ;
10856 int res1 = 0 ;
10857 PyObject *swig_obj[1] ;
10858
10859 if (!args) SWIG_fail;
10860 swig_obj[0] = args;
10861 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_DISOWN | 0 );
10862 if (!SWIG_IsOK(res1)) {
10863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimerRunner" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
10864 }
10865 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
10866 {
10867 PyThreadState* __tstate = wxPyBeginAllowThreads();
10868 delete arg1;
10869
10870 wxPyEndAllowThreads(__tstate);
10871 if (PyErr_Occurred()) SWIG_fail;
10872 }
10873 resultobj = SWIG_Py_Void();
10874 return resultobj;
10875 fail:
10876 return NULL;
10877 }
10878
10879
10880 SWIGINTERN PyObject *_wrap_TimerRunner_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10881 PyObject *resultobj = 0;
10882 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
10883 int arg2 ;
10884 bool arg3 = (bool) false ;
10885 void *argp1 = 0 ;
10886 int res1 = 0 ;
10887 int val2 ;
10888 int ecode2 = 0 ;
10889 bool val3 ;
10890 int ecode3 = 0 ;
10891 PyObject * obj0 = 0 ;
10892 PyObject * obj1 = 0 ;
10893 PyObject * obj2 = 0 ;
10894 char * kwnames[] = {
10895 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
10896 };
10897
10898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimerRunner, 0 | 0 );
10900 if (!SWIG_IsOK(res1)) {
10901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerRunner_Start" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
10902 }
10903 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
10904 ecode2 = SWIG_AsVal_int(obj1, &val2);
10905 if (!SWIG_IsOK(ecode2)) {
10906 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimerRunner_Start" "', expected argument " "2"" of type '" "int""'");
10907 }
10908 arg2 = static_cast< int >(val2);
10909 if (obj2) {
10910 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10911 if (!SWIG_IsOK(ecode3)) {
10912 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TimerRunner_Start" "', expected argument " "3"" of type '" "bool""'");
10913 }
10914 arg3 = static_cast< bool >(val3);
10915 }
10916 {
10917 PyThreadState* __tstate = wxPyBeginAllowThreads();
10918 (arg1)->Start(arg2,arg3);
10919 wxPyEndAllowThreads(__tstate);
10920 if (PyErr_Occurred()) SWIG_fail;
10921 }
10922 resultobj = SWIG_Py_Void();
10923 return resultobj;
10924 fail:
10925 return NULL;
10926 }
10927
10928
10929 SWIGINTERN PyObject *TimerRunner_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10930 PyObject *obj;
10931 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10932 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerRunner, SWIG_NewClientData(obj));
10933 return SWIG_Py_Void();
10934 }
10935
10936 SWIGINTERN PyObject *TimerRunner_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10937 return SWIG_Python_InitShadowInstance(args);
10938 }
10939
10940 SWIGINTERN PyObject *_wrap_new_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10941 PyObject *resultobj = 0;
10942 wxLog *result = 0 ;
10943
10944 if (!SWIG_Python_UnpackTuple(args,"new_Log",0,0,0)) SWIG_fail;
10945 {
10946 PyThreadState* __tstate = wxPyBeginAllowThreads();
10947 result = (wxLog *)new wxLog();
10948 wxPyEndAllowThreads(__tstate);
10949 if (PyErr_Occurred()) SWIG_fail;
10950 }
10951 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_NEW | 0 );
10952 return resultobj;
10953 fail:
10954 return NULL;
10955 }
10956
10957
10958 SWIGINTERN PyObject *_wrap_delete_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10959 PyObject *resultobj = 0;
10960 wxLog *arg1 = (wxLog *) 0 ;
10961 void *argp1 = 0 ;
10962 int res1 = 0 ;
10963 PyObject *swig_obj[1] ;
10964
10965 if (!args) SWIG_fail;
10966 swig_obj[0] = args;
10967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
10968 if (!SWIG_IsOK(res1)) {
10969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Log" "', expected argument " "1"" of type '" "wxLog *""'");
10970 }
10971 arg1 = reinterpret_cast< wxLog * >(argp1);
10972 {
10973 PyThreadState* __tstate = wxPyBeginAllowThreads();
10974 delete arg1;
10975
10976 wxPyEndAllowThreads(__tstate);
10977 if (PyErr_Occurred()) SWIG_fail;
10978 }
10979 resultobj = SWIG_Py_Void();
10980 return resultobj;
10981 fail:
10982 return NULL;
10983 }
10984
10985
10986 SWIGINTERN PyObject *_wrap_Log_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10987 PyObject *resultobj = 0;
10988 bool result;
10989
10990 if (!SWIG_Python_UnpackTuple(args,"Log_IsEnabled",0,0,0)) SWIG_fail;
10991 {
10992 PyThreadState* __tstate = wxPyBeginAllowThreads();
10993 result = (bool)wxLog::IsEnabled();
10994 wxPyEndAllowThreads(__tstate);
10995 if (PyErr_Occurred()) SWIG_fail;
10996 }
10997 {
10998 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10999 }
11000 return resultobj;
11001 fail:
11002 return NULL;
11003 }
11004
11005
11006 SWIGINTERN PyObject *_wrap_Log_EnableLogging(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11007 PyObject *resultobj = 0;
11008 bool arg1 = (bool) true ;
11009 bool result;
11010 bool val1 ;
11011 int ecode1 = 0 ;
11012 PyObject * obj0 = 0 ;
11013 char * kwnames[] = {
11014 (char *) "doIt", NULL
11015 };
11016
11017 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) SWIG_fail;
11018 if (obj0) {
11019 ecode1 = SWIG_AsVal_bool(obj0, &val1);
11020 if (!SWIG_IsOK(ecode1)) {
11021 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_EnableLogging" "', expected argument " "1"" of type '" "bool""'");
11022 }
11023 arg1 = static_cast< bool >(val1);
11024 }
11025 {
11026 PyThreadState* __tstate = wxPyBeginAllowThreads();
11027 result = (bool)wxLog::EnableLogging(arg1);
11028 wxPyEndAllowThreads(__tstate);
11029 if (PyErr_Occurred()) SWIG_fail;
11030 }
11031 {
11032 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11033 }
11034 return resultobj;
11035 fail:
11036 return NULL;
11037 }
11038
11039
11040 SWIGINTERN PyObject *_wrap_Log_OnLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11041 PyObject *resultobj = 0;
11042 wxLogLevel arg1 ;
11043 wxChar *arg2 = (wxChar *) 0 ;
11044 time_t arg3 ;
11045 unsigned long val1 ;
11046 int ecode1 = 0 ;
11047 void *argp2 = 0 ;
11048 int res2 = 0 ;
11049 unsigned int val3 ;
11050 int ecode3 = 0 ;
11051 PyObject * obj0 = 0 ;
11052 PyObject * obj1 = 0 ;
11053 PyObject * obj2 = 0 ;
11054 char * kwnames[] = {
11055 (char *) "level",(char *) "szString",(char *) "t", NULL
11056 };
11057
11058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11059 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
11060 if (!SWIG_IsOK(ecode1)) {
11061 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_OnLog" "', expected argument " "1"" of type '" "wxLogLevel""'");
11062 }
11063 arg1 = static_cast< wxLogLevel >(val1);
11064 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxChar, 0 | 0 );
11065 if (!SWIG_IsOK(res2)) {
11066 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Log_OnLog" "', expected argument " "2"" of type '" "wxChar const *""'");
11067 }
11068 arg2 = reinterpret_cast< wxChar * >(argp2);
11069 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
11070 if (!SWIG_IsOK(ecode3)) {
11071 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Log_OnLog" "', expected argument " "3"" of type '" "time_t""'");
11072 }
11073 arg3 = static_cast< time_t >(val3);
11074 {
11075 PyThreadState* __tstate = wxPyBeginAllowThreads();
11076 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
11077 wxPyEndAllowThreads(__tstate);
11078 if (PyErr_Occurred()) SWIG_fail;
11079 }
11080 resultobj = SWIG_Py_Void();
11081 return resultobj;
11082 fail:
11083 return NULL;
11084 }
11085
11086
11087 SWIGINTERN PyObject *_wrap_Log_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11088 PyObject *resultobj = 0;
11089 wxLog *arg1 = (wxLog *) 0 ;
11090 void *argp1 = 0 ;
11091 int res1 = 0 ;
11092 PyObject *swig_obj[1] ;
11093
11094 if (!args) SWIG_fail;
11095 swig_obj[0] = args;
11096 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
11097 if (!SWIG_IsOK(res1)) {
11098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Flush" "', expected argument " "1"" of type '" "wxLog *""'");
11099 }
11100 arg1 = reinterpret_cast< wxLog * >(argp1);
11101 {
11102 PyThreadState* __tstate = wxPyBeginAllowThreads();
11103 (arg1)->Flush();
11104 wxPyEndAllowThreads(__tstate);
11105 if (PyErr_Occurred()) SWIG_fail;
11106 }
11107 resultobj = SWIG_Py_Void();
11108 return resultobj;
11109 fail:
11110 return NULL;
11111 }
11112
11113
11114 SWIGINTERN PyObject *_wrap_Log_FlushActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11115 PyObject *resultobj = 0;
11116
11117 if (!SWIG_Python_UnpackTuple(args,"Log_FlushActive",0,0,0)) SWIG_fail;
11118 {
11119 PyThreadState* __tstate = wxPyBeginAllowThreads();
11120 wxLog::FlushActive();
11121 wxPyEndAllowThreads(__tstate);
11122 if (PyErr_Occurred()) SWIG_fail;
11123 }
11124 resultobj = SWIG_Py_Void();
11125 return resultobj;
11126 fail:
11127 return NULL;
11128 }
11129
11130
11131 SWIGINTERN PyObject *_wrap_Log_GetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11132 PyObject *resultobj = 0;
11133 wxLog *result = 0 ;
11134
11135 if (!SWIG_Python_UnpackTuple(args,"Log_GetActiveTarget",0,0,0)) SWIG_fail;
11136 {
11137 PyThreadState* __tstate = wxPyBeginAllowThreads();
11138 result = (wxLog *)wxLog::GetActiveTarget();
11139 wxPyEndAllowThreads(__tstate);
11140 if (PyErr_Occurred()) SWIG_fail;
11141 }
11142 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
11143 return resultobj;
11144 fail:
11145 return NULL;
11146 }
11147
11148
11149 SWIGINTERN PyObject *_wrap_Log_SetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11150 PyObject *resultobj = 0;
11151 wxLog *arg1 = (wxLog *) 0 ;
11152 wxLog *result = 0 ;
11153 int res1 = 0 ;
11154 PyObject * obj0 = 0 ;
11155 char * kwnames[] = {
11156 (char *) "pLogger", NULL
11157 };
11158
11159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) SWIG_fail;
11160 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
11161 if (!SWIG_IsOK(res1)) {
11162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetActiveTarget" "', expected argument " "1"" of type '" "wxLog *""'");
11163 }
11164 {
11165 PyThreadState* __tstate = wxPyBeginAllowThreads();
11166 result = (wxLog *)wxLog::SetActiveTarget(arg1);
11167 wxPyEndAllowThreads(__tstate);
11168 if (PyErr_Occurred()) SWIG_fail;
11169 }
11170 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_OWN | 0 );
11171 return resultobj;
11172 fail:
11173 return NULL;
11174 }
11175
11176
11177 SWIGINTERN PyObject *_wrap_Log_Suspend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11178 PyObject *resultobj = 0;
11179
11180 if (!SWIG_Python_UnpackTuple(args,"Log_Suspend",0,0,0)) SWIG_fail;
11181 {
11182 PyThreadState* __tstate = wxPyBeginAllowThreads();
11183 wxLog::Suspend();
11184 wxPyEndAllowThreads(__tstate);
11185 if (PyErr_Occurred()) SWIG_fail;
11186 }
11187 resultobj = SWIG_Py_Void();
11188 return resultobj;
11189 fail:
11190 return NULL;
11191 }
11192
11193
11194 SWIGINTERN PyObject *_wrap_Log_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11195 PyObject *resultobj = 0;
11196
11197 if (!SWIG_Python_UnpackTuple(args,"Log_Resume",0,0,0)) SWIG_fail;
11198 {
11199 PyThreadState* __tstate = wxPyBeginAllowThreads();
11200 wxLog::Resume();
11201 wxPyEndAllowThreads(__tstate);
11202 if (PyErr_Occurred()) SWIG_fail;
11203 }
11204 resultobj = SWIG_Py_Void();
11205 return resultobj;
11206 fail:
11207 return NULL;
11208 }
11209
11210
11211 SWIGINTERN PyObject *_wrap_Log_SetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11212 PyObject *resultobj = 0;
11213 bool arg1 = (bool) true ;
11214 bool val1 ;
11215 int ecode1 = 0 ;
11216 PyObject * obj0 = 0 ;
11217 char * kwnames[] = {
11218 (char *) "bVerbose", NULL
11219 };
11220
11221 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) SWIG_fail;
11222 if (obj0) {
11223 ecode1 = SWIG_AsVal_bool(obj0, &val1);
11224 if (!SWIG_IsOK(ecode1)) {
11225 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetVerbose" "', expected argument " "1"" of type '" "bool""'");
11226 }
11227 arg1 = static_cast< bool >(val1);
11228 }
11229 {
11230 PyThreadState* __tstate = wxPyBeginAllowThreads();
11231 wxLog::SetVerbose(arg1);
11232 wxPyEndAllowThreads(__tstate);
11233 if (PyErr_Occurred()) SWIG_fail;
11234 }
11235 resultobj = SWIG_Py_Void();
11236 return resultobj;
11237 fail:
11238 return NULL;
11239 }
11240
11241
11242 SWIGINTERN PyObject *_wrap_Log_SetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11243 PyObject *resultobj = 0;
11244 wxLogLevel arg1 ;
11245 unsigned long val1 ;
11246 int ecode1 = 0 ;
11247 PyObject * obj0 = 0 ;
11248 char * kwnames[] = {
11249 (char *) "logLevel", NULL
11250 };
11251
11252 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) SWIG_fail;
11253 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
11254 if (!SWIG_IsOK(ecode1)) {
11255 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetLogLevel" "', expected argument " "1"" of type '" "wxLogLevel""'");
11256 }
11257 arg1 = static_cast< wxLogLevel >(val1);
11258 {
11259 PyThreadState* __tstate = wxPyBeginAllowThreads();
11260 wxLog::SetLogLevel(arg1);
11261 wxPyEndAllowThreads(__tstate);
11262 if (PyErr_Occurred()) SWIG_fail;
11263 }
11264 resultobj = SWIG_Py_Void();
11265 return resultobj;
11266 fail:
11267 return NULL;
11268 }
11269
11270
11271 SWIGINTERN PyObject *_wrap_Log_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11272 PyObject *resultobj = 0;
11273
11274 if (!SWIG_Python_UnpackTuple(args,"Log_DontCreateOnDemand",0,0,0)) SWIG_fail;
11275 {
11276 PyThreadState* __tstate = wxPyBeginAllowThreads();
11277 wxLog::DontCreateOnDemand();
11278 wxPyEndAllowThreads(__tstate);
11279 if (PyErr_Occurred()) SWIG_fail;
11280 }
11281 resultobj = SWIG_Py_Void();
11282 return resultobj;
11283 fail:
11284 return NULL;
11285 }
11286
11287
11288 SWIGINTERN PyObject *_wrap_Log_SetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11289 PyObject *resultobj = 0;
11290 wxTraceMask arg1 ;
11291 unsigned long val1 ;
11292 int ecode1 = 0 ;
11293 PyObject * obj0 = 0 ;
11294 char * kwnames[] = {
11295 (char *) "ulMask", NULL
11296 };
11297
11298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) SWIG_fail;
11299 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
11300 if (!SWIG_IsOK(ecode1)) {
11301 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetTraceMask" "', expected argument " "1"" of type '" "wxTraceMask""'");
11302 }
11303 arg1 = static_cast< wxTraceMask >(val1);
11304 {
11305 PyThreadState* __tstate = wxPyBeginAllowThreads();
11306 wxLog::SetTraceMask(arg1);
11307 wxPyEndAllowThreads(__tstate);
11308 if (PyErr_Occurred()) SWIG_fail;
11309 }
11310 resultobj = SWIG_Py_Void();
11311 return resultobj;
11312 fail:
11313 return NULL;
11314 }
11315
11316
11317 SWIGINTERN PyObject *_wrap_Log_AddTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11318 PyObject *resultobj = 0;
11319 wxString *arg1 = 0 ;
11320 bool temp1 = false ;
11321 PyObject * obj0 = 0 ;
11322 char * kwnames[] = {
11323 (char *) "str", NULL
11324 };
11325
11326 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) SWIG_fail;
11327 {
11328 arg1 = wxString_in_helper(obj0);
11329 if (arg1 == NULL) SWIG_fail;
11330 temp1 = true;
11331 }
11332 {
11333 PyThreadState* __tstate = wxPyBeginAllowThreads();
11334 wxLog::AddTraceMask((wxString const &)*arg1);
11335 wxPyEndAllowThreads(__tstate);
11336 if (PyErr_Occurred()) SWIG_fail;
11337 }
11338 resultobj = SWIG_Py_Void();
11339 {
11340 if (temp1)
11341 delete arg1;
11342 }
11343 return resultobj;
11344 fail:
11345 {
11346 if (temp1)
11347 delete arg1;
11348 }
11349 return NULL;
11350 }
11351
11352
11353 SWIGINTERN PyObject *_wrap_Log_RemoveTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11354 PyObject *resultobj = 0;
11355 wxString *arg1 = 0 ;
11356 bool temp1 = false ;
11357 PyObject * obj0 = 0 ;
11358 char * kwnames[] = {
11359 (char *) "str", NULL
11360 };
11361
11362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) SWIG_fail;
11363 {
11364 arg1 = wxString_in_helper(obj0);
11365 if (arg1 == NULL) SWIG_fail;
11366 temp1 = true;
11367 }
11368 {
11369 PyThreadState* __tstate = wxPyBeginAllowThreads();
11370 wxLog::RemoveTraceMask((wxString const &)*arg1);
11371 wxPyEndAllowThreads(__tstate);
11372 if (PyErr_Occurred()) SWIG_fail;
11373 }
11374 resultobj = SWIG_Py_Void();
11375 {
11376 if (temp1)
11377 delete arg1;
11378 }
11379 return resultobj;
11380 fail:
11381 {
11382 if (temp1)
11383 delete arg1;
11384 }
11385 return NULL;
11386 }
11387
11388
11389 SWIGINTERN PyObject *_wrap_Log_ClearTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11390 PyObject *resultobj = 0;
11391
11392 if (!SWIG_Python_UnpackTuple(args,"Log_ClearTraceMasks",0,0,0)) SWIG_fail;
11393 {
11394 PyThreadState* __tstate = wxPyBeginAllowThreads();
11395 wxLog::ClearTraceMasks();
11396 wxPyEndAllowThreads(__tstate);
11397 if (PyErr_Occurred()) SWIG_fail;
11398 }
11399 resultobj = SWIG_Py_Void();
11400 return resultobj;
11401 fail:
11402 return NULL;
11403 }
11404
11405
11406 SWIGINTERN PyObject *_wrap_Log_GetTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11407 PyObject *resultobj = 0;
11408 wxArrayString *result = 0 ;
11409
11410 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMasks",0,0,0)) SWIG_fail;
11411 {
11412 PyThreadState* __tstate = wxPyBeginAllowThreads();
11413 {
11414 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
11415 result = (wxArrayString *) &_result_ref;
11416 }
11417 wxPyEndAllowThreads(__tstate);
11418 if (PyErr_Occurred()) SWIG_fail;
11419 }
11420 {
11421 resultobj = wxArrayString2PyList_helper(*result);
11422 }
11423 return resultobj;
11424 fail:
11425 return NULL;
11426 }
11427
11428
11429 SWIGINTERN PyObject *_wrap_Log_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11430 PyObject *resultobj = 0;
11431 wxChar *arg1 = (wxChar *) 0 ;
11432 void *argp1 = 0 ;
11433 int res1 = 0 ;
11434 PyObject * obj0 = 0 ;
11435 char * kwnames[] = {
11436 (char *) "ts", NULL
11437 };
11438
11439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) SWIG_fail;
11440 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
11441 if (!SWIG_IsOK(res1)) {
11442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetTimestamp" "', expected argument " "1"" of type '" "wxChar const *""'");
11443 }
11444 arg1 = reinterpret_cast< wxChar * >(argp1);
11445 {
11446 PyThreadState* __tstate = wxPyBeginAllowThreads();
11447 wxLog::SetTimestamp((wxChar const *)arg1);
11448 wxPyEndAllowThreads(__tstate);
11449 if (PyErr_Occurred()) SWIG_fail;
11450 }
11451 resultobj = SWIG_Py_Void();
11452 return resultobj;
11453 fail:
11454 return NULL;
11455 }
11456
11457
11458 SWIGINTERN PyObject *_wrap_Log_GetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11459 PyObject *resultobj = 0;
11460 bool result;
11461
11462 if (!SWIG_Python_UnpackTuple(args,"Log_GetVerbose",0,0,0)) SWIG_fail;
11463 {
11464 PyThreadState* __tstate = wxPyBeginAllowThreads();
11465 result = (bool)wxLog::GetVerbose();
11466 wxPyEndAllowThreads(__tstate);
11467 if (PyErr_Occurred()) SWIG_fail;
11468 }
11469 {
11470 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11471 }
11472 return resultobj;
11473 fail:
11474 return NULL;
11475 }
11476
11477
11478 SWIGINTERN PyObject *_wrap_Log_GetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11479 PyObject *resultobj = 0;
11480 wxTraceMask result;
11481
11482 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMask",0,0,0)) SWIG_fail;
11483 {
11484 PyThreadState* __tstate = wxPyBeginAllowThreads();
11485 result = (wxTraceMask)wxLog::GetTraceMask();
11486 wxPyEndAllowThreads(__tstate);
11487 if (PyErr_Occurred()) SWIG_fail;
11488 }
11489 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
11490 return resultobj;
11491 fail:
11492 return NULL;
11493 }
11494
11495
11496 SWIGINTERN PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11497 PyObject *resultobj = 0;
11498 wxChar *arg1 = (wxChar *) 0 ;
11499 bool result;
11500 void *argp1 = 0 ;
11501 int res1 = 0 ;
11502 PyObject * obj0 = 0 ;
11503 char * kwnames[] = {
11504 (char *) "mask", NULL
11505 };
11506
11507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) SWIG_fail;
11508 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
11509 if (!SWIG_IsOK(res1)) {
11510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_IsAllowedTraceMask" "', expected argument " "1"" of type '" "wxChar const *""'");
11511 }
11512 arg1 = reinterpret_cast< wxChar * >(argp1);
11513 {
11514 PyThreadState* __tstate = wxPyBeginAllowThreads();
11515 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
11516 wxPyEndAllowThreads(__tstate);
11517 if (PyErr_Occurred()) SWIG_fail;
11518 }
11519 {
11520 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11521 }
11522 return resultobj;
11523 fail:
11524 return NULL;
11525 }
11526
11527
11528 SWIGINTERN PyObject *_wrap_Log_GetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11529 PyObject *resultobj = 0;
11530 wxLogLevel result;
11531
11532 if (!SWIG_Python_UnpackTuple(args,"Log_GetLogLevel",0,0,0)) SWIG_fail;
11533 {
11534 PyThreadState* __tstate = wxPyBeginAllowThreads();
11535 result = (wxLogLevel)wxLog::GetLogLevel();
11536 wxPyEndAllowThreads(__tstate);
11537 if (PyErr_Occurred()) SWIG_fail;
11538 }
11539 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
11540 return resultobj;
11541 fail:
11542 return NULL;
11543 }
11544
11545
11546 SWIGINTERN PyObject *_wrap_Log_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11547 PyObject *resultobj = 0;
11548 wxChar *result = 0 ;
11549
11550 if (!SWIG_Python_UnpackTuple(args,"Log_GetTimestamp",0,0,0)) SWIG_fail;
11551 {
11552 PyThreadState* __tstate = wxPyBeginAllowThreads();
11553 result = (wxChar *)wxLog::GetTimestamp();
11554 wxPyEndAllowThreads(__tstate);
11555 if (PyErr_Occurred()) SWIG_fail;
11556 }
11557 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChar, 0 | 0 );
11558 return resultobj;
11559 fail:
11560 return NULL;
11561 }
11562
11563
11564 SWIGINTERN PyObject *_wrap_Log_TimeStamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11565 PyObject *resultobj = 0;
11566 wxString result;
11567
11568 if (!SWIG_Python_UnpackTuple(args,"Log_TimeStamp",0,0,0)) SWIG_fail;
11569 {
11570 PyThreadState* __tstate = wxPyBeginAllowThreads();
11571 result = wxLog_TimeStamp();
11572 wxPyEndAllowThreads(__tstate);
11573 if (PyErr_Occurred()) SWIG_fail;
11574 }
11575 {
11576 #if wxUSE_UNICODE
11577 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11578 #else
11579 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11580 #endif
11581 }
11582 return resultobj;
11583 fail:
11584 return NULL;
11585 }
11586
11587
11588 SWIGINTERN PyObject *_wrap_Log_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11589 PyObject *resultobj = 0;
11590 wxLog *arg1 = (wxLog *) 0 ;
11591 void *argp1 = 0 ;
11592 int res1 = 0 ;
11593 PyObject *swig_obj[1] ;
11594
11595 if (!args) SWIG_fail;
11596 swig_obj[0] = args;
11597 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
11598 if (!SWIG_IsOK(res1)) {
11599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Destroy" "', expected argument " "1"" of type '" "wxLog *""'");
11600 }
11601 arg1 = reinterpret_cast< wxLog * >(argp1);
11602 {
11603 PyThreadState* __tstate = wxPyBeginAllowThreads();
11604 wxLog_Destroy(arg1);
11605 wxPyEndAllowThreads(__tstate);
11606 if (PyErr_Occurred()) SWIG_fail;
11607 }
11608 resultobj = SWIG_Py_Void();
11609 return resultobj;
11610 fail:
11611 return NULL;
11612 }
11613
11614
11615 SWIGINTERN PyObject *Log_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11616 PyObject *obj;
11617 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11618 SWIG_TypeNewClientData(SWIGTYPE_p_wxLog, SWIG_NewClientData(obj));
11619 return SWIG_Py_Void();
11620 }
11621
11622 SWIGINTERN PyObject *Log_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11623 return SWIG_Python_InitShadowInstance(args);
11624 }
11625
11626 SWIGINTERN PyObject *_wrap_new_LogStderr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11627 PyObject *resultobj = 0;
11628 wxLogStderr *result = 0 ;
11629
11630 if (!SWIG_Python_UnpackTuple(args,"new_LogStderr",0,0,0)) SWIG_fail;
11631 {
11632 PyThreadState* __tstate = wxPyBeginAllowThreads();
11633 result = (wxLogStderr *)new wxLogStderr();
11634 wxPyEndAllowThreads(__tstate);
11635 if (PyErr_Occurred()) SWIG_fail;
11636 }
11637 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogStderr, SWIG_POINTER_NEW | 0 );
11638 return resultobj;
11639 fail:
11640 return NULL;
11641 }
11642
11643
11644 SWIGINTERN PyObject *LogStderr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11645 PyObject *obj;
11646 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11647 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogStderr, SWIG_NewClientData(obj));
11648 return SWIG_Py_Void();
11649 }
11650
11651 SWIGINTERN PyObject *LogStderr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11652 return SWIG_Python_InitShadowInstance(args);
11653 }
11654
11655 SWIGINTERN PyObject *_wrap_new_LogTextCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11656 PyObject *resultobj = 0;
11657 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
11658 wxLogTextCtrl *result = 0 ;
11659 void *argp1 = 0 ;
11660 int res1 = 0 ;
11661 PyObject * obj0 = 0 ;
11662 char * kwnames[] = {
11663 (char *) "pTextCtrl", NULL
11664 };
11665
11666 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) SWIG_fail;
11667 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextCtrl, 0 | 0 );
11668 if (!SWIG_IsOK(res1)) {
11669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogTextCtrl" "', expected argument " "1"" of type '" "wxTextCtrl *""'");
11670 }
11671 arg1 = reinterpret_cast< wxTextCtrl * >(argp1);
11672 {
11673 PyThreadState* __tstate = wxPyBeginAllowThreads();
11674 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
11675 wxPyEndAllowThreads(__tstate);
11676 if (PyErr_Occurred()) SWIG_fail;
11677 }
11678 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogTextCtrl, SWIG_POINTER_NEW | 0 );
11679 return resultobj;
11680 fail:
11681 return NULL;
11682 }
11683
11684
11685 SWIGINTERN PyObject *LogTextCtrl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11686 PyObject *obj;
11687 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11688 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogTextCtrl, SWIG_NewClientData(obj));
11689 return SWIG_Py_Void();
11690 }
11691
11692 SWIGINTERN PyObject *LogTextCtrl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11693 return SWIG_Python_InitShadowInstance(args);
11694 }
11695
11696 SWIGINTERN PyObject *_wrap_new_LogGui(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11697 PyObject *resultobj = 0;
11698 wxLogGui *result = 0 ;
11699
11700 if (!SWIG_Python_UnpackTuple(args,"new_LogGui",0,0,0)) SWIG_fail;
11701 {
11702 PyThreadState* __tstate = wxPyBeginAllowThreads();
11703 result = (wxLogGui *)new wxLogGui();
11704 wxPyEndAllowThreads(__tstate);
11705 if (PyErr_Occurred()) SWIG_fail;
11706 }
11707 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogGui, SWIG_POINTER_NEW | 0 );
11708 return resultobj;
11709 fail:
11710 return NULL;
11711 }
11712
11713
11714 SWIGINTERN PyObject *LogGui_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11715 PyObject *obj;
11716 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11717 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogGui, SWIG_NewClientData(obj));
11718 return SWIG_Py_Void();
11719 }
11720
11721 SWIGINTERN PyObject *LogGui_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11722 return SWIG_Python_InitShadowInstance(args);
11723 }
11724
11725 SWIGINTERN PyObject *_wrap_new_LogWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11726 PyObject *resultobj = 0;
11727 wxFrame *arg1 = (wxFrame *) 0 ;
11728 wxString *arg2 = 0 ;
11729 bool arg3 = (bool) true ;
11730 bool arg4 = (bool) true ;
11731 wxLogWindow *result = 0 ;
11732 void *argp1 = 0 ;
11733 int res1 = 0 ;
11734 bool temp2 = false ;
11735 bool val3 ;
11736 int ecode3 = 0 ;
11737 bool val4 ;
11738 int ecode4 = 0 ;
11739 PyObject * obj0 = 0 ;
11740 PyObject * obj1 = 0 ;
11741 PyObject * obj2 = 0 ;
11742 PyObject * obj3 = 0 ;
11743 char * kwnames[] = {
11744 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
11745 };
11746
11747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
11749 if (!SWIG_IsOK(res1)) {
11750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogWindow" "', expected argument " "1"" of type '" "wxFrame *""'");
11751 }
11752 arg1 = reinterpret_cast< wxFrame * >(argp1);
11753 {
11754 arg2 = wxString_in_helper(obj1);
11755 if (arg2 == NULL) SWIG_fail;
11756 temp2 = true;
11757 }
11758 if (obj2) {
11759 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11760 if (!SWIG_IsOK(ecode3)) {
11761 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_LogWindow" "', expected argument " "3"" of type '" "bool""'");
11762 }
11763 arg3 = static_cast< bool >(val3);
11764 }
11765 if (obj3) {
11766 ecode4 = SWIG_AsVal_bool(obj3, &val4);
11767 if (!SWIG_IsOK(ecode4)) {
11768 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LogWindow" "', expected argument " "4"" of type '" "bool""'");
11769 }
11770 arg4 = static_cast< bool >(val4);
11771 }
11772 {
11773 PyThreadState* __tstate = wxPyBeginAllowThreads();
11774 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
11775 wxPyEndAllowThreads(__tstate);
11776 if (PyErr_Occurred()) SWIG_fail;
11777 }
11778 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogWindow, SWIG_POINTER_NEW | 0 );
11779 {
11780 if (temp2)
11781 delete arg2;
11782 }
11783 return resultobj;
11784 fail:
11785 {
11786 if (temp2)
11787 delete arg2;
11788 }
11789 return NULL;
11790 }
11791
11792
11793 SWIGINTERN PyObject *_wrap_LogWindow_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11794 PyObject *resultobj = 0;
11795 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
11796 bool arg2 = (bool) true ;
11797 void *argp1 = 0 ;
11798 int res1 = 0 ;
11799 bool val2 ;
11800 int ecode2 = 0 ;
11801 PyObject * obj0 = 0 ;
11802 PyObject * obj1 = 0 ;
11803 char * kwnames[] = {
11804 (char *) "self",(char *) "bShow", NULL
11805 };
11806
11807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) SWIG_fail;
11808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
11809 if (!SWIG_IsOK(res1)) {
11810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_Show" "', expected argument " "1"" of type '" "wxLogWindow *""'");
11811 }
11812 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
11813 if (obj1) {
11814 ecode2 = SWIG_AsVal_bool(obj1, &val2);
11815 if (!SWIG_IsOK(ecode2)) {
11816 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_Show" "', expected argument " "2"" of type '" "bool""'");
11817 }
11818 arg2 = static_cast< bool >(val2);
11819 }
11820 {
11821 PyThreadState* __tstate = wxPyBeginAllowThreads();
11822 (arg1)->Show(arg2);
11823 wxPyEndAllowThreads(__tstate);
11824 if (PyErr_Occurred()) SWIG_fail;
11825 }
11826 resultobj = SWIG_Py_Void();
11827 return resultobj;
11828 fail:
11829 return NULL;
11830 }
11831
11832
11833 SWIGINTERN PyObject *_wrap_LogWindow_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11834 PyObject *resultobj = 0;
11835 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
11836 wxFrame *result = 0 ;
11837 void *argp1 = 0 ;
11838 int res1 = 0 ;
11839 PyObject *swig_obj[1] ;
11840
11841 if (!args) SWIG_fail;
11842 swig_obj[0] = args;
11843 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
11844 if (!SWIG_IsOK(res1)) {
11845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetFrame" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
11846 }
11847 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
11848 {
11849 PyThreadState* __tstate = wxPyBeginAllowThreads();
11850 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
11851 wxPyEndAllowThreads(__tstate);
11852 if (PyErr_Occurred()) SWIG_fail;
11853 }
11854 {
11855 resultobj = wxPyMake_wxObject(result, (bool)0);
11856 }
11857 return resultobj;
11858 fail:
11859 return NULL;
11860 }
11861
11862
11863 SWIGINTERN PyObject *_wrap_LogWindow_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11864 PyObject *resultobj = 0;
11865 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
11866 wxLog *result = 0 ;
11867 void *argp1 = 0 ;
11868 int res1 = 0 ;
11869 PyObject *swig_obj[1] ;
11870
11871 if (!args) SWIG_fail;
11872 swig_obj[0] = args;
11873 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
11874 if (!SWIG_IsOK(res1)) {
11875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetOldLog" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
11876 }
11877 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
11878 {
11879 PyThreadState* __tstate = wxPyBeginAllowThreads();
11880 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
11881 wxPyEndAllowThreads(__tstate);
11882 if (PyErr_Occurred()) SWIG_fail;
11883 }
11884 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
11885 return resultobj;
11886 fail:
11887 return NULL;
11888 }
11889
11890
11891 SWIGINTERN PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11892 PyObject *resultobj = 0;
11893 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
11894 bool result;
11895 void *argp1 = 0 ;
11896 int res1 = 0 ;
11897 PyObject *swig_obj[1] ;
11898
11899 if (!args) SWIG_fail;
11900 swig_obj[0] = args;
11901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
11902 if (!SWIG_IsOK(res1)) {
11903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
11904 }
11905 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
11906 {
11907 PyThreadState* __tstate = wxPyBeginAllowThreads();
11908 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
11909 wxPyEndAllowThreads(__tstate);
11910 if (PyErr_Occurred()) SWIG_fail;
11911 }
11912 {
11913 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11914 }
11915 return resultobj;
11916 fail:
11917 return NULL;
11918 }
11919
11920
11921 SWIGINTERN PyObject *_wrap_LogWindow_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11922 PyObject *resultobj = 0;
11923 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
11924 bool arg2 ;
11925 void *argp1 = 0 ;
11926 int res1 = 0 ;
11927 bool val2 ;
11928 int ecode2 = 0 ;
11929 PyObject * obj0 = 0 ;
11930 PyObject * obj1 = 0 ;
11931 char * kwnames[] = {
11932 (char *) "self",(char *) "bDoPass", NULL
11933 };
11934
11935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
11936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
11937 if (!SWIG_IsOK(res1)) {
11938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_PassMessages" "', expected argument " "1"" of type '" "wxLogWindow *""'");
11939 }
11940 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
11941 ecode2 = SWIG_AsVal_bool(obj1, &val2);
11942 if (!SWIG_IsOK(ecode2)) {
11943 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_PassMessages" "', expected argument " "2"" of type '" "bool""'");
11944 }
11945 arg2 = static_cast< bool >(val2);
11946 {
11947 PyThreadState* __tstate = wxPyBeginAllowThreads();
11948 (arg1)->PassMessages(arg2);
11949 wxPyEndAllowThreads(__tstate);
11950 if (PyErr_Occurred()) SWIG_fail;
11951 }
11952 resultobj = SWIG_Py_Void();
11953 return resultobj;
11954 fail:
11955 return NULL;
11956 }
11957
11958
11959 SWIGINTERN PyObject *LogWindow_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11960 PyObject *obj;
11961 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11962 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogWindow, SWIG_NewClientData(obj));
11963 return SWIG_Py_Void();
11964 }
11965
11966 SWIGINTERN PyObject *LogWindow_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11967 return SWIG_Python_InitShadowInstance(args);
11968 }
11969
11970 SWIGINTERN PyObject *_wrap_new_LogChain(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11971 PyObject *resultobj = 0;
11972 wxLog *arg1 = (wxLog *) 0 ;
11973 wxLogChain *result = 0 ;
11974 void *argp1 = 0 ;
11975 int res1 = 0 ;
11976 PyObject * obj0 = 0 ;
11977 char * kwnames[] = {
11978 (char *) "logger", NULL
11979 };
11980
11981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) SWIG_fail;
11982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
11983 if (!SWIG_IsOK(res1)) {
11984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogChain" "', expected argument " "1"" of type '" "wxLog *""'");
11985 }
11986 arg1 = reinterpret_cast< wxLog * >(argp1);
11987 {
11988 PyThreadState* __tstate = wxPyBeginAllowThreads();
11989 result = (wxLogChain *)new wxLogChain(arg1);
11990 wxPyEndAllowThreads(__tstate);
11991 if (PyErr_Occurred()) SWIG_fail;
11992 }
11993 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogChain, SWIG_POINTER_NEW | 0 );
11994 return resultobj;
11995 fail:
11996 return NULL;
11997 }
11998
11999
12000 SWIGINTERN PyObject *_wrap_LogChain_SetLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12001 PyObject *resultobj = 0;
12002 wxLogChain *arg1 = (wxLogChain *) 0 ;
12003 wxLog *arg2 = (wxLog *) 0 ;
12004 void *argp1 = 0 ;
12005 int res1 = 0 ;
12006 void *argp2 = 0 ;
12007 int res2 = 0 ;
12008 PyObject * obj0 = 0 ;
12009 PyObject * obj1 = 0 ;
12010 char * kwnames[] = {
12011 (char *) "self",(char *) "logger", NULL
12012 };
12013
12014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) SWIG_fail;
12015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
12016 if (!SWIG_IsOK(res1)) {
12017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_SetLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
12018 }
12019 arg1 = reinterpret_cast< wxLogChain * >(argp1);
12020 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLog, 0 | 0 );
12021 if (!SWIG_IsOK(res2)) {
12022 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LogChain_SetLog" "', expected argument " "2"" of type '" "wxLog *""'");
12023 }
12024 arg2 = reinterpret_cast< wxLog * >(argp2);
12025 {
12026 PyThreadState* __tstate = wxPyBeginAllowThreads();
12027 (arg1)->SetLog(arg2);
12028 wxPyEndAllowThreads(__tstate);
12029 if (PyErr_Occurred()) SWIG_fail;
12030 }
12031 resultobj = SWIG_Py_Void();
12032 return resultobj;
12033 fail:
12034 return NULL;
12035 }
12036
12037
12038 SWIGINTERN PyObject *_wrap_LogChain_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12039 PyObject *resultobj = 0;
12040 wxLogChain *arg1 = (wxLogChain *) 0 ;
12041 bool arg2 ;
12042 void *argp1 = 0 ;
12043 int res1 = 0 ;
12044 bool val2 ;
12045 int ecode2 = 0 ;
12046 PyObject * obj0 = 0 ;
12047 PyObject * obj1 = 0 ;
12048 char * kwnames[] = {
12049 (char *) "self",(char *) "bDoPass", NULL
12050 };
12051
12052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
12053 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
12054 if (!SWIG_IsOK(res1)) {
12055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_PassMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
12056 }
12057 arg1 = reinterpret_cast< wxLogChain * >(argp1);
12058 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12059 if (!SWIG_IsOK(ecode2)) {
12060 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogChain_PassMessages" "', expected argument " "2"" of type '" "bool""'");
12061 }
12062 arg2 = static_cast< bool >(val2);
12063 {
12064 PyThreadState* __tstate = wxPyBeginAllowThreads();
12065 (arg1)->PassMessages(arg2);
12066 wxPyEndAllowThreads(__tstate);
12067 if (PyErr_Occurred()) SWIG_fail;
12068 }
12069 resultobj = SWIG_Py_Void();
12070 return resultobj;
12071 fail:
12072 return NULL;
12073 }
12074
12075
12076 SWIGINTERN PyObject *_wrap_LogChain_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12077 PyObject *resultobj = 0;
12078 wxLogChain *arg1 = (wxLogChain *) 0 ;
12079 bool result;
12080 void *argp1 = 0 ;
12081 int res1 = 0 ;
12082 PyObject *swig_obj[1] ;
12083
12084 if (!args) SWIG_fail;
12085 swig_obj[0] = args;
12086 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
12087 if (!SWIG_IsOK(res1)) {
12088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
12089 }
12090 arg1 = reinterpret_cast< wxLogChain * >(argp1);
12091 {
12092 PyThreadState* __tstate = wxPyBeginAllowThreads();
12093 result = (bool)(arg1)->IsPassingMessages();
12094 wxPyEndAllowThreads(__tstate);
12095 if (PyErr_Occurred()) SWIG_fail;
12096 }
12097 {
12098 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12099 }
12100 return resultobj;
12101 fail:
12102 return NULL;
12103 }
12104
12105
12106 SWIGINTERN PyObject *_wrap_LogChain_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12107 PyObject *resultobj = 0;
12108 wxLogChain *arg1 = (wxLogChain *) 0 ;
12109 wxLog *result = 0 ;
12110 void *argp1 = 0 ;
12111 int res1 = 0 ;
12112 PyObject *swig_obj[1] ;
12113
12114 if (!args) SWIG_fail;
12115 swig_obj[0] = args;
12116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
12117 if (!SWIG_IsOK(res1)) {
12118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_GetOldLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
12119 }
12120 arg1 = reinterpret_cast< wxLogChain * >(argp1);
12121 {
12122 PyThreadState* __tstate = wxPyBeginAllowThreads();
12123 result = (wxLog *)(arg1)->GetOldLog();
12124 wxPyEndAllowThreads(__tstate);
12125 if (PyErr_Occurred()) SWIG_fail;
12126 }
12127 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
12128 return resultobj;
12129 fail:
12130 return NULL;
12131 }
12132
12133
12134 SWIGINTERN PyObject *LogChain_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12135 PyObject *obj;
12136 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12137 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogChain, SWIG_NewClientData(obj));
12138 return SWIG_Py_Void();
12139 }
12140
12141 SWIGINTERN PyObject *LogChain_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12142 return SWIG_Python_InitShadowInstance(args);
12143 }
12144
12145 SWIGINTERN PyObject *_wrap_new_LogBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12146 PyObject *resultobj = 0;
12147 wxLogBuffer *result = 0 ;
12148
12149 if (!SWIG_Python_UnpackTuple(args,"new_LogBuffer",0,0,0)) SWIG_fail;
12150 {
12151 PyThreadState* __tstate = wxPyBeginAllowThreads();
12152 result = (wxLogBuffer *)new wxLogBuffer();
12153 wxPyEndAllowThreads(__tstate);
12154 if (PyErr_Occurred()) SWIG_fail;
12155 }
12156 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogBuffer, SWIG_POINTER_NEW | 0 );
12157 return resultobj;
12158 fail:
12159 return NULL;
12160 }
12161
12162
12163 SWIGINTERN PyObject *_wrap_LogBuffer_GetBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12164 PyObject *resultobj = 0;
12165 wxLogBuffer *arg1 = (wxLogBuffer *) 0 ;
12166 wxString *result = 0 ;
12167 void *argp1 = 0 ;
12168 int res1 = 0 ;
12169 PyObject *swig_obj[1] ;
12170
12171 if (!args) SWIG_fail;
12172 swig_obj[0] = args;
12173 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogBuffer, 0 | 0 );
12174 if (!SWIG_IsOK(res1)) {
12175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogBuffer_GetBuffer" "', expected argument " "1"" of type '" "wxLogBuffer const *""'");
12176 }
12177 arg1 = reinterpret_cast< wxLogBuffer * >(argp1);
12178 {
12179 PyThreadState* __tstate = wxPyBeginAllowThreads();
12180 {
12181 wxString const &_result_ref = ((wxLogBuffer const *)arg1)->GetBuffer();
12182 result = (wxString *) &_result_ref;
12183 }
12184 wxPyEndAllowThreads(__tstate);
12185 if (PyErr_Occurred()) SWIG_fail;
12186 }
12187 {
12188 #if wxUSE_UNICODE
12189 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12190 #else
12191 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12192 #endif
12193 }
12194 return resultobj;
12195 fail:
12196 return NULL;
12197 }
12198
12199
12200 SWIGINTERN PyObject *LogBuffer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12201 PyObject *obj;
12202 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12203 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogBuffer, SWIG_NewClientData(obj));
12204 return SWIG_Py_Void();
12205 }
12206
12207 SWIGINTERN PyObject *LogBuffer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12208 return SWIG_Python_InitShadowInstance(args);
12209 }
12210
12211 SWIGINTERN PyObject *_wrap_SysErrorCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12212 PyObject *resultobj = 0;
12213 unsigned long result;
12214
12215 if (!SWIG_Python_UnpackTuple(args,"SysErrorCode",0,0,0)) SWIG_fail;
12216 {
12217 PyThreadState* __tstate = wxPyBeginAllowThreads();
12218 result = (unsigned long)wxSysErrorCode();
12219 wxPyEndAllowThreads(__tstate);
12220 if (PyErr_Occurred()) SWIG_fail;
12221 }
12222 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12223 return resultobj;
12224 fail:
12225 return NULL;
12226 }
12227
12228
12229 SWIGINTERN PyObject *_wrap_SysErrorMsg(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12230 PyObject *resultobj = 0;
12231 unsigned long arg1 = (unsigned long) 0 ;
12232 wxString result;
12233 unsigned long val1 ;
12234 int ecode1 = 0 ;
12235 PyObject * obj0 = 0 ;
12236 char * kwnames[] = {
12237 (char *) "nErrCode", NULL
12238 };
12239
12240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) SWIG_fail;
12241 if (obj0) {
12242 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12243 if (!SWIG_IsOK(ecode1)) {
12244 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SysErrorMsg" "', expected argument " "1"" of type '" "unsigned long""'");
12245 }
12246 arg1 = static_cast< unsigned long >(val1);
12247 }
12248 {
12249 PyThreadState* __tstate = wxPyBeginAllowThreads();
12250 result = wxSysErrorMsg(arg1);
12251 wxPyEndAllowThreads(__tstate);
12252 if (PyErr_Occurred()) SWIG_fail;
12253 }
12254 {
12255 #if wxUSE_UNICODE
12256 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12257 #else
12258 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12259 #endif
12260 }
12261 return resultobj;
12262 fail:
12263 return NULL;
12264 }
12265
12266
12267 SWIGINTERN PyObject *_wrap_LogFatalError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12268 PyObject *resultobj = 0;
12269 wxString *arg1 = 0 ;
12270 bool temp1 = false ;
12271 PyObject * obj0 = 0 ;
12272 char * kwnames[] = {
12273 (char *) "msg", NULL
12274 };
12275
12276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) SWIG_fail;
12277 {
12278 arg1 = wxString_in_helper(obj0);
12279 if (arg1 == NULL) SWIG_fail;
12280 temp1 = true;
12281 }
12282 {
12283 PyThreadState* __tstate = wxPyBeginAllowThreads();
12284 wxPyLogFatalError((wxString const &)*arg1);
12285 wxPyEndAllowThreads(__tstate);
12286 if (PyErr_Occurred()) SWIG_fail;
12287 }
12288 resultobj = SWIG_Py_Void();
12289 {
12290 if (temp1)
12291 delete arg1;
12292 }
12293 return resultobj;
12294 fail:
12295 {
12296 if (temp1)
12297 delete arg1;
12298 }
12299 return NULL;
12300 }
12301
12302
12303 SWIGINTERN PyObject *_wrap_LogError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12304 PyObject *resultobj = 0;
12305 wxString *arg1 = 0 ;
12306 bool temp1 = false ;
12307 PyObject * obj0 = 0 ;
12308 char * kwnames[] = {
12309 (char *) "msg", NULL
12310 };
12311
12312 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) SWIG_fail;
12313 {
12314 arg1 = wxString_in_helper(obj0);
12315 if (arg1 == NULL) SWIG_fail;
12316 temp1 = true;
12317 }
12318 {
12319 PyThreadState* __tstate = wxPyBeginAllowThreads();
12320 wxPyLogError((wxString const &)*arg1);
12321 wxPyEndAllowThreads(__tstate);
12322 if (PyErr_Occurred()) SWIG_fail;
12323 }
12324 resultobj = SWIG_Py_Void();
12325 {
12326 if (temp1)
12327 delete arg1;
12328 }
12329 return resultobj;
12330 fail:
12331 {
12332 if (temp1)
12333 delete arg1;
12334 }
12335 return NULL;
12336 }
12337
12338
12339 SWIGINTERN PyObject *_wrap_LogWarning(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12340 PyObject *resultobj = 0;
12341 wxString *arg1 = 0 ;
12342 bool temp1 = false ;
12343 PyObject * obj0 = 0 ;
12344 char * kwnames[] = {
12345 (char *) "msg", NULL
12346 };
12347
12348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) SWIG_fail;
12349 {
12350 arg1 = wxString_in_helper(obj0);
12351 if (arg1 == NULL) SWIG_fail;
12352 temp1 = true;
12353 }
12354 {
12355 PyThreadState* __tstate = wxPyBeginAllowThreads();
12356 wxPyLogWarning((wxString const &)*arg1);
12357 wxPyEndAllowThreads(__tstate);
12358 if (PyErr_Occurred()) SWIG_fail;
12359 }
12360 resultobj = SWIG_Py_Void();
12361 {
12362 if (temp1)
12363 delete arg1;
12364 }
12365 return resultobj;
12366 fail:
12367 {
12368 if (temp1)
12369 delete arg1;
12370 }
12371 return NULL;
12372 }
12373
12374
12375 SWIGINTERN PyObject *_wrap_LogMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12376 PyObject *resultobj = 0;
12377 wxString *arg1 = 0 ;
12378 bool temp1 = false ;
12379 PyObject * obj0 = 0 ;
12380 char * kwnames[] = {
12381 (char *) "msg", NULL
12382 };
12383
12384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) SWIG_fail;
12385 {
12386 arg1 = wxString_in_helper(obj0);
12387 if (arg1 == NULL) SWIG_fail;
12388 temp1 = true;
12389 }
12390 {
12391 PyThreadState* __tstate = wxPyBeginAllowThreads();
12392 wxPyLogMessage((wxString const &)*arg1);
12393 wxPyEndAllowThreads(__tstate);
12394 if (PyErr_Occurred()) SWIG_fail;
12395 }
12396 resultobj = SWIG_Py_Void();
12397 {
12398 if (temp1)
12399 delete arg1;
12400 }
12401 return resultobj;
12402 fail:
12403 {
12404 if (temp1)
12405 delete arg1;
12406 }
12407 return NULL;
12408 }
12409
12410
12411 SWIGINTERN PyObject *_wrap_LogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12412 PyObject *resultobj = 0;
12413 wxString *arg1 = 0 ;
12414 bool temp1 = false ;
12415 PyObject * obj0 = 0 ;
12416 char * kwnames[] = {
12417 (char *) "msg", NULL
12418 };
12419
12420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) SWIG_fail;
12421 {
12422 arg1 = wxString_in_helper(obj0);
12423 if (arg1 == NULL) SWIG_fail;
12424 temp1 = true;
12425 }
12426 {
12427 PyThreadState* __tstate = wxPyBeginAllowThreads();
12428 wxPyLogInfo((wxString const &)*arg1);
12429 wxPyEndAllowThreads(__tstate);
12430 if (PyErr_Occurred()) SWIG_fail;
12431 }
12432 resultobj = SWIG_Py_Void();
12433 {
12434 if (temp1)
12435 delete arg1;
12436 }
12437 return resultobj;
12438 fail:
12439 {
12440 if (temp1)
12441 delete arg1;
12442 }
12443 return NULL;
12444 }
12445
12446
12447 SWIGINTERN PyObject *_wrap_LogDebug(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12448 PyObject *resultobj = 0;
12449 wxString *arg1 = 0 ;
12450 bool temp1 = false ;
12451 PyObject * obj0 = 0 ;
12452 char * kwnames[] = {
12453 (char *) "msg", NULL
12454 };
12455
12456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) SWIG_fail;
12457 {
12458 arg1 = wxString_in_helper(obj0);
12459 if (arg1 == NULL) SWIG_fail;
12460 temp1 = true;
12461 }
12462 {
12463 PyThreadState* __tstate = wxPyBeginAllowThreads();
12464 wxPyLogDebug((wxString const &)*arg1);
12465 wxPyEndAllowThreads(__tstate);
12466 if (PyErr_Occurred()) SWIG_fail;
12467 }
12468 resultobj = SWIG_Py_Void();
12469 {
12470 if (temp1)
12471 delete arg1;
12472 }
12473 return resultobj;
12474 fail:
12475 {
12476 if (temp1)
12477 delete arg1;
12478 }
12479 return NULL;
12480 }
12481
12482
12483 SWIGINTERN PyObject *_wrap_LogVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12484 PyObject *resultobj = 0;
12485 wxString *arg1 = 0 ;
12486 bool temp1 = false ;
12487 PyObject * obj0 = 0 ;
12488 char * kwnames[] = {
12489 (char *) "msg", NULL
12490 };
12491
12492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) SWIG_fail;
12493 {
12494 arg1 = wxString_in_helper(obj0);
12495 if (arg1 == NULL) SWIG_fail;
12496 temp1 = true;
12497 }
12498 {
12499 PyThreadState* __tstate = wxPyBeginAllowThreads();
12500 wxPyLogVerbose((wxString const &)*arg1);
12501 wxPyEndAllowThreads(__tstate);
12502 if (PyErr_Occurred()) SWIG_fail;
12503 }
12504 resultobj = SWIG_Py_Void();
12505 {
12506 if (temp1)
12507 delete arg1;
12508 }
12509 return resultobj;
12510 fail:
12511 {
12512 if (temp1)
12513 delete arg1;
12514 }
12515 return NULL;
12516 }
12517
12518
12519 SWIGINTERN PyObject *_wrap_LogStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12520 PyObject *resultobj = 0;
12521 wxString *arg1 = 0 ;
12522 bool temp1 = false ;
12523 PyObject * obj0 = 0 ;
12524 char * kwnames[] = {
12525 (char *) "msg", NULL
12526 };
12527
12528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) SWIG_fail;
12529 {
12530 arg1 = wxString_in_helper(obj0);
12531 if (arg1 == NULL) SWIG_fail;
12532 temp1 = true;
12533 }
12534 {
12535 PyThreadState* __tstate = wxPyBeginAllowThreads();
12536 wxPyLogStatus((wxString const &)*arg1);
12537 wxPyEndAllowThreads(__tstate);
12538 if (PyErr_Occurred()) SWIG_fail;
12539 }
12540 resultobj = SWIG_Py_Void();
12541 {
12542 if (temp1)
12543 delete arg1;
12544 }
12545 return resultobj;
12546 fail:
12547 {
12548 if (temp1)
12549 delete arg1;
12550 }
12551 return NULL;
12552 }
12553
12554
12555 SWIGINTERN PyObject *_wrap_LogStatusFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12556 PyObject *resultobj = 0;
12557 wxFrame *arg1 = (wxFrame *) 0 ;
12558 wxString *arg2 = 0 ;
12559 void *argp1 = 0 ;
12560 int res1 = 0 ;
12561 bool temp2 = false ;
12562 PyObject * obj0 = 0 ;
12563 PyObject * obj1 = 0 ;
12564 char * kwnames[] = {
12565 (char *) "pFrame",(char *) "msg", NULL
12566 };
12567
12568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) SWIG_fail;
12569 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
12570 if (!SWIG_IsOK(res1)) {
12571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogStatusFrame" "', expected argument " "1"" of type '" "wxFrame *""'");
12572 }
12573 arg1 = reinterpret_cast< wxFrame * >(argp1);
12574 {
12575 arg2 = wxString_in_helper(obj1);
12576 if (arg2 == NULL) SWIG_fail;
12577 temp2 = true;
12578 }
12579 {
12580 PyThreadState* __tstate = wxPyBeginAllowThreads();
12581 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
12582 wxPyEndAllowThreads(__tstate);
12583 if (PyErr_Occurred()) SWIG_fail;
12584 }
12585 resultobj = SWIG_Py_Void();
12586 {
12587 if (temp2)
12588 delete arg2;
12589 }
12590 return resultobj;
12591 fail:
12592 {
12593 if (temp2)
12594 delete arg2;
12595 }
12596 return NULL;
12597 }
12598
12599
12600 SWIGINTERN PyObject *_wrap_LogSysError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12601 PyObject *resultobj = 0;
12602 wxString *arg1 = 0 ;
12603 bool temp1 = false ;
12604 PyObject * obj0 = 0 ;
12605 char * kwnames[] = {
12606 (char *) "msg", NULL
12607 };
12608
12609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) SWIG_fail;
12610 {
12611 arg1 = wxString_in_helper(obj0);
12612 if (arg1 == NULL) SWIG_fail;
12613 temp1 = true;
12614 }
12615 {
12616 PyThreadState* __tstate = wxPyBeginAllowThreads();
12617 wxPyLogSysError((wxString const &)*arg1);
12618 wxPyEndAllowThreads(__tstate);
12619 if (PyErr_Occurred()) SWIG_fail;
12620 }
12621 resultobj = SWIG_Py_Void();
12622 {
12623 if (temp1)
12624 delete arg1;
12625 }
12626 return resultobj;
12627 fail:
12628 {
12629 if (temp1)
12630 delete arg1;
12631 }
12632 return NULL;
12633 }
12634
12635
12636 SWIGINTERN PyObject *_wrap_LogGeneric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12637 PyObject *resultobj = 0;
12638 unsigned long arg1 ;
12639 wxString *arg2 = 0 ;
12640 unsigned long val1 ;
12641 int ecode1 = 0 ;
12642 bool temp2 = false ;
12643 PyObject * obj0 = 0 ;
12644 PyObject * obj1 = 0 ;
12645 char * kwnames[] = {
12646 (char *) "level",(char *) "msg", NULL
12647 };
12648
12649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) SWIG_fail;
12650 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12651 if (!SWIG_IsOK(ecode1)) {
12652 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogGeneric" "', expected argument " "1"" of type '" "unsigned long""'");
12653 }
12654 arg1 = static_cast< unsigned long >(val1);
12655 {
12656 arg2 = wxString_in_helper(obj1);
12657 if (arg2 == NULL) SWIG_fail;
12658 temp2 = true;
12659 }
12660 {
12661 PyThreadState* __tstate = wxPyBeginAllowThreads();
12662 wxPyLogGeneric(arg1,(wxString const &)*arg2);
12663 wxPyEndAllowThreads(__tstate);
12664 if (PyErr_Occurred()) SWIG_fail;
12665 }
12666 resultobj = SWIG_Py_Void();
12667 {
12668 if (temp2)
12669 delete arg2;
12670 }
12671 return resultobj;
12672 fail:
12673 {
12674 if (temp2)
12675 delete arg2;
12676 }
12677 return NULL;
12678 }
12679
12680
12681 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
12682 PyObject *resultobj = 0;
12683 unsigned long arg1 ;
12684 wxString *arg2 = 0 ;
12685 unsigned long val1 ;
12686 int ecode1 = 0 ;
12687 bool temp2 = false ;
12688
12689 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
12690 ecode1 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val1);
12691 if (!SWIG_IsOK(ecode1)) {
12692 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogTrace" "', expected argument " "1"" of type '" "unsigned long""'");
12693 }
12694 arg1 = static_cast< unsigned long >(val1);
12695 {
12696 arg2 = wxString_in_helper(swig_obj[1]);
12697 if (arg2 == NULL) SWIG_fail;
12698 temp2 = true;
12699 }
12700 {
12701 PyThreadState* __tstate = wxPyBeginAllowThreads();
12702 wxPyLogTrace(arg1,(wxString const &)*arg2);
12703 wxPyEndAllowThreads(__tstate);
12704 if (PyErr_Occurred()) SWIG_fail;
12705 }
12706 resultobj = SWIG_Py_Void();
12707 {
12708 if (temp2)
12709 delete arg2;
12710 }
12711 return resultobj;
12712 fail:
12713 {
12714 if (temp2)
12715 delete arg2;
12716 }
12717 return NULL;
12718 }
12719
12720
12721 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
12722 PyObject *resultobj = 0;
12723 wxString *arg1 = 0 ;
12724 wxString *arg2 = 0 ;
12725 bool temp1 = false ;
12726 bool temp2 = false ;
12727
12728 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
12729 {
12730 arg1 = wxString_in_helper(swig_obj[0]);
12731 if (arg1 == NULL) SWIG_fail;
12732 temp1 = true;
12733 }
12734 {
12735 arg2 = wxString_in_helper(swig_obj[1]);
12736 if (arg2 == NULL) SWIG_fail;
12737 temp2 = true;
12738 }
12739 {
12740 PyThreadState* __tstate = wxPyBeginAllowThreads();
12741 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
12742 wxPyEndAllowThreads(__tstate);
12743 if (PyErr_Occurred()) SWIG_fail;
12744 }
12745 resultobj = SWIG_Py_Void();
12746 {
12747 if (temp1)
12748 delete arg1;
12749 }
12750 {
12751 if (temp2)
12752 delete arg2;
12753 }
12754 return resultobj;
12755 fail:
12756 {
12757 if (temp1)
12758 delete arg1;
12759 }
12760 {
12761 if (temp2)
12762 delete arg2;
12763 }
12764 return NULL;
12765 }
12766
12767
12768 SWIGINTERN PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
12769 int argc;
12770 PyObject *argv[3];
12771
12772 if (!(argc = SWIG_Python_UnpackTuple(args,"LogTrace",0,2,argv))) SWIG_fail;
12773 --argc;
12774 if (argc == 2) {
12775 int _v = 0;
12776 {
12777 {
12778 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
12779 }
12780 }
12781 if (!_v) goto check_1;
12782 return _wrap_LogTrace__SWIG_1(self, argc, argv);
12783 }
12784 check_1:
12785
12786 if (argc == 2) {
12787 return _wrap_LogTrace__SWIG_0(self, argc, argv);
12788 }
12789
12790 fail:
12791 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
12792 return NULL;
12793 }
12794
12795
12796 SWIGINTERN PyObject *_wrap_SafeShowMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12797 PyObject *resultobj = 0;
12798 wxString *arg1 = 0 ;
12799 wxString *arg2 = 0 ;
12800 bool temp1 = false ;
12801 bool temp2 = false ;
12802 PyObject * obj0 = 0 ;
12803 PyObject * obj1 = 0 ;
12804 char * kwnames[] = {
12805 (char *) "title",(char *) "text", NULL
12806 };
12807
12808 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) SWIG_fail;
12809 {
12810 arg1 = wxString_in_helper(obj0);
12811 if (arg1 == NULL) SWIG_fail;
12812 temp1 = true;
12813 }
12814 {
12815 arg2 = wxString_in_helper(obj1);
12816 if (arg2 == NULL) SWIG_fail;
12817 temp2 = true;
12818 }
12819 {
12820 PyThreadState* __tstate = wxPyBeginAllowThreads();
12821 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
12822 wxPyEndAllowThreads(__tstate);
12823 if (PyErr_Occurred()) SWIG_fail;
12824 }
12825 resultobj = SWIG_Py_Void();
12826 {
12827 if (temp1)
12828 delete arg1;
12829 }
12830 {
12831 if (temp2)
12832 delete arg2;
12833 }
12834 return resultobj;
12835 fail:
12836 {
12837 if (temp1)
12838 delete arg1;
12839 }
12840 {
12841 if (temp2)
12842 delete arg2;
12843 }
12844 return NULL;
12845 }
12846
12847
12848 SWIGINTERN PyObject *_wrap_new_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12849 PyObject *resultobj = 0;
12850 wxLogNull *result = 0 ;
12851
12852 if (!SWIG_Python_UnpackTuple(args,"new_LogNull",0,0,0)) SWIG_fail;
12853 {
12854 PyThreadState* __tstate = wxPyBeginAllowThreads();
12855 result = (wxLogNull *)new wxLogNull();
12856 wxPyEndAllowThreads(__tstate);
12857 if (PyErr_Occurred()) SWIG_fail;
12858 }
12859 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogNull, SWIG_POINTER_NEW | 0 );
12860 return resultobj;
12861 fail:
12862 return NULL;
12863 }
12864
12865
12866 SWIGINTERN PyObject *_wrap_delete_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12867 PyObject *resultobj = 0;
12868 wxLogNull *arg1 = (wxLogNull *) 0 ;
12869 void *argp1 = 0 ;
12870 int res1 = 0 ;
12871 PyObject *swig_obj[1] ;
12872
12873 if (!args) SWIG_fail;
12874 swig_obj[0] = args;
12875 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogNull, SWIG_POINTER_DISOWN | 0 );
12876 if (!SWIG_IsOK(res1)) {
12877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LogNull" "', expected argument " "1"" of type '" "wxLogNull *""'");
12878 }
12879 arg1 = reinterpret_cast< wxLogNull * >(argp1);
12880 {
12881 PyThreadState* __tstate = wxPyBeginAllowThreads();
12882 delete arg1;
12883
12884 wxPyEndAllowThreads(__tstate);
12885 if (PyErr_Occurred()) SWIG_fail;
12886 }
12887 resultobj = SWIG_Py_Void();
12888 return resultobj;
12889 fail:
12890 return NULL;
12891 }
12892
12893
12894 SWIGINTERN PyObject *LogNull_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12895 PyObject *obj;
12896 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12897 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogNull, SWIG_NewClientData(obj));
12898 return SWIG_Py_Void();
12899 }
12900
12901 SWIGINTERN PyObject *LogNull_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12902 return SWIG_Python_InitShadowInstance(args);
12903 }
12904
12905 SWIGINTERN PyObject *_wrap_new_PyLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12906 PyObject *resultobj = 0;
12907 wxPyLog *result = 0 ;
12908
12909 if (!SWIG_Python_UnpackTuple(args,"new_PyLog",0,0,0)) SWIG_fail;
12910 {
12911 PyThreadState* __tstate = wxPyBeginAllowThreads();
12912 result = (wxPyLog *)new wxPyLog();
12913 wxPyEndAllowThreads(__tstate);
12914 if (PyErr_Occurred()) SWIG_fail;
12915 }
12916 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyLog, SWIG_POINTER_NEW | 0 );
12917 return resultobj;
12918 fail:
12919 return NULL;
12920 }
12921
12922
12923 SWIGINTERN PyObject *_wrap_PyLog__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12924 PyObject *resultobj = 0;
12925 wxPyLog *arg1 = (wxPyLog *) 0 ;
12926 PyObject *arg2 = (PyObject *) 0 ;
12927 PyObject *arg3 = (PyObject *) 0 ;
12928 void *argp1 = 0 ;
12929 int res1 = 0 ;
12930 PyObject * obj0 = 0 ;
12931 PyObject * obj1 = 0 ;
12932 PyObject * obj2 = 0 ;
12933 char * kwnames[] = {
12934 (char *) "self",(char *) "self",(char *) "_class", NULL
12935 };
12936
12937 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12938 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyLog, 0 | 0 );
12939 if (!SWIG_IsOK(res1)) {
12940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyLog__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyLog *""'");
12941 }
12942 arg1 = reinterpret_cast< wxPyLog * >(argp1);
12943 arg2 = obj1;
12944 arg3 = obj2;
12945 {
12946 PyThreadState* __tstate = wxPyBeginAllowThreads();
12947 (arg1)->_setCallbackInfo(arg2,arg3);
12948 wxPyEndAllowThreads(__tstate);
12949 if (PyErr_Occurred()) SWIG_fail;
12950 }
12951 resultobj = SWIG_Py_Void();
12952 return resultobj;
12953 fail:
12954 return NULL;
12955 }
12956
12957
12958 SWIGINTERN PyObject *PyLog_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12959 PyObject *obj;
12960 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12961 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyLog, SWIG_NewClientData(obj));
12962 return SWIG_Py_Void();
12963 }
12964
12965 SWIGINTERN PyObject *PyLog_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12966 return SWIG_Python_InitShadowInstance(args);
12967 }
12968
12969 SWIGINTERN PyObject *_wrap_Process_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12970 PyObject *resultobj = 0;
12971 int arg1 ;
12972 wxSignal arg2 = (wxSignal) wxSIGTERM ;
12973 int arg3 = (int) wxKILL_NOCHILDREN ;
12974 wxKillError result;
12975 int val1 ;
12976 int ecode1 = 0 ;
12977 int val2 ;
12978 int ecode2 = 0 ;
12979 int val3 ;
12980 int ecode3 = 0 ;
12981 PyObject * obj0 = 0 ;
12982 PyObject * obj1 = 0 ;
12983 PyObject * obj2 = 0 ;
12984 char * kwnames[] = {
12985 (char *) "pid",(char *) "sig",(char *) "flags", NULL
12986 };
12987
12988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12989 ecode1 = SWIG_AsVal_int(obj0, &val1);
12990 if (!SWIG_IsOK(ecode1)) {
12991 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Kill" "', expected argument " "1"" of type '" "int""'");
12992 }
12993 arg1 = static_cast< int >(val1);
12994 if (obj1) {
12995 ecode2 = SWIG_AsVal_int(obj1, &val2);
12996 if (!SWIG_IsOK(ecode2)) {
12997 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Kill" "', expected argument " "2"" of type '" "wxSignal""'");
12998 }
12999 arg2 = static_cast< wxSignal >(val2);
13000 }
13001 if (obj2) {
13002 ecode3 = SWIG_AsVal_int(obj2, &val3);
13003 if (!SWIG_IsOK(ecode3)) {
13004 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_Kill" "', expected argument " "3"" of type '" "int""'");
13005 }
13006 arg3 = static_cast< int >(val3);
13007 }
13008 {
13009 PyThreadState* __tstate = wxPyBeginAllowThreads();
13010 result = (wxKillError)wxPyProcess::Kill(arg1,arg2,arg3);
13011 wxPyEndAllowThreads(__tstate);
13012 if (PyErr_Occurred()) SWIG_fail;
13013 }
13014 resultobj = SWIG_From_int(static_cast< int >(result));
13015 return resultobj;
13016 fail:
13017 return NULL;
13018 }
13019
13020
13021 SWIGINTERN PyObject *_wrap_Process_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13022 PyObject *resultobj = 0;
13023 int arg1 ;
13024 bool result;
13025 int val1 ;
13026 int ecode1 = 0 ;
13027 PyObject * obj0 = 0 ;
13028 char * kwnames[] = {
13029 (char *) "pid", NULL
13030 };
13031
13032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) SWIG_fail;
13033 ecode1 = SWIG_AsVal_int(obj0, &val1);
13034 if (!SWIG_IsOK(ecode1)) {
13035 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Exists" "', expected argument " "1"" of type '" "int""'");
13036 }
13037 arg1 = static_cast< int >(val1);
13038 {
13039 PyThreadState* __tstate = wxPyBeginAllowThreads();
13040 result = (bool)wxPyProcess::Exists(arg1);
13041 wxPyEndAllowThreads(__tstate);
13042 if (PyErr_Occurred()) SWIG_fail;
13043 }
13044 {
13045 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13046 }
13047 return resultobj;
13048 fail:
13049 return NULL;
13050 }
13051
13052
13053 SWIGINTERN PyObject *_wrap_Process_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13054 PyObject *resultobj = 0;
13055 wxString *arg1 = 0 ;
13056 int arg2 = (int) wxEXEC_ASYNC ;
13057 wxPyProcess *result = 0 ;
13058 bool temp1 = false ;
13059 int val2 ;
13060 int ecode2 = 0 ;
13061 PyObject * obj0 = 0 ;
13062 PyObject * obj1 = 0 ;
13063 char * kwnames[] = {
13064 (char *) "cmd",(char *) "flags", NULL
13065 };
13066
13067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) SWIG_fail;
13068 {
13069 arg1 = wxString_in_helper(obj0);
13070 if (arg1 == NULL) SWIG_fail;
13071 temp1 = true;
13072 }
13073 if (obj1) {
13074 ecode2 = SWIG_AsVal_int(obj1, &val2);
13075 if (!SWIG_IsOK(ecode2)) {
13076 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Open" "', expected argument " "2"" of type '" "int""'");
13077 }
13078 arg2 = static_cast< int >(val2);
13079 }
13080 {
13081 PyThreadState* __tstate = wxPyBeginAllowThreads();
13082 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
13083 wxPyEndAllowThreads(__tstate);
13084 if (PyErr_Occurred()) SWIG_fail;
13085 }
13086 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, 0 | 0 );
13087 {
13088 if (temp1)
13089 delete arg1;
13090 }
13091 return resultobj;
13092 fail:
13093 {
13094 if (temp1)
13095 delete arg1;
13096 }
13097 return NULL;
13098 }
13099
13100
13101 SWIGINTERN PyObject *_wrap_new_Process(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13102 PyObject *resultobj = 0;
13103 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
13104 int arg2 = (int) -1 ;
13105 wxPyProcess *result = 0 ;
13106 void *argp1 = 0 ;
13107 int res1 = 0 ;
13108 int val2 ;
13109 int ecode2 = 0 ;
13110 PyObject * obj0 = 0 ;
13111 PyObject * obj1 = 0 ;
13112 char * kwnames[] = {
13113 (char *) "parent",(char *) "id", NULL
13114 };
13115
13116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) SWIG_fail;
13117 if (obj0) {
13118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
13119 if (!SWIG_IsOK(res1)) {
13120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Process" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
13121 }
13122 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
13123 }
13124 if (obj1) {
13125 ecode2 = SWIG_AsVal_int(obj1, &val2);
13126 if (!SWIG_IsOK(ecode2)) {
13127 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Process" "', expected argument " "2"" of type '" "int""'");
13128 }
13129 arg2 = static_cast< int >(val2);
13130 }
13131 {
13132 PyThreadState* __tstate = wxPyBeginAllowThreads();
13133 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
13134 wxPyEndAllowThreads(__tstate);
13135 if (PyErr_Occurred()) SWIG_fail;
13136 }
13137 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, SWIG_POINTER_NEW | 0 );
13138 return resultobj;
13139 fail:
13140 return NULL;
13141 }
13142
13143
13144 SWIGINTERN PyObject *_wrap_Process__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13145 PyObject *resultobj = 0;
13146 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13147 PyObject *arg2 = (PyObject *) 0 ;
13148 PyObject *arg3 = (PyObject *) 0 ;
13149 void *argp1 = 0 ;
13150 int res1 = 0 ;
13151 PyObject * obj0 = 0 ;
13152 PyObject * obj1 = 0 ;
13153 PyObject * obj2 = 0 ;
13154 char * kwnames[] = {
13155 (char *) "self",(char *) "self",(char *) "_class", NULL
13156 };
13157
13158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13160 if (!SWIG_IsOK(res1)) {
13161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13162 }
13163 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13164 arg2 = obj1;
13165 arg3 = obj2;
13166 {
13167 PyThreadState* __tstate = wxPyBeginAllowThreads();
13168 (arg1)->_setCallbackInfo(arg2,arg3);
13169 wxPyEndAllowThreads(__tstate);
13170 if (PyErr_Occurred()) SWIG_fail;
13171 }
13172 resultobj = SWIG_Py_Void();
13173 return resultobj;
13174 fail:
13175 return NULL;
13176 }
13177
13178
13179 SWIGINTERN PyObject *_wrap_Process_OnTerminate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13180 PyObject *resultobj = 0;
13181 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13182 int arg2 ;
13183 int arg3 ;
13184 void *argp1 = 0 ;
13185 int res1 = 0 ;
13186 int val2 ;
13187 int ecode2 = 0 ;
13188 int val3 ;
13189 int ecode3 = 0 ;
13190 PyObject * obj0 = 0 ;
13191 PyObject * obj1 = 0 ;
13192 PyObject * obj2 = 0 ;
13193 char * kwnames[] = {
13194 (char *) "self",(char *) "pid",(char *) "status", NULL
13195 };
13196
13197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_OnTerminate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13199 if (!SWIG_IsOK(res1)) {
13200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_OnTerminate" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13201 }
13202 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13203 ecode2 = SWIG_AsVal_int(obj1, &val2);
13204 if (!SWIG_IsOK(ecode2)) {
13205 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_OnTerminate" "', expected argument " "2"" of type '" "int""'");
13206 }
13207 arg2 = static_cast< int >(val2);
13208 ecode3 = SWIG_AsVal_int(obj2, &val3);
13209 if (!SWIG_IsOK(ecode3)) {
13210 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_OnTerminate" "', expected argument " "3"" of type '" "int""'");
13211 }
13212 arg3 = static_cast< int >(val3);
13213 {
13214 PyThreadState* __tstate = wxPyBeginAllowThreads();
13215 (arg1)->OnTerminate(arg2,arg3);
13216 wxPyEndAllowThreads(__tstate);
13217 if (PyErr_Occurred()) SWIG_fail;
13218 }
13219 resultobj = SWIG_Py_Void();
13220 return resultobj;
13221 fail:
13222 return NULL;
13223 }
13224
13225
13226 SWIGINTERN PyObject *_wrap_Process_Redirect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13227 PyObject *resultobj = 0;
13228 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13229 void *argp1 = 0 ;
13230 int res1 = 0 ;
13231 PyObject *swig_obj[1] ;
13232
13233 if (!args) SWIG_fail;
13234 swig_obj[0] = args;
13235 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13236 if (!SWIG_IsOK(res1)) {
13237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Redirect" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13238 }
13239 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13240 {
13241 PyThreadState* __tstate = wxPyBeginAllowThreads();
13242 (arg1)->Redirect();
13243 wxPyEndAllowThreads(__tstate);
13244 if (PyErr_Occurred()) SWIG_fail;
13245 }
13246 resultobj = SWIG_Py_Void();
13247 return resultobj;
13248 fail:
13249 return NULL;
13250 }
13251
13252
13253 SWIGINTERN PyObject *_wrap_Process_IsRedirected(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13254 PyObject *resultobj = 0;
13255 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13256 bool result;
13257 void *argp1 = 0 ;
13258 int res1 = 0 ;
13259 PyObject *swig_obj[1] ;
13260
13261 if (!args) SWIG_fail;
13262 swig_obj[0] = args;
13263 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13264 if (!SWIG_IsOK(res1)) {
13265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsRedirected" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13266 }
13267 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13268 {
13269 PyThreadState* __tstate = wxPyBeginAllowThreads();
13270 result = (bool)(arg1)->IsRedirected();
13271 wxPyEndAllowThreads(__tstate);
13272 if (PyErr_Occurred()) SWIG_fail;
13273 }
13274 {
13275 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13276 }
13277 return resultobj;
13278 fail:
13279 return NULL;
13280 }
13281
13282
13283 SWIGINTERN PyObject *_wrap_Process_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13284 PyObject *resultobj = 0;
13285 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13286 void *argp1 = 0 ;
13287 int res1 = 0 ;
13288 PyObject *swig_obj[1] ;
13289
13290 if (!args) SWIG_fail;
13291 swig_obj[0] = args;
13292 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13293 if (!SWIG_IsOK(res1)) {
13294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Detach" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13295 }
13296 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13297 {
13298 PyThreadState* __tstate = wxPyBeginAllowThreads();
13299 (arg1)->Detach();
13300 wxPyEndAllowThreads(__tstate);
13301 if (PyErr_Occurred()) SWIG_fail;
13302 }
13303 resultobj = SWIG_Py_Void();
13304 return resultobj;
13305 fail:
13306 return NULL;
13307 }
13308
13309
13310 SWIGINTERN PyObject *_wrap_Process_GetInputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13311 PyObject *resultobj = 0;
13312 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13313 wxInputStream *result = 0 ;
13314 void *argp1 = 0 ;
13315 int res1 = 0 ;
13316 PyObject *swig_obj[1] ;
13317
13318 if (!args) SWIG_fail;
13319 swig_obj[0] = args;
13320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13321 if (!SWIG_IsOK(res1)) {
13322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetInputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13323 }
13324 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13325 {
13326 PyThreadState* __tstate = wxPyBeginAllowThreads();
13327 result = (wxInputStream *)(arg1)->GetInputStream();
13328 wxPyEndAllowThreads(__tstate);
13329 if (PyErr_Occurred()) SWIG_fail;
13330 }
13331 {
13332 wxPyInputStream * _ptr = NULL;
13333
13334 if (result) {
13335 _ptr = new wxPyInputStream(result);
13336 }
13337 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
13338 }
13339 return resultobj;
13340 fail:
13341 return NULL;
13342 }
13343
13344
13345 SWIGINTERN PyObject *_wrap_Process_GetErrorStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13346 PyObject *resultobj = 0;
13347 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13348 wxInputStream *result = 0 ;
13349 void *argp1 = 0 ;
13350 int res1 = 0 ;
13351 PyObject *swig_obj[1] ;
13352
13353 if (!args) SWIG_fail;
13354 swig_obj[0] = args;
13355 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13356 if (!SWIG_IsOK(res1)) {
13357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetErrorStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13358 }
13359 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13360 {
13361 PyThreadState* __tstate = wxPyBeginAllowThreads();
13362 result = (wxInputStream *)(arg1)->GetErrorStream();
13363 wxPyEndAllowThreads(__tstate);
13364 if (PyErr_Occurred()) SWIG_fail;
13365 }
13366 {
13367 wxPyInputStream * _ptr = NULL;
13368
13369 if (result) {
13370 _ptr = new wxPyInputStream(result);
13371 }
13372 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
13373 }
13374 return resultobj;
13375 fail:
13376 return NULL;
13377 }
13378
13379
13380 SWIGINTERN PyObject *_wrap_Process_GetOutputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13381 PyObject *resultobj = 0;
13382 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13383 wxOutputStream *result = 0 ;
13384 void *argp1 = 0 ;
13385 int res1 = 0 ;
13386 PyObject *swig_obj[1] ;
13387
13388 if (!args) SWIG_fail;
13389 swig_obj[0] = args;
13390 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13391 if (!SWIG_IsOK(res1)) {
13392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetOutputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13393 }
13394 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13395 {
13396 PyThreadState* __tstate = wxPyBeginAllowThreads();
13397 result = (wxOutputStream *)(arg1)->GetOutputStream();
13398 wxPyEndAllowThreads(__tstate);
13399 if (PyErr_Occurred()) SWIG_fail;
13400 }
13401 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxOutputStream, 0 | 0 );
13402 return resultobj;
13403 fail:
13404 return NULL;
13405 }
13406
13407
13408 SWIGINTERN PyObject *_wrap_Process_CloseOutput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13409 PyObject *resultobj = 0;
13410 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13411 void *argp1 = 0 ;
13412 int res1 = 0 ;
13413 PyObject *swig_obj[1] ;
13414
13415 if (!args) SWIG_fail;
13416 swig_obj[0] = args;
13417 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13418 if (!SWIG_IsOK(res1)) {
13419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_CloseOutput" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13420 }
13421 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13422 {
13423 PyThreadState* __tstate = wxPyBeginAllowThreads();
13424 (arg1)->CloseOutput();
13425 wxPyEndAllowThreads(__tstate);
13426 if (PyErr_Occurred()) SWIG_fail;
13427 }
13428 resultobj = SWIG_Py_Void();
13429 return resultobj;
13430 fail:
13431 return NULL;
13432 }
13433
13434
13435 SWIGINTERN PyObject *_wrap_Process_IsInputOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13436 PyObject *resultobj = 0;
13437 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13438 bool result;
13439 void *argp1 = 0 ;
13440 int res1 = 0 ;
13441 PyObject *swig_obj[1] ;
13442
13443 if (!args) SWIG_fail;
13444 swig_obj[0] = args;
13445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13446 if (!SWIG_IsOK(res1)) {
13447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputOpened" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
13448 }
13449 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13450 {
13451 PyThreadState* __tstate = wxPyBeginAllowThreads();
13452 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
13453 wxPyEndAllowThreads(__tstate);
13454 if (PyErr_Occurred()) SWIG_fail;
13455 }
13456 {
13457 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13458 }
13459 return resultobj;
13460 fail:
13461 return NULL;
13462 }
13463
13464
13465 SWIGINTERN PyObject *_wrap_Process_IsInputAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13466 PyObject *resultobj = 0;
13467 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13468 bool result;
13469 void *argp1 = 0 ;
13470 int res1 = 0 ;
13471 PyObject *swig_obj[1] ;
13472
13473 if (!args) SWIG_fail;
13474 swig_obj[0] = args;
13475 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13476 if (!SWIG_IsOK(res1)) {
13477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
13478 }
13479 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13480 {
13481 PyThreadState* __tstate = wxPyBeginAllowThreads();
13482 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
13483 wxPyEndAllowThreads(__tstate);
13484 if (PyErr_Occurred()) SWIG_fail;
13485 }
13486 {
13487 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13488 }
13489 return resultobj;
13490 fail:
13491 return NULL;
13492 }
13493
13494
13495 SWIGINTERN PyObject *_wrap_Process_IsErrorAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13496 PyObject *resultobj = 0;
13497 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13498 bool result;
13499 void *argp1 = 0 ;
13500 int res1 = 0 ;
13501 PyObject *swig_obj[1] ;
13502
13503 if (!args) SWIG_fail;
13504 swig_obj[0] = args;
13505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13506 if (!SWIG_IsOK(res1)) {
13507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsErrorAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
13508 }
13509 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13510 {
13511 PyThreadState* __tstate = wxPyBeginAllowThreads();
13512 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
13513 wxPyEndAllowThreads(__tstate);
13514 if (PyErr_Occurred()) SWIG_fail;
13515 }
13516 {
13517 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13518 }
13519 return resultobj;
13520 fail:
13521 return NULL;
13522 }
13523
13524
13525 SWIGINTERN PyObject *Process_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13526 PyObject *obj;
13527 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13528 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyProcess, SWIG_NewClientData(obj));
13529 return SWIG_Py_Void();
13530 }
13531
13532 SWIGINTERN PyObject *Process_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13533 return SWIG_Python_InitShadowInstance(args);
13534 }
13535
13536 SWIGINTERN PyObject *_wrap_new_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13537 PyObject *resultobj = 0;
13538 int arg1 = (int) 0 ;
13539 int arg2 = (int) 0 ;
13540 int arg3 = (int) 0 ;
13541 wxProcessEvent *result = 0 ;
13542 int val1 ;
13543 int ecode1 = 0 ;
13544 int val2 ;
13545 int ecode2 = 0 ;
13546 int val3 ;
13547 int ecode3 = 0 ;
13548 PyObject * obj0 = 0 ;
13549 PyObject * obj1 = 0 ;
13550 PyObject * obj2 = 0 ;
13551 char * kwnames[] = {
13552 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
13553 };
13554
13555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13556 if (obj0) {
13557 ecode1 = SWIG_AsVal_int(obj0, &val1);
13558 if (!SWIG_IsOK(ecode1)) {
13559 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ProcessEvent" "', expected argument " "1"" of type '" "int""'");
13560 }
13561 arg1 = static_cast< int >(val1);
13562 }
13563 if (obj1) {
13564 ecode2 = SWIG_AsVal_int(obj1, &val2);
13565 if (!SWIG_IsOK(ecode2)) {
13566 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ProcessEvent" "', expected argument " "2"" of type '" "int""'");
13567 }
13568 arg2 = static_cast< int >(val2);
13569 }
13570 if (obj2) {
13571 ecode3 = SWIG_AsVal_int(obj2, &val3);
13572 if (!SWIG_IsOK(ecode3)) {
13573 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ProcessEvent" "', expected argument " "3"" of type '" "int""'");
13574 }
13575 arg3 = static_cast< int >(val3);
13576 }
13577 {
13578 PyThreadState* __tstate = wxPyBeginAllowThreads();
13579 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
13580 wxPyEndAllowThreads(__tstate);
13581 if (PyErr_Occurred()) SWIG_fail;
13582 }
13583 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_NEW | 0 );
13584 return resultobj;
13585 fail:
13586 return NULL;
13587 }
13588
13589
13590 SWIGINTERN PyObject *_wrap_ProcessEvent_GetPid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13591 PyObject *resultobj = 0;
13592 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13593 int result;
13594 void *argp1 = 0 ;
13595 int res1 = 0 ;
13596 PyObject *swig_obj[1] ;
13597
13598 if (!args) SWIG_fail;
13599 swig_obj[0] = args;
13600 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13601 if (!SWIG_IsOK(res1)) {
13602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetPid" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13603 }
13604 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13605 {
13606 PyThreadState* __tstate = wxPyBeginAllowThreads();
13607 result = (int)(arg1)->GetPid();
13608 wxPyEndAllowThreads(__tstate);
13609 if (PyErr_Occurred()) SWIG_fail;
13610 }
13611 resultobj = SWIG_From_int(static_cast< int >(result));
13612 return resultobj;
13613 fail:
13614 return NULL;
13615 }
13616
13617
13618 SWIGINTERN PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13619 PyObject *resultobj = 0;
13620 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13621 int result;
13622 void *argp1 = 0 ;
13623 int res1 = 0 ;
13624 PyObject *swig_obj[1] ;
13625
13626 if (!args) SWIG_fail;
13627 swig_obj[0] = args;
13628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13629 if (!SWIG_IsOK(res1)) {
13630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetExitCode" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13631 }
13632 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13633 {
13634 PyThreadState* __tstate = wxPyBeginAllowThreads();
13635 result = (int)(arg1)->GetExitCode();
13636 wxPyEndAllowThreads(__tstate);
13637 if (PyErr_Occurred()) SWIG_fail;
13638 }
13639 resultobj = SWIG_From_int(static_cast< int >(result));
13640 return resultobj;
13641 fail:
13642 return NULL;
13643 }
13644
13645
13646 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13647 PyObject *resultobj = 0;
13648 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13649 int arg2 ;
13650 void *argp1 = 0 ;
13651 int res1 = 0 ;
13652 int val2 ;
13653 int ecode2 = 0 ;
13654 PyObject *swig_obj[2] ;
13655
13656 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_pid_set",2,2,swig_obj)) SWIG_fail;
13657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13658 if (!SWIG_IsOK(res1)) {
13659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13660 }
13661 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13662 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
13663 if (!SWIG_IsOK(ecode2)) {
13664 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "2"" of type '" "int""'");
13665 }
13666 arg2 = static_cast< int >(val2);
13667 if (arg1) (arg1)->m_pid = arg2;
13668
13669 resultobj = SWIG_Py_Void();
13670 return resultobj;
13671 fail:
13672 return NULL;
13673 }
13674
13675
13676 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13677 PyObject *resultobj = 0;
13678 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13679 int result;
13680 void *argp1 = 0 ;
13681 int res1 = 0 ;
13682 PyObject *swig_obj[1] ;
13683
13684 if (!args) SWIG_fail;
13685 swig_obj[0] = args;
13686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13687 if (!SWIG_IsOK(res1)) {
13688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13689 }
13690 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13691 result = (int) ((arg1)->m_pid);
13692 resultobj = SWIG_From_int(static_cast< int >(result));
13693 return resultobj;
13694 fail:
13695 return NULL;
13696 }
13697
13698
13699 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13700 PyObject *resultobj = 0;
13701 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13702 int arg2 ;
13703 void *argp1 = 0 ;
13704 int res1 = 0 ;
13705 int val2 ;
13706 int ecode2 = 0 ;
13707 PyObject *swig_obj[2] ;
13708
13709 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_exitcode_set",2,2,swig_obj)) SWIG_fail;
13710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13711 if (!SWIG_IsOK(res1)) {
13712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13713 }
13714 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13715 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
13716 if (!SWIG_IsOK(ecode2)) {
13717 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "2"" of type '" "int""'");
13718 }
13719 arg2 = static_cast< int >(val2);
13720 if (arg1) (arg1)->m_exitcode = arg2;
13721
13722 resultobj = SWIG_Py_Void();
13723 return resultobj;
13724 fail:
13725 return NULL;
13726 }
13727
13728
13729 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13730 PyObject *resultobj = 0;
13731 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13732 int result;
13733 void *argp1 = 0 ;
13734 int res1 = 0 ;
13735 PyObject *swig_obj[1] ;
13736
13737 if (!args) SWIG_fail;
13738 swig_obj[0] = args;
13739 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13740 if (!SWIG_IsOK(res1)) {
13741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13742 }
13743 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13744 result = (int) ((arg1)->m_exitcode);
13745 resultobj = SWIG_From_int(static_cast< int >(result));
13746 return resultobj;
13747 fail:
13748 return NULL;
13749 }
13750
13751
13752 SWIGINTERN PyObject *ProcessEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13753 PyObject *obj;
13754 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13755 SWIG_TypeNewClientData(SWIGTYPE_p_wxProcessEvent, SWIG_NewClientData(obj));
13756 return SWIG_Py_Void();
13757 }
13758
13759 SWIGINTERN PyObject *ProcessEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13760 return SWIG_Python_InitShadowInstance(args);
13761 }
13762
13763 SWIGINTERN PyObject *_wrap_Execute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13764 PyObject *resultobj = 0;
13765 wxString *arg1 = 0 ;
13766 int arg2 = (int) wxEXEC_ASYNC ;
13767 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
13768 long result;
13769 bool temp1 = false ;
13770 int val2 ;
13771 int ecode2 = 0 ;
13772 void *argp3 = 0 ;
13773 int res3 = 0 ;
13774 PyObject * obj0 = 0 ;
13775 PyObject * obj1 = 0 ;
13776 PyObject * obj2 = 0 ;
13777 char * kwnames[] = {
13778 (char *) "command",(char *) "flags",(char *) "process", NULL
13779 };
13780
13781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13782 {
13783 arg1 = wxString_in_helper(obj0);
13784 if (arg1 == NULL) SWIG_fail;
13785 temp1 = true;
13786 }
13787 if (obj1) {
13788 ecode2 = SWIG_AsVal_int(obj1, &val2);
13789 if (!SWIG_IsOK(ecode2)) {
13790 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Execute" "', expected argument " "2"" of type '" "int""'");
13791 }
13792 arg2 = static_cast< int >(val2);
13793 }
13794 if (obj2) {
13795 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13796 if (!SWIG_IsOK(res3)) {
13797 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Execute" "', expected argument " "3"" of type '" "wxPyProcess *""'");
13798 }
13799 arg3 = reinterpret_cast< wxPyProcess * >(argp3);
13800 }
13801 {
13802 if (!wxPyCheckForApp()) SWIG_fail;
13803 PyThreadState* __tstate = wxPyBeginAllowThreads();
13804 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
13805 wxPyEndAllowThreads(__tstate);
13806 if (PyErr_Occurred()) SWIG_fail;
13807 }
13808 resultobj = SWIG_From_long(static_cast< long >(result));
13809 {
13810 if (temp1)
13811 delete arg1;
13812 }
13813 return resultobj;
13814 fail:
13815 {
13816 if (temp1)
13817 delete arg1;
13818 }
13819 return NULL;
13820 }
13821
13822
13823 SWIGINTERN PyObject *_wrap_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13824 PyObject *resultobj = 0;
13825 long arg1 ;
13826 wxSignal arg2 = (wxSignal) wxSIGTERM ;
13827 wxKillError *arg3 = (wxKillError *) 0 ;
13828 int arg4 = (int) wxKILL_NOCHILDREN ;
13829 int result;
13830 long val1 ;
13831 int ecode1 = 0 ;
13832 int val2 ;
13833 int ecode2 = 0 ;
13834 wxKillError temp3 ;
13835 int val4 ;
13836 int ecode4 = 0 ;
13837 PyObject * obj0 = 0 ;
13838 PyObject * obj1 = 0 ;
13839 PyObject * obj2 = 0 ;
13840 char * kwnames[] = {
13841 (char *) "pid",(char *) "sig",(char *) "flags", NULL
13842 };
13843
13844 {
13845 arg3 = &temp3;
13846 }
13847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13848 ecode1 = SWIG_AsVal_long(obj0, &val1);
13849 if (!SWIG_IsOK(ecode1)) {
13850 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Kill" "', expected argument " "1"" of type '" "long""'");
13851 }
13852 arg1 = static_cast< long >(val1);
13853 if (obj1) {
13854 ecode2 = SWIG_AsVal_int(obj1, &val2);
13855 if (!SWIG_IsOK(ecode2)) {
13856 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Kill" "', expected argument " "2"" of type '" "wxSignal""'");
13857 }
13858 arg2 = static_cast< wxSignal >(val2);
13859 }
13860 if (obj2) {
13861 ecode4 = SWIG_AsVal_int(obj2, &val4);
13862 if (!SWIG_IsOK(ecode4)) {
13863 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Kill" "', expected argument " "4"" of type '" "int""'");
13864 }
13865 arg4 = static_cast< int >(val4);
13866 }
13867 {
13868 PyThreadState* __tstate = wxPyBeginAllowThreads();
13869 result = (int)wxKill(arg1,arg2,arg3,arg4);
13870 wxPyEndAllowThreads(__tstate);
13871 if (PyErr_Occurred()) SWIG_fail;
13872 }
13873 resultobj = SWIG_From_int(static_cast< int >(result));
13874 {
13875 PyObject* o;
13876 o = PyInt_FromLong((long) (*arg3));
13877
13878
13879
13880 resultobj = SWIG_Python_AppendOutput(resultobj, o);
13881
13882 }
13883 return resultobj;
13884 fail:
13885 return NULL;
13886 }
13887
13888
13889 SWIGINTERN PyObject *_wrap_new_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13890 PyObject *resultobj = 0;
13891 int arg1 = (int) wxJOYSTICK1 ;
13892 wxJoystick *result = 0 ;
13893 int val1 ;
13894 int ecode1 = 0 ;
13895 PyObject * obj0 = 0 ;
13896 char * kwnames[] = {
13897 (char *) "joystick", NULL
13898 };
13899
13900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) SWIG_fail;
13901 if (obj0) {
13902 ecode1 = SWIG_AsVal_int(obj0, &val1);
13903 if (!SWIG_IsOK(ecode1)) {
13904 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Joystick" "', expected argument " "1"" of type '" "int""'");
13905 }
13906 arg1 = static_cast< int >(val1);
13907 }
13908 {
13909 if (!wxPyCheckForApp()) SWIG_fail;
13910 PyThreadState* __tstate = wxPyBeginAllowThreads();
13911 result = (wxJoystick *)new wxJoystick(arg1);
13912 wxPyEndAllowThreads(__tstate);
13913 if (PyErr_Occurred()) SWIG_fail;
13914 }
13915 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystick, SWIG_POINTER_NEW | 0 );
13916 return resultobj;
13917 fail:
13918 return NULL;
13919 }
13920
13921
13922 SWIGINTERN PyObject *_wrap_delete_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13923 PyObject *resultobj = 0;
13924 wxJoystick *arg1 = (wxJoystick *) 0 ;
13925 void *argp1 = 0 ;
13926 int res1 = 0 ;
13927 PyObject *swig_obj[1] ;
13928
13929 if (!args) SWIG_fail;
13930 swig_obj[0] = args;
13931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, SWIG_POINTER_DISOWN | 0 );
13932 if (!SWIG_IsOK(res1)) {
13933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Joystick" "', expected argument " "1"" of type '" "wxJoystick *""'");
13934 }
13935 arg1 = reinterpret_cast< wxJoystick * >(argp1);
13936 {
13937 PyThreadState* __tstate = wxPyBeginAllowThreads();
13938 delete arg1;
13939
13940 wxPyEndAllowThreads(__tstate);
13941 if (PyErr_Occurred()) SWIG_fail;
13942 }
13943 resultobj = SWIG_Py_Void();
13944 return resultobj;
13945 fail:
13946 return NULL;
13947 }
13948
13949
13950 SWIGINTERN PyObject *_wrap_Joystick_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13951 PyObject *resultobj = 0;
13952 wxJoystick *arg1 = (wxJoystick *) 0 ;
13953 wxPoint result;
13954 void *argp1 = 0 ;
13955 int res1 = 0 ;
13956 PyObject *swig_obj[1] ;
13957
13958 if (!args) SWIG_fail;
13959 swig_obj[0] = args;
13960 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
13961 if (!SWIG_IsOK(res1)) {
13962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
13963 }
13964 arg1 = reinterpret_cast< wxJoystick * >(argp1);
13965 {
13966 PyThreadState* __tstate = wxPyBeginAllowThreads();
13967 result = (arg1)->GetPosition();
13968 wxPyEndAllowThreads(__tstate);
13969 if (PyErr_Occurred()) SWIG_fail;
13970 }
13971 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
13972 return resultobj;
13973 fail:
13974 return NULL;
13975 }
13976
13977
13978 SWIGINTERN PyObject *_wrap_Joystick_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13979 PyObject *resultobj = 0;
13980 wxJoystick *arg1 = (wxJoystick *) 0 ;
13981 int result;
13982 void *argp1 = 0 ;
13983 int res1 = 0 ;
13984 PyObject *swig_obj[1] ;
13985
13986 if (!args) SWIG_fail;
13987 swig_obj[0] = args;
13988 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
13989 if (!SWIG_IsOK(res1)) {
13990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
13991 }
13992 arg1 = reinterpret_cast< wxJoystick * >(argp1);
13993 {
13994 PyThreadState* __tstate = wxPyBeginAllowThreads();
13995 result = (int)(arg1)->GetZPosition();
13996 wxPyEndAllowThreads(__tstate);
13997 if (PyErr_Occurred()) SWIG_fail;
13998 }
13999 resultobj = SWIG_From_int(static_cast< int >(result));
14000 return resultobj;
14001 fail:
14002 return NULL;
14003 }
14004
14005
14006 SWIGINTERN PyObject *_wrap_Joystick_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14007 PyObject *resultobj = 0;
14008 wxJoystick *arg1 = (wxJoystick *) 0 ;
14009 int result;
14010 void *argp1 = 0 ;
14011 int res1 = 0 ;
14012 PyObject *swig_obj[1] ;
14013
14014 if (!args) SWIG_fail;
14015 swig_obj[0] = args;
14016 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14017 if (!SWIG_IsOK(res1)) {
14018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetButtonState" "', expected argument " "1"" of type '" "wxJoystick *""'");
14019 }
14020 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14021 {
14022 PyThreadState* __tstate = wxPyBeginAllowThreads();
14023 result = (int)(arg1)->GetButtonState();
14024 wxPyEndAllowThreads(__tstate);
14025 if (PyErr_Occurred()) SWIG_fail;
14026 }
14027 resultobj = SWIG_From_int(static_cast< int >(result));
14028 return resultobj;
14029 fail:
14030 return NULL;
14031 }
14032
14033
14034 SWIGINTERN PyObject *_wrap_Joystick_GetPOVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14035 PyObject *resultobj = 0;
14036 wxJoystick *arg1 = (wxJoystick *) 0 ;
14037 int result;
14038 void *argp1 = 0 ;
14039 int res1 = 0 ;
14040 PyObject *swig_obj[1] ;
14041
14042 if (!args) SWIG_fail;
14043 swig_obj[0] = args;
14044 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14045 if (!SWIG_IsOK(res1)) {
14046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14047 }
14048 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14049 {
14050 PyThreadState* __tstate = wxPyBeginAllowThreads();
14051 result = (int)(arg1)->GetPOVPosition();
14052 wxPyEndAllowThreads(__tstate);
14053 if (PyErr_Occurred()) SWIG_fail;
14054 }
14055 resultobj = SWIG_From_int(static_cast< int >(result));
14056 return resultobj;
14057 fail:
14058 return NULL;
14059 }
14060
14061
14062 SWIGINTERN PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14063 PyObject *resultobj = 0;
14064 wxJoystick *arg1 = (wxJoystick *) 0 ;
14065 int result;
14066 void *argp1 = 0 ;
14067 int res1 = 0 ;
14068 PyObject *swig_obj[1] ;
14069
14070 if (!args) SWIG_fail;
14071 swig_obj[0] = args;
14072 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14073 if (!SWIG_IsOK(res1)) {
14074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVCTSPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14075 }
14076 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14077 {
14078 PyThreadState* __tstate = wxPyBeginAllowThreads();
14079 result = (int)(arg1)->GetPOVCTSPosition();
14080 wxPyEndAllowThreads(__tstate);
14081 if (PyErr_Occurred()) SWIG_fail;
14082 }
14083 resultobj = SWIG_From_int(static_cast< int >(result));
14084 return resultobj;
14085 fail:
14086 return NULL;
14087 }
14088
14089
14090 SWIGINTERN PyObject *_wrap_Joystick_GetRudderPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14091 PyObject *resultobj = 0;
14092 wxJoystick *arg1 = (wxJoystick *) 0 ;
14093 int result;
14094 void *argp1 = 0 ;
14095 int res1 = 0 ;
14096 PyObject *swig_obj[1] ;
14097
14098 if (!args) SWIG_fail;
14099 swig_obj[0] = args;
14100 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14101 if (!SWIG_IsOK(res1)) {
14102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14103 }
14104 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14105 {
14106 PyThreadState* __tstate = wxPyBeginAllowThreads();
14107 result = (int)(arg1)->GetRudderPosition();
14108 wxPyEndAllowThreads(__tstate);
14109 if (PyErr_Occurred()) SWIG_fail;
14110 }
14111 resultobj = SWIG_From_int(static_cast< int >(result));
14112 return resultobj;
14113 fail:
14114 return NULL;
14115 }
14116
14117
14118 SWIGINTERN PyObject *_wrap_Joystick_GetUPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14119 PyObject *resultobj = 0;
14120 wxJoystick *arg1 = (wxJoystick *) 0 ;
14121 int result;
14122 void *argp1 = 0 ;
14123 int res1 = 0 ;
14124 PyObject *swig_obj[1] ;
14125
14126 if (!args) SWIG_fail;
14127 swig_obj[0] = args;
14128 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14129 if (!SWIG_IsOK(res1)) {
14130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14131 }
14132 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14133 {
14134 PyThreadState* __tstate = wxPyBeginAllowThreads();
14135 result = (int)(arg1)->GetUPosition();
14136 wxPyEndAllowThreads(__tstate);
14137 if (PyErr_Occurred()) SWIG_fail;
14138 }
14139 resultobj = SWIG_From_int(static_cast< int >(result));
14140 return resultobj;
14141 fail:
14142 return NULL;
14143 }
14144
14145
14146 SWIGINTERN PyObject *_wrap_Joystick_GetVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14147 PyObject *resultobj = 0;
14148 wxJoystick *arg1 = (wxJoystick *) 0 ;
14149 int result;
14150 void *argp1 = 0 ;
14151 int res1 = 0 ;
14152 PyObject *swig_obj[1] ;
14153
14154 if (!args) SWIG_fail;
14155 swig_obj[0] = args;
14156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14157 if (!SWIG_IsOK(res1)) {
14158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14159 }
14160 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14161 {
14162 PyThreadState* __tstate = wxPyBeginAllowThreads();
14163 result = (int)(arg1)->GetVPosition();
14164 wxPyEndAllowThreads(__tstate);
14165 if (PyErr_Occurred()) SWIG_fail;
14166 }
14167 resultobj = SWIG_From_int(static_cast< int >(result));
14168 return resultobj;
14169 fail:
14170 return NULL;
14171 }
14172
14173
14174 SWIGINTERN PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14175 PyObject *resultobj = 0;
14176 wxJoystick *arg1 = (wxJoystick *) 0 ;
14177 int result;
14178 void *argp1 = 0 ;
14179 int res1 = 0 ;
14180 PyObject *swig_obj[1] ;
14181
14182 if (!args) SWIG_fail;
14183 swig_obj[0] = args;
14184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14185 if (!SWIG_IsOK(res1)) {
14186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
14187 }
14188 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14189 {
14190 PyThreadState* __tstate = wxPyBeginAllowThreads();
14191 result = (int)(arg1)->GetMovementThreshold();
14192 wxPyEndAllowThreads(__tstate);
14193 if (PyErr_Occurred()) SWIG_fail;
14194 }
14195 resultobj = SWIG_From_int(static_cast< int >(result));
14196 return resultobj;
14197 fail:
14198 return NULL;
14199 }
14200
14201
14202 SWIGINTERN PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14203 PyObject *resultobj = 0;
14204 wxJoystick *arg1 = (wxJoystick *) 0 ;
14205 int arg2 ;
14206 void *argp1 = 0 ;
14207 int res1 = 0 ;
14208 int val2 ;
14209 int ecode2 = 0 ;
14210 PyObject * obj0 = 0 ;
14211 PyObject * obj1 = 0 ;
14212 char * kwnames[] = {
14213 (char *) "self",(char *) "threshold", NULL
14214 };
14215
14216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) SWIG_fail;
14217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14218 if (!SWIG_IsOK(res1)) {
14219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
14220 }
14221 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14222 ecode2 = SWIG_AsVal_int(obj1, &val2);
14223 if (!SWIG_IsOK(ecode2)) {
14224 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "2"" of type '" "int""'");
14225 }
14226 arg2 = static_cast< int >(val2);
14227 {
14228 PyThreadState* __tstate = wxPyBeginAllowThreads();
14229 (arg1)->SetMovementThreshold(arg2);
14230 wxPyEndAllowThreads(__tstate);
14231 if (PyErr_Occurred()) SWIG_fail;
14232 }
14233 resultobj = SWIG_Py_Void();
14234 return resultobj;
14235 fail:
14236 return NULL;
14237 }
14238
14239
14240 SWIGINTERN PyObject *_wrap_Joystick_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14241 PyObject *resultobj = 0;
14242 wxJoystick *arg1 = (wxJoystick *) 0 ;
14243 bool result;
14244 void *argp1 = 0 ;
14245 int res1 = 0 ;
14246 PyObject *swig_obj[1] ;
14247
14248 if (!args) SWIG_fail;
14249 swig_obj[0] = args;
14250 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14251 if (!SWIG_IsOK(res1)) {
14252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_IsOk" "', expected argument " "1"" of type '" "wxJoystick *""'");
14253 }
14254 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14255 {
14256 PyThreadState* __tstate = wxPyBeginAllowThreads();
14257 result = (bool)(arg1)->IsOk();
14258 wxPyEndAllowThreads(__tstate);
14259 if (PyErr_Occurred()) SWIG_fail;
14260 }
14261 {
14262 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14263 }
14264 return resultobj;
14265 fail:
14266 return NULL;
14267 }
14268
14269
14270 SWIGINTERN PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14271 PyObject *resultobj = 0;
14272 wxJoystick *arg1 = (wxJoystick *) 0 ;
14273 int result;
14274 void *argp1 = 0 ;
14275 int res1 = 0 ;
14276 PyObject *swig_obj[1] ;
14277
14278 if (!args) SWIG_fail;
14279 swig_obj[0] = args;
14280 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14281 if (!SWIG_IsOK(res1)) {
14282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberJoysticks" "', expected argument " "1"" of type '" "wxJoystick *""'");
14283 }
14284 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14285 {
14286 PyThreadState* __tstate = wxPyBeginAllowThreads();
14287 result = (int)(arg1)->GetNumberJoysticks();
14288 wxPyEndAllowThreads(__tstate);
14289 if (PyErr_Occurred()) SWIG_fail;
14290 }
14291 resultobj = SWIG_From_int(static_cast< int >(result));
14292 return resultobj;
14293 fail:
14294 return NULL;
14295 }
14296
14297
14298 SWIGINTERN PyObject *_wrap_Joystick_GetManufacturerId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14299 PyObject *resultobj = 0;
14300 wxJoystick *arg1 = (wxJoystick *) 0 ;
14301 int result;
14302 void *argp1 = 0 ;
14303 int res1 = 0 ;
14304 PyObject *swig_obj[1] ;
14305
14306 if (!args) SWIG_fail;
14307 swig_obj[0] = args;
14308 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14309 if (!SWIG_IsOK(res1)) {
14310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetManufacturerId" "', expected argument " "1"" of type '" "wxJoystick *""'");
14311 }
14312 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14313 {
14314 PyThreadState* __tstate = wxPyBeginAllowThreads();
14315 result = (int)(arg1)->GetManufacturerId();
14316 wxPyEndAllowThreads(__tstate);
14317 if (PyErr_Occurred()) SWIG_fail;
14318 }
14319 resultobj = SWIG_From_int(static_cast< int >(result));
14320 return resultobj;
14321 fail:
14322 return NULL;
14323 }
14324
14325
14326 SWIGINTERN PyObject *_wrap_Joystick_GetProductId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14327 PyObject *resultobj = 0;
14328 wxJoystick *arg1 = (wxJoystick *) 0 ;
14329 int result;
14330 void *argp1 = 0 ;
14331 int res1 = 0 ;
14332 PyObject *swig_obj[1] ;
14333
14334 if (!args) SWIG_fail;
14335 swig_obj[0] = args;
14336 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14337 if (!SWIG_IsOK(res1)) {
14338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductId" "', expected argument " "1"" of type '" "wxJoystick *""'");
14339 }
14340 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14341 {
14342 PyThreadState* __tstate = wxPyBeginAllowThreads();
14343 result = (int)(arg1)->GetProductId();
14344 wxPyEndAllowThreads(__tstate);
14345 if (PyErr_Occurred()) SWIG_fail;
14346 }
14347 resultobj = SWIG_From_int(static_cast< int >(result));
14348 return resultobj;
14349 fail:
14350 return NULL;
14351 }
14352
14353
14354 SWIGINTERN PyObject *_wrap_Joystick_GetProductName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14355 PyObject *resultobj = 0;
14356 wxJoystick *arg1 = (wxJoystick *) 0 ;
14357 wxString result;
14358 void *argp1 = 0 ;
14359 int res1 = 0 ;
14360 PyObject *swig_obj[1] ;
14361
14362 if (!args) SWIG_fail;
14363 swig_obj[0] = args;
14364 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14365 if (!SWIG_IsOK(res1)) {
14366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductName" "', expected argument " "1"" of type '" "wxJoystick *""'");
14367 }
14368 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14369 {
14370 PyThreadState* __tstate = wxPyBeginAllowThreads();
14371 result = (arg1)->GetProductName();
14372 wxPyEndAllowThreads(__tstate);
14373 if (PyErr_Occurred()) SWIG_fail;
14374 }
14375 {
14376 #if wxUSE_UNICODE
14377 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14378 #else
14379 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14380 #endif
14381 }
14382 return resultobj;
14383 fail:
14384 return NULL;
14385 }
14386
14387
14388 SWIGINTERN PyObject *_wrap_Joystick_GetXMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14389 PyObject *resultobj = 0;
14390 wxJoystick *arg1 = (wxJoystick *) 0 ;
14391 int result;
14392 void *argp1 = 0 ;
14393 int res1 = 0 ;
14394 PyObject *swig_obj[1] ;
14395
14396 if (!args) SWIG_fail;
14397 swig_obj[0] = args;
14398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14399 if (!SWIG_IsOK(res1)) {
14400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14401 }
14402 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14403 {
14404 PyThreadState* __tstate = wxPyBeginAllowThreads();
14405 result = (int)(arg1)->GetXMin();
14406 wxPyEndAllowThreads(__tstate);
14407 if (PyErr_Occurred()) SWIG_fail;
14408 }
14409 resultobj = SWIG_From_int(static_cast< int >(result));
14410 return resultobj;
14411 fail:
14412 return NULL;
14413 }
14414
14415
14416 SWIGINTERN PyObject *_wrap_Joystick_GetYMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14417 PyObject *resultobj = 0;
14418 wxJoystick *arg1 = (wxJoystick *) 0 ;
14419 int result;
14420 void *argp1 = 0 ;
14421 int res1 = 0 ;
14422 PyObject *swig_obj[1] ;
14423
14424 if (!args) SWIG_fail;
14425 swig_obj[0] = args;
14426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14427 if (!SWIG_IsOK(res1)) {
14428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14429 }
14430 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14431 {
14432 PyThreadState* __tstate = wxPyBeginAllowThreads();
14433 result = (int)(arg1)->GetYMin();
14434 wxPyEndAllowThreads(__tstate);
14435 if (PyErr_Occurred()) SWIG_fail;
14436 }
14437 resultobj = SWIG_From_int(static_cast< int >(result));
14438 return resultobj;
14439 fail:
14440 return NULL;
14441 }
14442
14443
14444 SWIGINTERN PyObject *_wrap_Joystick_GetZMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14445 PyObject *resultobj = 0;
14446 wxJoystick *arg1 = (wxJoystick *) 0 ;
14447 int result;
14448 void *argp1 = 0 ;
14449 int res1 = 0 ;
14450 PyObject *swig_obj[1] ;
14451
14452 if (!args) SWIG_fail;
14453 swig_obj[0] = args;
14454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14455 if (!SWIG_IsOK(res1)) {
14456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14457 }
14458 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14459 {
14460 PyThreadState* __tstate = wxPyBeginAllowThreads();
14461 result = (int)(arg1)->GetZMin();
14462 wxPyEndAllowThreads(__tstate);
14463 if (PyErr_Occurred()) SWIG_fail;
14464 }
14465 resultobj = SWIG_From_int(static_cast< int >(result));
14466 return resultobj;
14467 fail:
14468 return NULL;
14469 }
14470
14471
14472 SWIGINTERN PyObject *_wrap_Joystick_GetXMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14473 PyObject *resultobj = 0;
14474 wxJoystick *arg1 = (wxJoystick *) 0 ;
14475 int result;
14476 void *argp1 = 0 ;
14477 int res1 = 0 ;
14478 PyObject *swig_obj[1] ;
14479
14480 if (!args) SWIG_fail;
14481 swig_obj[0] = args;
14482 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14483 if (!SWIG_IsOK(res1)) {
14484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14485 }
14486 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14487 {
14488 PyThreadState* __tstate = wxPyBeginAllowThreads();
14489 result = (int)(arg1)->GetXMax();
14490 wxPyEndAllowThreads(__tstate);
14491 if (PyErr_Occurred()) SWIG_fail;
14492 }
14493 resultobj = SWIG_From_int(static_cast< int >(result));
14494 return resultobj;
14495 fail:
14496 return NULL;
14497 }
14498
14499
14500 SWIGINTERN PyObject *_wrap_Joystick_GetYMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14501 PyObject *resultobj = 0;
14502 wxJoystick *arg1 = (wxJoystick *) 0 ;
14503 int result;
14504 void *argp1 = 0 ;
14505 int res1 = 0 ;
14506 PyObject *swig_obj[1] ;
14507
14508 if (!args) SWIG_fail;
14509 swig_obj[0] = args;
14510 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14511 if (!SWIG_IsOK(res1)) {
14512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14513 }
14514 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14515 {
14516 PyThreadState* __tstate = wxPyBeginAllowThreads();
14517 result = (int)(arg1)->GetYMax();
14518 wxPyEndAllowThreads(__tstate);
14519 if (PyErr_Occurred()) SWIG_fail;
14520 }
14521 resultobj = SWIG_From_int(static_cast< int >(result));
14522 return resultobj;
14523 fail:
14524 return NULL;
14525 }
14526
14527
14528 SWIGINTERN PyObject *_wrap_Joystick_GetZMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14529 PyObject *resultobj = 0;
14530 wxJoystick *arg1 = (wxJoystick *) 0 ;
14531 int result;
14532 void *argp1 = 0 ;
14533 int res1 = 0 ;
14534 PyObject *swig_obj[1] ;
14535
14536 if (!args) SWIG_fail;
14537 swig_obj[0] = args;
14538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14539 if (!SWIG_IsOK(res1)) {
14540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14541 }
14542 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14543 {
14544 PyThreadState* __tstate = wxPyBeginAllowThreads();
14545 result = (int)(arg1)->GetZMax();
14546 wxPyEndAllowThreads(__tstate);
14547 if (PyErr_Occurred()) SWIG_fail;
14548 }
14549 resultobj = SWIG_From_int(static_cast< int >(result));
14550 return resultobj;
14551 fail:
14552 return NULL;
14553 }
14554
14555
14556 SWIGINTERN PyObject *_wrap_Joystick_GetNumberButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14557 PyObject *resultobj = 0;
14558 wxJoystick *arg1 = (wxJoystick *) 0 ;
14559 int result;
14560 void *argp1 = 0 ;
14561 int res1 = 0 ;
14562 PyObject *swig_obj[1] ;
14563
14564 if (!args) SWIG_fail;
14565 swig_obj[0] = args;
14566 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14567 if (!SWIG_IsOK(res1)) {
14568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
14569 }
14570 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14571 {
14572 PyThreadState* __tstate = wxPyBeginAllowThreads();
14573 result = (int)(arg1)->GetNumberButtons();
14574 wxPyEndAllowThreads(__tstate);
14575 if (PyErr_Occurred()) SWIG_fail;
14576 }
14577 resultobj = SWIG_From_int(static_cast< int >(result));
14578 return resultobj;
14579 fail:
14580 return NULL;
14581 }
14582
14583
14584 SWIGINTERN PyObject *_wrap_Joystick_GetNumberAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14585 PyObject *resultobj = 0;
14586 wxJoystick *arg1 = (wxJoystick *) 0 ;
14587 int result;
14588 void *argp1 = 0 ;
14589 int res1 = 0 ;
14590 PyObject *swig_obj[1] ;
14591
14592 if (!args) SWIG_fail;
14593 swig_obj[0] = args;
14594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14595 if (!SWIG_IsOK(res1)) {
14596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
14597 }
14598 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14599 {
14600 PyThreadState* __tstate = wxPyBeginAllowThreads();
14601 result = (int)(arg1)->GetNumberAxes();
14602 wxPyEndAllowThreads(__tstate);
14603 if (PyErr_Occurred()) SWIG_fail;
14604 }
14605 resultobj = SWIG_From_int(static_cast< int >(result));
14606 return resultobj;
14607 fail:
14608 return NULL;
14609 }
14610
14611
14612 SWIGINTERN PyObject *_wrap_Joystick_GetMaxButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14613 PyObject *resultobj = 0;
14614 wxJoystick *arg1 = (wxJoystick *) 0 ;
14615 int result;
14616 void *argp1 = 0 ;
14617 int res1 = 0 ;
14618 PyObject *swig_obj[1] ;
14619
14620 if (!args) SWIG_fail;
14621 swig_obj[0] = args;
14622 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14623 if (!SWIG_IsOK(res1)) {
14624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
14625 }
14626 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14627 {
14628 PyThreadState* __tstate = wxPyBeginAllowThreads();
14629 result = (int)(arg1)->GetMaxButtons();
14630 wxPyEndAllowThreads(__tstate);
14631 if (PyErr_Occurred()) SWIG_fail;
14632 }
14633 resultobj = SWIG_From_int(static_cast< int >(result));
14634 return resultobj;
14635 fail:
14636 return NULL;
14637 }
14638
14639
14640 SWIGINTERN PyObject *_wrap_Joystick_GetMaxAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14641 PyObject *resultobj = 0;
14642 wxJoystick *arg1 = (wxJoystick *) 0 ;
14643 int result;
14644 void *argp1 = 0 ;
14645 int res1 = 0 ;
14646 PyObject *swig_obj[1] ;
14647
14648 if (!args) SWIG_fail;
14649 swig_obj[0] = args;
14650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14651 if (!SWIG_IsOK(res1)) {
14652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
14653 }
14654 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14655 {
14656 PyThreadState* __tstate = wxPyBeginAllowThreads();
14657 result = (int)(arg1)->GetMaxAxes();
14658 wxPyEndAllowThreads(__tstate);
14659 if (PyErr_Occurred()) SWIG_fail;
14660 }
14661 resultobj = SWIG_From_int(static_cast< int >(result));
14662 return resultobj;
14663 fail:
14664 return NULL;
14665 }
14666
14667
14668 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14669 PyObject *resultobj = 0;
14670 wxJoystick *arg1 = (wxJoystick *) 0 ;
14671 int result;
14672 void *argp1 = 0 ;
14673 int res1 = 0 ;
14674 PyObject *swig_obj[1] ;
14675
14676 if (!args) SWIG_fail;
14677 swig_obj[0] = args;
14678 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14679 if (!SWIG_IsOK(res1)) {
14680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14681 }
14682 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14683 {
14684 PyThreadState* __tstate = wxPyBeginAllowThreads();
14685 result = (int)(arg1)->GetPollingMin();
14686 wxPyEndAllowThreads(__tstate);
14687 if (PyErr_Occurred()) SWIG_fail;
14688 }
14689 resultobj = SWIG_From_int(static_cast< int >(result));
14690 return resultobj;
14691 fail:
14692 return NULL;
14693 }
14694
14695
14696 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14697 PyObject *resultobj = 0;
14698 wxJoystick *arg1 = (wxJoystick *) 0 ;
14699 int result;
14700 void *argp1 = 0 ;
14701 int res1 = 0 ;
14702 PyObject *swig_obj[1] ;
14703
14704 if (!args) SWIG_fail;
14705 swig_obj[0] = args;
14706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14707 if (!SWIG_IsOK(res1)) {
14708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14709 }
14710 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14711 {
14712 PyThreadState* __tstate = wxPyBeginAllowThreads();
14713 result = (int)(arg1)->GetPollingMax();
14714 wxPyEndAllowThreads(__tstate);
14715 if (PyErr_Occurred()) SWIG_fail;
14716 }
14717 resultobj = SWIG_From_int(static_cast< int >(result));
14718 return resultobj;
14719 fail:
14720 return NULL;
14721 }
14722
14723
14724 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14725 PyObject *resultobj = 0;
14726 wxJoystick *arg1 = (wxJoystick *) 0 ;
14727 int result;
14728 void *argp1 = 0 ;
14729 int res1 = 0 ;
14730 PyObject *swig_obj[1] ;
14731
14732 if (!args) SWIG_fail;
14733 swig_obj[0] = args;
14734 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14735 if (!SWIG_IsOK(res1)) {
14736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14737 }
14738 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14739 {
14740 PyThreadState* __tstate = wxPyBeginAllowThreads();
14741 result = (int)(arg1)->GetRudderMin();
14742 wxPyEndAllowThreads(__tstate);
14743 if (PyErr_Occurred()) SWIG_fail;
14744 }
14745 resultobj = SWIG_From_int(static_cast< int >(result));
14746 return resultobj;
14747 fail:
14748 return NULL;
14749 }
14750
14751
14752 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14753 PyObject *resultobj = 0;
14754 wxJoystick *arg1 = (wxJoystick *) 0 ;
14755 int result;
14756 void *argp1 = 0 ;
14757 int res1 = 0 ;
14758 PyObject *swig_obj[1] ;
14759
14760 if (!args) SWIG_fail;
14761 swig_obj[0] = args;
14762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14763 if (!SWIG_IsOK(res1)) {
14764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14765 }
14766 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14767 {
14768 PyThreadState* __tstate = wxPyBeginAllowThreads();
14769 result = (int)(arg1)->GetRudderMax();
14770 wxPyEndAllowThreads(__tstate);
14771 if (PyErr_Occurred()) SWIG_fail;
14772 }
14773 resultobj = SWIG_From_int(static_cast< int >(result));
14774 return resultobj;
14775 fail:
14776 return NULL;
14777 }
14778
14779
14780 SWIGINTERN PyObject *_wrap_Joystick_GetUMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14781 PyObject *resultobj = 0;
14782 wxJoystick *arg1 = (wxJoystick *) 0 ;
14783 int result;
14784 void *argp1 = 0 ;
14785 int res1 = 0 ;
14786 PyObject *swig_obj[1] ;
14787
14788 if (!args) SWIG_fail;
14789 swig_obj[0] = args;
14790 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14791 if (!SWIG_IsOK(res1)) {
14792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14793 }
14794 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14795 {
14796 PyThreadState* __tstate = wxPyBeginAllowThreads();
14797 result = (int)(arg1)->GetUMin();
14798 wxPyEndAllowThreads(__tstate);
14799 if (PyErr_Occurred()) SWIG_fail;
14800 }
14801 resultobj = SWIG_From_int(static_cast< int >(result));
14802 return resultobj;
14803 fail:
14804 return NULL;
14805 }
14806
14807
14808 SWIGINTERN PyObject *_wrap_Joystick_GetUMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14809 PyObject *resultobj = 0;
14810 wxJoystick *arg1 = (wxJoystick *) 0 ;
14811 int result;
14812 void *argp1 = 0 ;
14813 int res1 = 0 ;
14814 PyObject *swig_obj[1] ;
14815
14816 if (!args) SWIG_fail;
14817 swig_obj[0] = args;
14818 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14819 if (!SWIG_IsOK(res1)) {
14820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14821 }
14822 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14823 {
14824 PyThreadState* __tstate = wxPyBeginAllowThreads();
14825 result = (int)(arg1)->GetUMax();
14826 wxPyEndAllowThreads(__tstate);
14827 if (PyErr_Occurred()) SWIG_fail;
14828 }
14829 resultobj = SWIG_From_int(static_cast< int >(result));
14830 return resultobj;
14831 fail:
14832 return NULL;
14833 }
14834
14835
14836 SWIGINTERN PyObject *_wrap_Joystick_GetVMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14837 PyObject *resultobj = 0;
14838 wxJoystick *arg1 = (wxJoystick *) 0 ;
14839 int result;
14840 void *argp1 = 0 ;
14841 int res1 = 0 ;
14842 PyObject *swig_obj[1] ;
14843
14844 if (!args) SWIG_fail;
14845 swig_obj[0] = args;
14846 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14847 if (!SWIG_IsOK(res1)) {
14848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14849 }
14850 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14851 {
14852 PyThreadState* __tstate = wxPyBeginAllowThreads();
14853 result = (int)(arg1)->GetVMin();
14854 wxPyEndAllowThreads(__tstate);
14855 if (PyErr_Occurred()) SWIG_fail;
14856 }
14857 resultobj = SWIG_From_int(static_cast< int >(result));
14858 return resultobj;
14859 fail:
14860 return NULL;
14861 }
14862
14863
14864 SWIGINTERN PyObject *_wrap_Joystick_GetVMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14865 PyObject *resultobj = 0;
14866 wxJoystick *arg1 = (wxJoystick *) 0 ;
14867 int result;
14868 void *argp1 = 0 ;
14869 int res1 = 0 ;
14870 PyObject *swig_obj[1] ;
14871
14872 if (!args) SWIG_fail;
14873 swig_obj[0] = args;
14874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14875 if (!SWIG_IsOK(res1)) {
14876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14877 }
14878 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14879 {
14880 PyThreadState* __tstate = wxPyBeginAllowThreads();
14881 result = (int)(arg1)->GetVMax();
14882 wxPyEndAllowThreads(__tstate);
14883 if (PyErr_Occurred()) SWIG_fail;
14884 }
14885 resultobj = SWIG_From_int(static_cast< int >(result));
14886 return resultobj;
14887 fail:
14888 return NULL;
14889 }
14890
14891
14892 SWIGINTERN PyObject *_wrap_Joystick_HasRudder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14893 PyObject *resultobj = 0;
14894 wxJoystick *arg1 = (wxJoystick *) 0 ;
14895 bool result;
14896 void *argp1 = 0 ;
14897 int res1 = 0 ;
14898 PyObject *swig_obj[1] ;
14899
14900 if (!args) SWIG_fail;
14901 swig_obj[0] = args;
14902 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14903 if (!SWIG_IsOK(res1)) {
14904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasRudder" "', expected argument " "1"" of type '" "wxJoystick *""'");
14905 }
14906 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14907 {
14908 PyThreadState* __tstate = wxPyBeginAllowThreads();
14909 result = (bool)(arg1)->HasRudder();
14910 wxPyEndAllowThreads(__tstate);
14911 if (PyErr_Occurred()) SWIG_fail;
14912 }
14913 {
14914 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14915 }
14916 return resultobj;
14917 fail:
14918 return NULL;
14919 }
14920
14921
14922 SWIGINTERN PyObject *_wrap_Joystick_HasZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14923 PyObject *resultobj = 0;
14924 wxJoystick *arg1 = (wxJoystick *) 0 ;
14925 bool result;
14926 void *argp1 = 0 ;
14927 int res1 = 0 ;
14928 PyObject *swig_obj[1] ;
14929
14930 if (!args) SWIG_fail;
14931 swig_obj[0] = args;
14932 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14933 if (!SWIG_IsOK(res1)) {
14934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasZ" "', expected argument " "1"" of type '" "wxJoystick *""'");
14935 }
14936 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14937 {
14938 PyThreadState* __tstate = wxPyBeginAllowThreads();
14939 result = (bool)(arg1)->HasZ();
14940 wxPyEndAllowThreads(__tstate);
14941 if (PyErr_Occurred()) SWIG_fail;
14942 }
14943 {
14944 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14945 }
14946 return resultobj;
14947 fail:
14948 return NULL;
14949 }
14950
14951
14952 SWIGINTERN PyObject *_wrap_Joystick_HasU(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14953 PyObject *resultobj = 0;
14954 wxJoystick *arg1 = (wxJoystick *) 0 ;
14955 bool result;
14956 void *argp1 = 0 ;
14957 int res1 = 0 ;
14958 PyObject *swig_obj[1] ;
14959
14960 if (!args) SWIG_fail;
14961 swig_obj[0] = args;
14962 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14963 if (!SWIG_IsOK(res1)) {
14964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasU" "', expected argument " "1"" of type '" "wxJoystick *""'");
14965 }
14966 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14967 {
14968 PyThreadState* __tstate = wxPyBeginAllowThreads();
14969 result = (bool)(arg1)->HasU();
14970 wxPyEndAllowThreads(__tstate);
14971 if (PyErr_Occurred()) SWIG_fail;
14972 }
14973 {
14974 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14975 }
14976 return resultobj;
14977 fail:
14978 return NULL;
14979 }
14980
14981
14982 SWIGINTERN PyObject *_wrap_Joystick_HasV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14983 PyObject *resultobj = 0;
14984 wxJoystick *arg1 = (wxJoystick *) 0 ;
14985 bool result;
14986 void *argp1 = 0 ;
14987 int res1 = 0 ;
14988 PyObject *swig_obj[1] ;
14989
14990 if (!args) SWIG_fail;
14991 swig_obj[0] = args;
14992 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14993 if (!SWIG_IsOK(res1)) {
14994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasV" "', expected argument " "1"" of type '" "wxJoystick *""'");
14995 }
14996 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14997 {
14998 PyThreadState* __tstate = wxPyBeginAllowThreads();
14999 result = (bool)(arg1)->HasV();
15000 wxPyEndAllowThreads(__tstate);
15001 if (PyErr_Occurred()) SWIG_fail;
15002 }
15003 {
15004 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15005 }
15006 return resultobj;
15007 fail:
15008 return NULL;
15009 }
15010
15011
15012 SWIGINTERN PyObject *_wrap_Joystick_HasPOV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15013 PyObject *resultobj = 0;
15014 wxJoystick *arg1 = (wxJoystick *) 0 ;
15015 bool result;
15016 void *argp1 = 0 ;
15017 int res1 = 0 ;
15018 PyObject *swig_obj[1] ;
15019
15020 if (!args) SWIG_fail;
15021 swig_obj[0] = args;
15022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15023 if (!SWIG_IsOK(res1)) {
15024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV" "', expected argument " "1"" of type '" "wxJoystick *""'");
15025 }
15026 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15027 {
15028 PyThreadState* __tstate = wxPyBeginAllowThreads();
15029 result = (bool)(arg1)->HasPOV();
15030 wxPyEndAllowThreads(__tstate);
15031 if (PyErr_Occurred()) SWIG_fail;
15032 }
15033 {
15034 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15035 }
15036 return resultobj;
15037 fail:
15038 return NULL;
15039 }
15040
15041
15042 SWIGINTERN PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15043 PyObject *resultobj = 0;
15044 wxJoystick *arg1 = (wxJoystick *) 0 ;
15045 bool result;
15046 void *argp1 = 0 ;
15047 int res1 = 0 ;
15048 PyObject *swig_obj[1] ;
15049
15050 if (!args) SWIG_fail;
15051 swig_obj[0] = args;
15052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15053 if (!SWIG_IsOK(res1)) {
15054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV4Dir" "', expected argument " "1"" of type '" "wxJoystick *""'");
15055 }
15056 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15057 {
15058 PyThreadState* __tstate = wxPyBeginAllowThreads();
15059 result = (bool)(arg1)->HasPOV4Dir();
15060 wxPyEndAllowThreads(__tstate);
15061 if (PyErr_Occurred()) SWIG_fail;
15062 }
15063 {
15064 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15065 }
15066 return resultobj;
15067 fail:
15068 return NULL;
15069 }
15070
15071
15072 SWIGINTERN PyObject *_wrap_Joystick_HasPOVCTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15073 PyObject *resultobj = 0;
15074 wxJoystick *arg1 = (wxJoystick *) 0 ;
15075 bool result;
15076 void *argp1 = 0 ;
15077 int res1 = 0 ;
15078 PyObject *swig_obj[1] ;
15079
15080 if (!args) SWIG_fail;
15081 swig_obj[0] = args;
15082 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15083 if (!SWIG_IsOK(res1)) {
15084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOVCTS" "', expected argument " "1"" of type '" "wxJoystick *""'");
15085 }
15086 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15087 {
15088 PyThreadState* __tstate = wxPyBeginAllowThreads();
15089 result = (bool)(arg1)->HasPOVCTS();
15090 wxPyEndAllowThreads(__tstate);
15091 if (PyErr_Occurred()) SWIG_fail;
15092 }
15093 {
15094 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15095 }
15096 return resultobj;
15097 fail:
15098 return NULL;
15099 }
15100
15101
15102 SWIGINTERN PyObject *_wrap_Joystick_SetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15103 PyObject *resultobj = 0;
15104 wxJoystick *arg1 = (wxJoystick *) 0 ;
15105 wxWindow *arg2 = (wxWindow *) 0 ;
15106 int arg3 = (int) 0 ;
15107 bool result;
15108 void *argp1 = 0 ;
15109 int res1 = 0 ;
15110 void *argp2 = 0 ;
15111 int res2 = 0 ;
15112 int val3 ;
15113 int ecode3 = 0 ;
15114 PyObject * obj0 = 0 ;
15115 PyObject * obj1 = 0 ;
15116 PyObject * obj2 = 0 ;
15117 char * kwnames[] = {
15118 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
15119 };
15120
15121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15122 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15123 if (!SWIG_IsOK(res1)) {
15124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
15125 }
15126 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15127 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
15128 if (!SWIG_IsOK(res2)) {
15129 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Joystick_SetCapture" "', expected argument " "2"" of type '" "wxWindow *""'");
15130 }
15131 arg2 = reinterpret_cast< wxWindow * >(argp2);
15132 if (obj2) {
15133 ecode3 = SWIG_AsVal_int(obj2, &val3);
15134 if (!SWIG_IsOK(ecode3)) {
15135 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Joystick_SetCapture" "', expected argument " "3"" of type '" "int""'");
15136 }
15137 arg3 = static_cast< int >(val3);
15138 }
15139 {
15140 PyThreadState* __tstate = wxPyBeginAllowThreads();
15141 result = (bool)(arg1)->SetCapture(arg2,arg3);
15142 wxPyEndAllowThreads(__tstate);
15143 if (PyErr_Occurred()) SWIG_fail;
15144 }
15145 {
15146 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15147 }
15148 return resultobj;
15149 fail:
15150 return NULL;
15151 }
15152
15153
15154 SWIGINTERN PyObject *_wrap_Joystick_ReleaseCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15155 PyObject *resultobj = 0;
15156 wxJoystick *arg1 = (wxJoystick *) 0 ;
15157 bool result;
15158 void *argp1 = 0 ;
15159 int res1 = 0 ;
15160 PyObject *swig_obj[1] ;
15161
15162 if (!args) SWIG_fail;
15163 swig_obj[0] = args;
15164 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15165 if (!SWIG_IsOK(res1)) {
15166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_ReleaseCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
15167 }
15168 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15169 {
15170 PyThreadState* __tstate = wxPyBeginAllowThreads();
15171 result = (bool)(arg1)->ReleaseCapture();
15172 wxPyEndAllowThreads(__tstate);
15173 if (PyErr_Occurred()) SWIG_fail;
15174 }
15175 {
15176 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15177 }
15178 return resultobj;
15179 fail:
15180 return NULL;
15181 }
15182
15183
15184 SWIGINTERN PyObject *Joystick_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15185 PyObject *obj;
15186 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15187 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystick, SWIG_NewClientData(obj));
15188 return SWIG_Py_Void();
15189 }
15190
15191 SWIGINTERN PyObject *Joystick_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15192 return SWIG_Python_InitShadowInstance(args);
15193 }
15194
15195 SWIGINTERN PyObject *_wrap_new_JoystickEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15196 PyObject *resultobj = 0;
15197 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15198 int arg2 = (int) 0 ;
15199 int arg3 = (int) wxJOYSTICK1 ;
15200 int arg4 = (int) 0 ;
15201 wxJoystickEvent *result = 0 ;
15202 int val1 ;
15203 int ecode1 = 0 ;
15204 int val2 ;
15205 int ecode2 = 0 ;
15206 int val3 ;
15207 int ecode3 = 0 ;
15208 int val4 ;
15209 int ecode4 = 0 ;
15210 PyObject * obj0 = 0 ;
15211 PyObject * obj1 = 0 ;
15212 PyObject * obj2 = 0 ;
15213 PyObject * obj3 = 0 ;
15214 char * kwnames[] = {
15215 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
15216 };
15217
15218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15219 if (obj0) {
15220 ecode1 = SWIG_AsVal_int(obj0, &val1);
15221 if (!SWIG_IsOK(ecode1)) {
15222 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_JoystickEvent" "', expected argument " "1"" of type '" "wxEventType""'");
15223 }
15224 arg1 = static_cast< wxEventType >(val1);
15225 }
15226 if (obj1) {
15227 ecode2 = SWIG_AsVal_int(obj1, &val2);
15228 if (!SWIG_IsOK(ecode2)) {
15229 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_JoystickEvent" "', expected argument " "2"" of type '" "int""'");
15230 }
15231 arg2 = static_cast< int >(val2);
15232 }
15233 if (obj2) {
15234 ecode3 = SWIG_AsVal_int(obj2, &val3);
15235 if (!SWIG_IsOK(ecode3)) {
15236 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_JoystickEvent" "', expected argument " "3"" of type '" "int""'");
15237 }
15238 arg3 = static_cast< int >(val3);
15239 }
15240 if (obj3) {
15241 ecode4 = SWIG_AsVal_int(obj3, &val4);
15242 if (!SWIG_IsOK(ecode4)) {
15243 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_JoystickEvent" "', expected argument " "4"" of type '" "int""'");
15244 }
15245 arg4 = static_cast< int >(val4);
15246 }
15247 {
15248 PyThreadState* __tstate = wxPyBeginAllowThreads();
15249 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
15250 wxPyEndAllowThreads(__tstate);
15251 if (PyErr_Occurred()) SWIG_fail;
15252 }
15253 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_NEW | 0 );
15254 return resultobj;
15255 fail:
15256 return NULL;
15257 }
15258
15259
15260 SWIGINTERN PyObject *_wrap_JoystickEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15261 PyObject *resultobj = 0;
15262 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15263 wxPoint result;
15264 void *argp1 = 0 ;
15265 int res1 = 0 ;
15266 PyObject *swig_obj[1] ;
15267
15268 if (!args) SWIG_fail;
15269 swig_obj[0] = args;
15270 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15271 if (!SWIG_IsOK(res1)) {
15272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15273 }
15274 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15275 {
15276 PyThreadState* __tstate = wxPyBeginAllowThreads();
15277 result = ((wxJoystickEvent const *)arg1)->GetPosition();
15278 wxPyEndAllowThreads(__tstate);
15279 if (PyErr_Occurred()) SWIG_fail;
15280 }
15281 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
15282 return resultobj;
15283 fail:
15284 return NULL;
15285 }
15286
15287
15288 SWIGINTERN PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15289 PyObject *resultobj = 0;
15290 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15291 int result;
15292 void *argp1 = 0 ;
15293 int res1 = 0 ;
15294 PyObject *swig_obj[1] ;
15295
15296 if (!args) SWIG_fail;
15297 swig_obj[0] = args;
15298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15299 if (!SWIG_IsOK(res1)) {
15300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15301 }
15302 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15303 {
15304 PyThreadState* __tstate = wxPyBeginAllowThreads();
15305 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
15306 wxPyEndAllowThreads(__tstate);
15307 if (PyErr_Occurred()) SWIG_fail;
15308 }
15309 resultobj = SWIG_From_int(static_cast< int >(result));
15310 return resultobj;
15311 fail:
15312 return NULL;
15313 }
15314
15315
15316 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15317 PyObject *resultobj = 0;
15318 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15319 int result;
15320 void *argp1 = 0 ;
15321 int res1 = 0 ;
15322 PyObject *swig_obj[1] ;
15323
15324 if (!args) SWIG_fail;
15325 swig_obj[0] = args;
15326 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15327 if (!SWIG_IsOK(res1)) {
15328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15329 }
15330 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15331 {
15332 PyThreadState* __tstate = wxPyBeginAllowThreads();
15333 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
15334 wxPyEndAllowThreads(__tstate);
15335 if (PyErr_Occurred()) SWIG_fail;
15336 }
15337 resultobj = SWIG_From_int(static_cast< int >(result));
15338 return resultobj;
15339 fail:
15340 return NULL;
15341 }
15342
15343
15344 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15345 PyObject *resultobj = 0;
15346 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15347 int result;
15348 void *argp1 = 0 ;
15349 int res1 = 0 ;
15350 PyObject *swig_obj[1] ;
15351
15352 if (!args) SWIG_fail;
15353 swig_obj[0] = args;
15354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15355 if (!SWIG_IsOK(res1)) {
15356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15357 }
15358 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15359 {
15360 PyThreadState* __tstate = wxPyBeginAllowThreads();
15361 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
15362 wxPyEndAllowThreads(__tstate);
15363 if (PyErr_Occurred()) SWIG_fail;
15364 }
15365 resultobj = SWIG_From_int(static_cast< int >(result));
15366 return resultobj;
15367 fail:
15368 return NULL;
15369 }
15370
15371
15372 SWIGINTERN PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15373 PyObject *resultobj = 0;
15374 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15375 int result;
15376 void *argp1 = 0 ;
15377 int res1 = 0 ;
15378 PyObject *swig_obj[1] ;
15379
15380 if (!args) SWIG_fail;
15381 swig_obj[0] = args;
15382 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15383 if (!SWIG_IsOK(res1)) {
15384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15385 }
15386 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15387 {
15388 PyThreadState* __tstate = wxPyBeginAllowThreads();
15389 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
15390 wxPyEndAllowThreads(__tstate);
15391 if (PyErr_Occurred()) SWIG_fail;
15392 }
15393 resultobj = SWIG_From_int(static_cast< int >(result));
15394 return resultobj;
15395 fail:
15396 return NULL;
15397 }
15398
15399
15400 SWIGINTERN PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15401 PyObject *resultobj = 0;
15402 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15403 int arg2 ;
15404 void *argp1 = 0 ;
15405 int res1 = 0 ;
15406 int val2 ;
15407 int ecode2 = 0 ;
15408 PyObject * obj0 = 0 ;
15409 PyObject * obj1 = 0 ;
15410 char * kwnames[] = {
15411 (char *) "self",(char *) "stick", NULL
15412 };
15413
15414 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) SWIG_fail;
15415 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15416 if (!SWIG_IsOK(res1)) {
15417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15418 }
15419 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15420 ecode2 = SWIG_AsVal_int(obj1, &val2);
15421 if (!SWIG_IsOK(ecode2)) {
15422 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "2"" of type '" "int""'");
15423 }
15424 arg2 = static_cast< int >(val2);
15425 {
15426 PyThreadState* __tstate = wxPyBeginAllowThreads();
15427 (arg1)->SetJoystick(arg2);
15428 wxPyEndAllowThreads(__tstate);
15429 if (PyErr_Occurred()) SWIG_fail;
15430 }
15431 resultobj = SWIG_Py_Void();
15432 return resultobj;
15433 fail:
15434 return NULL;
15435 }
15436
15437
15438 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15439 PyObject *resultobj = 0;
15440 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15441 int arg2 ;
15442 void *argp1 = 0 ;
15443 int res1 = 0 ;
15444 int val2 ;
15445 int ecode2 = 0 ;
15446 PyObject * obj0 = 0 ;
15447 PyObject * obj1 = 0 ;
15448 char * kwnames[] = {
15449 (char *) "self",(char *) "state", NULL
15450 };
15451
15452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) SWIG_fail;
15453 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15454 if (!SWIG_IsOK(res1)) {
15455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15456 }
15457 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15458 ecode2 = SWIG_AsVal_int(obj1, &val2);
15459 if (!SWIG_IsOK(ecode2)) {
15460 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "2"" of type '" "int""'");
15461 }
15462 arg2 = static_cast< int >(val2);
15463 {
15464 PyThreadState* __tstate = wxPyBeginAllowThreads();
15465 (arg1)->SetButtonState(arg2);
15466 wxPyEndAllowThreads(__tstate);
15467 if (PyErr_Occurred()) SWIG_fail;
15468 }
15469 resultobj = SWIG_Py_Void();
15470 return resultobj;
15471 fail:
15472 return NULL;
15473 }
15474
15475
15476 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15477 PyObject *resultobj = 0;
15478 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15479 int arg2 ;
15480 void *argp1 = 0 ;
15481 int res1 = 0 ;
15482 int val2 ;
15483 int ecode2 = 0 ;
15484 PyObject * obj0 = 0 ;
15485 PyObject * obj1 = 0 ;
15486 char * kwnames[] = {
15487 (char *) "self",(char *) "change", NULL
15488 };
15489
15490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) SWIG_fail;
15491 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15492 if (!SWIG_IsOK(res1)) {
15493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15494 }
15495 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15496 ecode2 = SWIG_AsVal_int(obj1, &val2);
15497 if (!SWIG_IsOK(ecode2)) {
15498 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "2"" of type '" "int""'");
15499 }
15500 arg2 = static_cast< int >(val2);
15501 {
15502 PyThreadState* __tstate = wxPyBeginAllowThreads();
15503 (arg1)->SetButtonChange(arg2);
15504 wxPyEndAllowThreads(__tstate);
15505 if (PyErr_Occurred()) SWIG_fail;
15506 }
15507 resultobj = SWIG_Py_Void();
15508 return resultobj;
15509 fail:
15510 return NULL;
15511 }
15512
15513
15514 SWIGINTERN PyObject *_wrap_JoystickEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15515 PyObject *resultobj = 0;
15516 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15517 wxPoint *arg2 = 0 ;
15518 void *argp1 = 0 ;
15519 int res1 = 0 ;
15520 wxPoint temp2 ;
15521 PyObject * obj0 = 0 ;
15522 PyObject * obj1 = 0 ;
15523 char * kwnames[] = {
15524 (char *) "self",(char *) "pos", NULL
15525 };
15526
15527 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
15528 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15529 if (!SWIG_IsOK(res1)) {
15530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15531 }
15532 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15533 {
15534 arg2 = &temp2;
15535 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
15536 }
15537 {
15538 PyThreadState* __tstate = wxPyBeginAllowThreads();
15539 (arg1)->SetPosition((wxPoint const &)*arg2);
15540 wxPyEndAllowThreads(__tstate);
15541 if (PyErr_Occurred()) SWIG_fail;
15542 }
15543 resultobj = SWIG_Py_Void();
15544 return resultobj;
15545 fail:
15546 return NULL;
15547 }
15548
15549
15550 SWIGINTERN PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15551 PyObject *resultobj = 0;
15552 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15553 int arg2 ;
15554 void *argp1 = 0 ;
15555 int res1 = 0 ;
15556 int val2 ;
15557 int ecode2 = 0 ;
15558 PyObject * obj0 = 0 ;
15559 PyObject * obj1 = 0 ;
15560 char * kwnames[] = {
15561 (char *) "self",(char *) "zPos", NULL
15562 };
15563
15564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) SWIG_fail;
15565 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15566 if (!SWIG_IsOK(res1)) {
15567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15568 }
15569 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15570 ecode2 = SWIG_AsVal_int(obj1, &val2);
15571 if (!SWIG_IsOK(ecode2)) {
15572 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "2"" of type '" "int""'");
15573 }
15574 arg2 = static_cast< int >(val2);
15575 {
15576 PyThreadState* __tstate = wxPyBeginAllowThreads();
15577 (arg1)->SetZPosition(arg2);
15578 wxPyEndAllowThreads(__tstate);
15579 if (PyErr_Occurred()) SWIG_fail;
15580 }
15581 resultobj = SWIG_Py_Void();
15582 return resultobj;
15583 fail:
15584 return NULL;
15585 }
15586
15587
15588 SWIGINTERN PyObject *_wrap_JoystickEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15589 PyObject *resultobj = 0;
15590 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15591 bool result;
15592 void *argp1 = 0 ;
15593 int res1 = 0 ;
15594 PyObject *swig_obj[1] ;
15595
15596 if (!args) SWIG_fail;
15597 swig_obj[0] = args;
15598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15599 if (!SWIG_IsOK(res1)) {
15600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsButton" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15601 }
15602 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15603 {
15604 PyThreadState* __tstate = wxPyBeginAllowThreads();
15605 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
15606 wxPyEndAllowThreads(__tstate);
15607 if (PyErr_Occurred()) SWIG_fail;
15608 }
15609 {
15610 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15611 }
15612 return resultobj;
15613 fail:
15614 return NULL;
15615 }
15616
15617
15618 SWIGINTERN PyObject *_wrap_JoystickEvent_IsMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15619 PyObject *resultobj = 0;
15620 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15621 bool result;
15622 void *argp1 = 0 ;
15623 int res1 = 0 ;
15624 PyObject *swig_obj[1] ;
15625
15626 if (!args) SWIG_fail;
15627 swig_obj[0] = args;
15628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15629 if (!SWIG_IsOK(res1)) {
15630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15631 }
15632 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15633 {
15634 PyThreadState* __tstate = wxPyBeginAllowThreads();
15635 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
15636 wxPyEndAllowThreads(__tstate);
15637 if (PyErr_Occurred()) SWIG_fail;
15638 }
15639 {
15640 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15641 }
15642 return resultobj;
15643 fail:
15644 return NULL;
15645 }
15646
15647
15648 SWIGINTERN PyObject *_wrap_JoystickEvent_IsZMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15649 PyObject *resultobj = 0;
15650 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15651 bool result;
15652 void *argp1 = 0 ;
15653 int res1 = 0 ;
15654 PyObject *swig_obj[1] ;
15655
15656 if (!args) SWIG_fail;
15657 swig_obj[0] = args;
15658 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15659 if (!SWIG_IsOK(res1)) {
15660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsZMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15661 }
15662 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15663 {
15664 PyThreadState* __tstate = wxPyBeginAllowThreads();
15665 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
15666 wxPyEndAllowThreads(__tstate);
15667 if (PyErr_Occurred()) SWIG_fail;
15668 }
15669 {
15670 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15671 }
15672 return resultobj;
15673 fail:
15674 return NULL;
15675 }
15676
15677
15678 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15679 PyObject *resultobj = 0;
15680 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15681 int arg2 = (int) wxJOY_BUTTON_ANY ;
15682 bool result;
15683 void *argp1 = 0 ;
15684 int res1 = 0 ;
15685 int val2 ;
15686 int ecode2 = 0 ;
15687 PyObject * obj0 = 0 ;
15688 PyObject * obj1 = 0 ;
15689 char * kwnames[] = {
15690 (char *) "self",(char *) "but", NULL
15691 };
15692
15693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
15694 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15695 if (!SWIG_IsOK(res1)) {
15696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15697 }
15698 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15699 if (obj1) {
15700 ecode2 = SWIG_AsVal_int(obj1, &val2);
15701 if (!SWIG_IsOK(ecode2)) {
15702 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
15703 }
15704 arg2 = static_cast< int >(val2);
15705 }
15706 {
15707 PyThreadState* __tstate = wxPyBeginAllowThreads();
15708 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
15709 wxPyEndAllowThreads(__tstate);
15710 if (PyErr_Occurred()) SWIG_fail;
15711 }
15712 {
15713 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15714 }
15715 return resultobj;
15716 fail:
15717 return NULL;
15718 }
15719
15720
15721 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15722 PyObject *resultobj = 0;
15723 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15724 int arg2 = (int) wxJOY_BUTTON_ANY ;
15725 bool result;
15726 void *argp1 = 0 ;
15727 int res1 = 0 ;
15728 int val2 ;
15729 int ecode2 = 0 ;
15730 PyObject * obj0 = 0 ;
15731 PyObject * obj1 = 0 ;
15732 char * kwnames[] = {
15733 (char *) "self",(char *) "but", NULL
15734 };
15735
15736 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
15737 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15738 if (!SWIG_IsOK(res1)) {
15739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15740 }
15741 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15742 if (obj1) {
15743 ecode2 = SWIG_AsVal_int(obj1, &val2);
15744 if (!SWIG_IsOK(ecode2)) {
15745 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
15746 }
15747 arg2 = static_cast< int >(val2);
15748 }
15749 {
15750 PyThreadState* __tstate = wxPyBeginAllowThreads();
15751 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
15752 wxPyEndAllowThreads(__tstate);
15753 if (PyErr_Occurred()) SWIG_fail;
15754 }
15755 {
15756 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15757 }
15758 return resultobj;
15759 fail:
15760 return NULL;
15761 }
15762
15763
15764 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15765 PyObject *resultobj = 0;
15766 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15767 int arg2 = (int) wxJOY_BUTTON_ANY ;
15768 bool result;
15769 void *argp1 = 0 ;
15770 int res1 = 0 ;
15771 int val2 ;
15772 int ecode2 = 0 ;
15773 PyObject * obj0 = 0 ;
15774 PyObject * obj1 = 0 ;
15775 char * kwnames[] = {
15776 (char *) "self",(char *) "but", NULL
15777 };
15778
15779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
15780 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15781 if (!SWIG_IsOK(res1)) {
15782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15783 }
15784 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15785 if (obj1) {
15786 ecode2 = SWIG_AsVal_int(obj1, &val2);
15787 if (!SWIG_IsOK(ecode2)) {
15788 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
15789 }
15790 arg2 = static_cast< int >(val2);
15791 }
15792 {
15793 PyThreadState* __tstate = wxPyBeginAllowThreads();
15794 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
15795 wxPyEndAllowThreads(__tstate);
15796 if (PyErr_Occurred()) SWIG_fail;
15797 }
15798 {
15799 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15800 }
15801 return resultobj;
15802 fail:
15803 return NULL;
15804 }
15805
15806
15807 SWIGINTERN PyObject *JoystickEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15808 PyObject *obj;
15809 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15810 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystickEvent, SWIG_NewClientData(obj));
15811 return SWIG_Py_Void();
15812 }
15813
15814 SWIGINTERN PyObject *JoystickEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15815 return SWIG_Python_InitShadowInstance(args);
15816 }
15817
15818 SWIGINTERN PyObject *_wrap_new_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15819 PyObject *resultobj = 0;
15820 wxString const &arg1_defvalue = wxPyEmptyString ;
15821 wxString *arg1 = (wxString *) &arg1_defvalue ;
15822 wxSound *result = 0 ;
15823 bool temp1 = false ;
15824 PyObject * obj0 = 0 ;
15825 char * kwnames[] = {
15826 (char *) "fileName", NULL
15827 };
15828
15829 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) SWIG_fail;
15830 if (obj0) {
15831 {
15832 arg1 = wxString_in_helper(obj0);
15833 if (arg1 == NULL) SWIG_fail;
15834 temp1 = true;
15835 }
15836 }
15837 {
15838 if (!wxPyCheckForApp()) SWIG_fail;
15839 PyThreadState* __tstate = wxPyBeginAllowThreads();
15840 result = (wxSound *)new_wxSound((wxString const &)*arg1);
15841 wxPyEndAllowThreads(__tstate);
15842 if (PyErr_Occurred()) SWIG_fail;
15843 }
15844 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_NEW | 0 );
15845 {
15846 if (temp1)
15847 delete arg1;
15848 }
15849 return resultobj;
15850 fail:
15851 {
15852 if (temp1)
15853 delete arg1;
15854 }
15855 return NULL;
15856 }
15857
15858
15859 SWIGINTERN PyObject *_wrap_new_SoundFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15860 PyObject *resultobj = 0;
15861 PyObject *arg1 = (PyObject *) 0 ;
15862 wxSound *result = 0 ;
15863 PyObject * obj0 = 0 ;
15864 char * kwnames[] = {
15865 (char *) "data", NULL
15866 };
15867
15868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) SWIG_fail;
15869 arg1 = obj0;
15870 {
15871 if (!wxPyCheckForApp()) SWIG_fail;
15872 PyThreadState* __tstate = wxPyBeginAllowThreads();
15873 result = (wxSound *)new_wxSound(arg1);
15874 wxPyEndAllowThreads(__tstate);
15875 if (PyErr_Occurred()) SWIG_fail;
15876 }
15877 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_OWN | 0 );
15878 return resultobj;
15879 fail:
15880 return NULL;
15881 }
15882
15883
15884 SWIGINTERN PyObject *_wrap_delete_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15885 PyObject *resultobj = 0;
15886 wxSound *arg1 = (wxSound *) 0 ;
15887 void *argp1 = 0 ;
15888 int res1 = 0 ;
15889 PyObject *swig_obj[1] ;
15890
15891 if (!args) SWIG_fail;
15892 swig_obj[0] = args;
15893 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, SWIG_POINTER_DISOWN | 0 );
15894 if (!SWIG_IsOK(res1)) {
15895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sound" "', expected argument " "1"" of type '" "wxSound *""'");
15896 }
15897 arg1 = reinterpret_cast< wxSound * >(argp1);
15898 {
15899 PyThreadState* __tstate = wxPyBeginAllowThreads();
15900 delete arg1;
15901
15902 wxPyEndAllowThreads(__tstate);
15903 if (PyErr_Occurred()) SWIG_fail;
15904 }
15905 resultobj = SWIG_Py_Void();
15906 return resultobj;
15907 fail:
15908 return NULL;
15909 }
15910
15911
15912 SWIGINTERN PyObject *_wrap_Sound_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15913 PyObject *resultobj = 0;
15914 wxSound *arg1 = (wxSound *) 0 ;
15915 wxString *arg2 = 0 ;
15916 bool result;
15917 void *argp1 = 0 ;
15918 int res1 = 0 ;
15919 bool temp2 = false ;
15920 PyObject * obj0 = 0 ;
15921 PyObject * obj1 = 0 ;
15922 char * kwnames[] = {
15923 (char *) "self",(char *) "fileName", NULL
15924 };
15925
15926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) SWIG_fail;
15927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
15928 if (!SWIG_IsOK(res1)) {
15929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Create" "', expected argument " "1"" of type '" "wxSound *""'");
15930 }
15931 arg1 = reinterpret_cast< wxSound * >(argp1);
15932 {
15933 arg2 = wxString_in_helper(obj1);
15934 if (arg2 == NULL) SWIG_fail;
15935 temp2 = true;
15936 }
15937 {
15938 PyThreadState* __tstate = wxPyBeginAllowThreads();
15939 result = (bool)(arg1)->Create((wxString const &)*arg2);
15940 wxPyEndAllowThreads(__tstate);
15941 if (PyErr_Occurred()) SWIG_fail;
15942 }
15943 {
15944 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15945 }
15946 {
15947 if (temp2)
15948 delete arg2;
15949 }
15950 return resultobj;
15951 fail:
15952 {
15953 if (temp2)
15954 delete arg2;
15955 }
15956 return NULL;
15957 }
15958
15959
15960 SWIGINTERN PyObject *_wrap_Sound_CreateFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15961 PyObject *resultobj = 0;
15962 wxSound *arg1 = (wxSound *) 0 ;
15963 PyObject *arg2 = (PyObject *) 0 ;
15964 bool result;
15965 void *argp1 = 0 ;
15966 int res1 = 0 ;
15967 PyObject * obj0 = 0 ;
15968 PyObject * obj1 = 0 ;
15969 char * kwnames[] = {
15970 (char *) "self",(char *) "data", NULL
15971 };
15972
15973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) SWIG_fail;
15974 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
15975 if (!SWIG_IsOK(res1)) {
15976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_CreateFromData" "', expected argument " "1"" of type '" "wxSound *""'");
15977 }
15978 arg1 = reinterpret_cast< wxSound * >(argp1);
15979 arg2 = obj1;
15980 {
15981 PyThreadState* __tstate = wxPyBeginAllowThreads();
15982 result = (bool)wxSound_CreateFromData(arg1,arg2);
15983 wxPyEndAllowThreads(__tstate);
15984 if (PyErr_Occurred()) SWIG_fail;
15985 }
15986 {
15987 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15988 }
15989 return resultobj;
15990 fail:
15991 return NULL;
15992 }
15993
15994
15995 SWIGINTERN PyObject *_wrap_Sound_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15996 PyObject *resultobj = 0;
15997 wxSound *arg1 = (wxSound *) 0 ;
15998 bool result;
15999 void *argp1 = 0 ;
16000 int res1 = 0 ;
16001 PyObject *swig_obj[1] ;
16002
16003 if (!args) SWIG_fail;
16004 swig_obj[0] = args;
16005 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
16006 if (!SWIG_IsOK(res1)) {
16007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_IsOk" "', expected argument " "1"" of type '" "wxSound *""'");
16008 }
16009 arg1 = reinterpret_cast< wxSound * >(argp1);
16010 {
16011 PyThreadState* __tstate = wxPyBeginAllowThreads();
16012 result = (bool)(arg1)->IsOk();
16013 wxPyEndAllowThreads(__tstate);
16014 if (PyErr_Occurred()) SWIG_fail;
16015 }
16016 {
16017 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16018 }
16019 return resultobj;
16020 fail:
16021 return NULL;
16022 }
16023
16024
16025 SWIGINTERN PyObject *_wrap_Sound_Play(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16026 PyObject *resultobj = 0;
16027 wxSound *arg1 = (wxSound *) 0 ;
16028 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
16029 bool result;
16030 void *argp1 = 0 ;
16031 int res1 = 0 ;
16032 unsigned int val2 ;
16033 int ecode2 = 0 ;
16034 PyObject * obj0 = 0 ;
16035 PyObject * obj1 = 0 ;
16036 char * kwnames[] = {
16037 (char *) "self",(char *) "flags", NULL
16038 };
16039
16040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) SWIG_fail;
16041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
16042 if (!SWIG_IsOK(res1)) {
16043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Play" "', expected argument " "1"" of type '" "wxSound const *""'");
16044 }
16045 arg1 = reinterpret_cast< wxSound * >(argp1);
16046 if (obj1) {
16047 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
16048 if (!SWIG_IsOK(ecode2)) {
16049 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_Play" "', expected argument " "2"" of type '" "unsigned int""'");
16050 }
16051 arg2 = static_cast< unsigned int >(val2);
16052 }
16053 {
16054 if (!wxPyCheckForApp()) SWIG_fail;
16055 PyThreadState* __tstate = wxPyBeginAllowThreads();
16056 result = (bool)((wxSound const *)arg1)->Play(arg2);
16057 wxPyEndAllowThreads(__tstate);
16058 if (PyErr_Occurred()) SWIG_fail;
16059 }
16060 {
16061 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16062 }
16063 return resultobj;
16064 fail:
16065 return NULL;
16066 }
16067
16068
16069 SWIGINTERN PyObject *_wrap_Sound_PlaySound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16070 PyObject *resultobj = 0;
16071 wxString *arg1 = 0 ;
16072 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
16073 bool result;
16074 bool temp1 = false ;
16075 unsigned int val2 ;
16076 int ecode2 = 0 ;
16077 PyObject * obj0 = 0 ;
16078 PyObject * obj1 = 0 ;
16079 char * kwnames[] = {
16080 (char *) "filename",(char *) "flags", NULL
16081 };
16082
16083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) SWIG_fail;
16084 {
16085 arg1 = wxString_in_helper(obj0);
16086 if (arg1 == NULL) SWIG_fail;
16087 temp1 = true;
16088 }
16089 if (obj1) {
16090 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
16091 if (!SWIG_IsOK(ecode2)) {
16092 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_PlaySound" "', expected argument " "2"" of type '" "unsigned int""'");
16093 }
16094 arg2 = static_cast< unsigned int >(val2);
16095 }
16096 {
16097 if (!wxPyCheckForApp()) SWIG_fail;
16098 PyThreadState* __tstate = wxPyBeginAllowThreads();
16099 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
16100 wxPyEndAllowThreads(__tstate);
16101 if (PyErr_Occurred()) SWIG_fail;
16102 }
16103 {
16104 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16105 }
16106 {
16107 if (temp1)
16108 delete arg1;
16109 }
16110 return resultobj;
16111 fail:
16112 {
16113 if (temp1)
16114 delete arg1;
16115 }
16116 return NULL;
16117 }
16118
16119
16120 SWIGINTERN PyObject *_wrap_Sound_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16121 PyObject *resultobj = 0;
16122
16123 if (!SWIG_Python_UnpackTuple(args,"Sound_Stop",0,0,0)) SWIG_fail;
16124 {
16125 if (!wxPyCheckForApp()) SWIG_fail;
16126 PyThreadState* __tstate = wxPyBeginAllowThreads();
16127 wxSound::Stop();
16128 wxPyEndAllowThreads(__tstate);
16129 if (PyErr_Occurred()) SWIG_fail;
16130 }
16131 resultobj = SWIG_Py_Void();
16132 return resultobj;
16133 fail:
16134 return NULL;
16135 }
16136
16137
16138 SWIGINTERN PyObject *Sound_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16139 PyObject *obj;
16140 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16141 SWIG_TypeNewClientData(SWIGTYPE_p_wxSound, SWIG_NewClientData(obj));
16142 return SWIG_Py_Void();
16143 }
16144
16145 SWIGINTERN PyObject *Sound_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16146 return SWIG_Python_InitShadowInstance(args);
16147 }
16148
16149 SWIGINTERN PyObject *_wrap_new_FileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16150 PyObject *resultobj = 0;
16151 wxString *arg1 = 0 ;
16152 wxString *arg2 = 0 ;
16153 wxString *arg3 = 0 ;
16154 wxString *arg4 = 0 ;
16155 wxFileTypeInfo *result = 0 ;
16156 bool temp1 = false ;
16157 bool temp2 = false ;
16158 bool temp3 = false ;
16159 bool temp4 = false ;
16160 PyObject * obj0 = 0 ;
16161 PyObject * obj1 = 0 ;
16162 PyObject * obj2 = 0 ;
16163 PyObject * obj3 = 0 ;
16164 char * kwnames[] = {
16165 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
16166 };
16167
16168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16169 {
16170 arg1 = wxString_in_helper(obj0);
16171 if (arg1 == NULL) SWIG_fail;
16172 temp1 = true;
16173 }
16174 {
16175 arg2 = wxString_in_helper(obj1);
16176 if (arg2 == NULL) SWIG_fail;
16177 temp2 = true;
16178 }
16179 {
16180 arg3 = wxString_in_helper(obj2);
16181 if (arg3 == NULL) SWIG_fail;
16182 temp3 = true;
16183 }
16184 {
16185 arg4 = wxString_in_helper(obj3);
16186 if (arg4 == NULL) SWIG_fail;
16187 temp4 = true;
16188 }
16189 {
16190 PyThreadState* __tstate = wxPyBeginAllowThreads();
16191 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
16192 wxPyEndAllowThreads(__tstate);
16193 if (PyErr_Occurred()) SWIG_fail;
16194 }
16195 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_NEW | 0 );
16196 {
16197 if (temp1)
16198 delete arg1;
16199 }
16200 {
16201 if (temp2)
16202 delete arg2;
16203 }
16204 {
16205 if (temp3)
16206 delete arg3;
16207 }
16208 {
16209 if (temp4)
16210 delete arg4;
16211 }
16212 return resultobj;
16213 fail:
16214 {
16215 if (temp1)
16216 delete arg1;
16217 }
16218 {
16219 if (temp2)
16220 delete arg2;
16221 }
16222 {
16223 if (temp3)
16224 delete arg3;
16225 }
16226 {
16227 if (temp4)
16228 delete arg4;
16229 }
16230 return NULL;
16231 }
16232
16233
16234 SWIGINTERN PyObject *_wrap_new_FileTypeInfoSequence(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16235 PyObject *resultobj = 0;
16236 wxArrayString *arg1 = 0 ;
16237 wxFileTypeInfo *result = 0 ;
16238 bool temp1 = false ;
16239 PyObject * obj0 = 0 ;
16240 char * kwnames[] = {
16241 (char *) "sArray", NULL
16242 };
16243
16244 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) SWIG_fail;
16245 {
16246 if (! PySequence_Check(obj0)) {
16247 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
16248 SWIG_fail;
16249 }
16250 arg1 = new wxArrayString;
16251 temp1 = true;
16252 int i, len=PySequence_Length(obj0);
16253 for (i=0; i<len; i++) {
16254 PyObject* item = PySequence_GetItem(obj0, i);
16255 wxString* s = wxString_in_helper(item);
16256 if (PyErr_Occurred()) SWIG_fail;
16257 arg1->Add(*s);
16258 delete s;
16259 Py_DECREF(item);
16260 }
16261 }
16262 {
16263 PyThreadState* __tstate = wxPyBeginAllowThreads();
16264 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
16265 wxPyEndAllowThreads(__tstate);
16266 if (PyErr_Occurred()) SWIG_fail;
16267 }
16268 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
16269 {
16270 if (temp1) delete arg1;
16271 }
16272 return resultobj;
16273 fail:
16274 {
16275 if (temp1) delete arg1;
16276 }
16277 return NULL;
16278 }
16279
16280
16281 SWIGINTERN PyObject *_wrap_new_NullFileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16282 PyObject *resultobj = 0;
16283 wxFileTypeInfo *result = 0 ;
16284
16285 if (!SWIG_Python_UnpackTuple(args,"new_NullFileTypeInfo",0,0,0)) SWIG_fail;
16286 {
16287 PyThreadState* __tstate = wxPyBeginAllowThreads();
16288 result = (wxFileTypeInfo *)new wxFileTypeInfo();
16289 wxPyEndAllowThreads(__tstate);
16290 if (PyErr_Occurred()) SWIG_fail;
16291 }
16292 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
16293 return resultobj;
16294 fail:
16295 return NULL;
16296 }
16297
16298
16299 SWIGINTERN PyObject *_wrap_FileTypeInfo_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16300 PyObject *resultobj = 0;
16301 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16302 bool result;
16303 void *argp1 = 0 ;
16304 int res1 = 0 ;
16305 PyObject *swig_obj[1] ;
16306
16307 if (!args) SWIG_fail;
16308 swig_obj[0] = args;
16309 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16310 if (!SWIG_IsOK(res1)) {
16311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_IsValid" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16312 }
16313 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16314 {
16315 PyThreadState* __tstate = wxPyBeginAllowThreads();
16316 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
16317 wxPyEndAllowThreads(__tstate);
16318 if (PyErr_Occurred()) SWIG_fail;
16319 }
16320 {
16321 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16322 }
16323 return resultobj;
16324 fail:
16325 return NULL;
16326 }
16327
16328
16329 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16330 PyObject *resultobj = 0;
16331 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16332 wxString *arg2 = 0 ;
16333 int arg3 = (int) 0 ;
16334 void *argp1 = 0 ;
16335 int res1 = 0 ;
16336 bool temp2 = false ;
16337 int val3 ;
16338 int ecode3 = 0 ;
16339 PyObject * obj0 = 0 ;
16340 PyObject * obj1 = 0 ;
16341 PyObject * obj2 = 0 ;
16342 char * kwnames[] = {
16343 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
16344 };
16345
16346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16347 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16348 if (!SWIG_IsOK(res1)) {
16349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
16350 }
16351 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16352 {
16353 arg2 = wxString_in_helper(obj1);
16354 if (arg2 == NULL) SWIG_fail;
16355 temp2 = true;
16356 }
16357 if (obj2) {
16358 ecode3 = SWIG_AsVal_int(obj2, &val3);
16359 if (!SWIG_IsOK(ecode3)) {
16360 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "3"" of type '" "int""'");
16361 }
16362 arg3 = static_cast< int >(val3);
16363 }
16364 {
16365 PyThreadState* __tstate = wxPyBeginAllowThreads();
16366 (arg1)->SetIcon((wxString const &)*arg2,arg3);
16367 wxPyEndAllowThreads(__tstate);
16368 if (PyErr_Occurred()) SWIG_fail;
16369 }
16370 resultobj = SWIG_Py_Void();
16371 {
16372 if (temp2)
16373 delete arg2;
16374 }
16375 return resultobj;
16376 fail:
16377 {
16378 if (temp2)
16379 delete arg2;
16380 }
16381 return NULL;
16382 }
16383
16384
16385 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16386 PyObject *resultobj = 0;
16387 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16388 wxString *arg2 = 0 ;
16389 void *argp1 = 0 ;
16390 int res1 = 0 ;
16391 bool temp2 = false ;
16392 PyObject * obj0 = 0 ;
16393 PyObject * obj1 = 0 ;
16394 char * kwnames[] = {
16395 (char *) "self",(char *) "shortDesc", NULL
16396 };
16397
16398 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) SWIG_fail;
16399 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16400 if (!SWIG_IsOK(res1)) {
16401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
16402 }
16403 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16404 {
16405 arg2 = wxString_in_helper(obj1);
16406 if (arg2 == NULL) SWIG_fail;
16407 temp2 = true;
16408 }
16409 {
16410 PyThreadState* __tstate = wxPyBeginAllowThreads();
16411 (arg1)->SetShortDesc((wxString const &)*arg2);
16412 wxPyEndAllowThreads(__tstate);
16413 if (PyErr_Occurred()) SWIG_fail;
16414 }
16415 resultobj = SWIG_Py_Void();
16416 {
16417 if (temp2)
16418 delete arg2;
16419 }
16420 return resultobj;
16421 fail:
16422 {
16423 if (temp2)
16424 delete arg2;
16425 }
16426 return NULL;
16427 }
16428
16429
16430 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16431 PyObject *resultobj = 0;
16432 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16433 wxString *result = 0 ;
16434 void *argp1 = 0 ;
16435 int res1 = 0 ;
16436 PyObject *swig_obj[1] ;
16437
16438 if (!args) SWIG_fail;
16439 swig_obj[0] = args;
16440 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16441 if (!SWIG_IsOK(res1)) {
16442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetMimeType" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16443 }
16444 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16445 {
16446 PyThreadState* __tstate = wxPyBeginAllowThreads();
16447 {
16448 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
16449 result = (wxString *) &_result_ref;
16450 }
16451 wxPyEndAllowThreads(__tstate);
16452 if (PyErr_Occurred()) SWIG_fail;
16453 }
16454 {
16455 #if wxUSE_UNICODE
16456 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16457 #else
16458 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16459 #endif
16460 }
16461 return resultobj;
16462 fail:
16463 return NULL;
16464 }
16465
16466
16467 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16468 PyObject *resultobj = 0;
16469 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16470 wxString *result = 0 ;
16471 void *argp1 = 0 ;
16472 int res1 = 0 ;
16473 PyObject *swig_obj[1] ;
16474
16475 if (!args) SWIG_fail;
16476 swig_obj[0] = args;
16477 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16478 if (!SWIG_IsOK(res1)) {
16479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16480 }
16481 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16482 {
16483 PyThreadState* __tstate = wxPyBeginAllowThreads();
16484 {
16485 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
16486 result = (wxString *) &_result_ref;
16487 }
16488 wxPyEndAllowThreads(__tstate);
16489 if (PyErr_Occurred()) SWIG_fail;
16490 }
16491 {
16492 #if wxUSE_UNICODE
16493 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16494 #else
16495 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16496 #endif
16497 }
16498 return resultobj;
16499 fail:
16500 return NULL;
16501 }
16502
16503
16504 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16505 PyObject *resultobj = 0;
16506 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16507 wxString *result = 0 ;
16508 void *argp1 = 0 ;
16509 int res1 = 0 ;
16510 PyObject *swig_obj[1] ;
16511
16512 if (!args) SWIG_fail;
16513 swig_obj[0] = args;
16514 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16515 if (!SWIG_IsOK(res1)) {
16516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16517 }
16518 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16519 {
16520 PyThreadState* __tstate = wxPyBeginAllowThreads();
16521 {
16522 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
16523 result = (wxString *) &_result_ref;
16524 }
16525 wxPyEndAllowThreads(__tstate);
16526 if (PyErr_Occurred()) SWIG_fail;
16527 }
16528 {
16529 #if wxUSE_UNICODE
16530 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16531 #else
16532 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16533 #endif
16534 }
16535 return resultobj;
16536 fail:
16537 return NULL;
16538 }
16539
16540
16541 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16542 PyObject *resultobj = 0;
16543 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16544 wxString *result = 0 ;
16545 void *argp1 = 0 ;
16546 int res1 = 0 ;
16547 PyObject *swig_obj[1] ;
16548
16549 if (!args) SWIG_fail;
16550 swig_obj[0] = args;
16551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16552 if (!SWIG_IsOK(res1)) {
16553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16554 }
16555 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16556 {
16557 PyThreadState* __tstate = wxPyBeginAllowThreads();
16558 {
16559 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
16560 result = (wxString *) &_result_ref;
16561 }
16562 wxPyEndAllowThreads(__tstate);
16563 if (PyErr_Occurred()) SWIG_fail;
16564 }
16565 {
16566 #if wxUSE_UNICODE
16567 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16568 #else
16569 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16570 #endif
16571 }
16572 return resultobj;
16573 fail:
16574 return NULL;
16575 }
16576
16577
16578 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16579 PyObject *resultobj = 0;
16580 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16581 wxString *result = 0 ;
16582 void *argp1 = 0 ;
16583 int res1 = 0 ;
16584 PyObject *swig_obj[1] ;
16585
16586 if (!args) SWIG_fail;
16587 swig_obj[0] = args;
16588 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16589 if (!SWIG_IsOK(res1)) {
16590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetDescription" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16591 }
16592 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16593 {
16594 PyThreadState* __tstate = wxPyBeginAllowThreads();
16595 {
16596 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
16597 result = (wxString *) &_result_ref;
16598 }
16599 wxPyEndAllowThreads(__tstate);
16600 if (PyErr_Occurred()) SWIG_fail;
16601 }
16602 {
16603 #if wxUSE_UNICODE
16604 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16605 #else
16606 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16607 #endif
16608 }
16609 return resultobj;
16610 fail:
16611 return NULL;
16612 }
16613
16614
16615 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16616 PyObject *resultobj = 0;
16617 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16618 wxArrayString *result = 0 ;
16619 void *argp1 = 0 ;
16620 int res1 = 0 ;
16621 PyObject *swig_obj[1] ;
16622
16623 if (!args) SWIG_fail;
16624 swig_obj[0] = args;
16625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16626 if (!SWIG_IsOK(res1)) {
16627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensions" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16628 }
16629 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16630 {
16631 PyThreadState* __tstate = wxPyBeginAllowThreads();
16632 {
16633 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
16634 result = (wxArrayString *) &_result_ref;
16635 }
16636 wxPyEndAllowThreads(__tstate);
16637 if (PyErr_Occurred()) SWIG_fail;
16638 }
16639 {
16640 resultobj = wxArrayString2PyList_helper(*result);
16641 }
16642 return resultobj;
16643 fail:
16644 return NULL;
16645 }
16646
16647
16648 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16649 PyObject *resultobj = 0;
16650 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16651 size_t result;
16652 void *argp1 = 0 ;
16653 int res1 = 0 ;
16654 PyObject *swig_obj[1] ;
16655
16656 if (!args) SWIG_fail;
16657 swig_obj[0] = args;
16658 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16659 if (!SWIG_IsOK(res1)) {
16660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensionsCount" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16661 }
16662 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16663 {
16664 PyThreadState* __tstate = wxPyBeginAllowThreads();
16665 result = (size_t)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
16666 wxPyEndAllowThreads(__tstate);
16667 if (PyErr_Occurred()) SWIG_fail;
16668 }
16669 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
16670 return resultobj;
16671 fail:
16672 return NULL;
16673 }
16674
16675
16676 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16677 PyObject *resultobj = 0;
16678 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16679 wxString *result = 0 ;
16680 void *argp1 = 0 ;
16681 int res1 = 0 ;
16682 PyObject *swig_obj[1] ;
16683
16684 if (!args) SWIG_fail;
16685 swig_obj[0] = args;
16686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16687 if (!SWIG_IsOK(res1)) {
16688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconFile" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16689 }
16690 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16691 {
16692 PyThreadState* __tstate = wxPyBeginAllowThreads();
16693 {
16694 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
16695 result = (wxString *) &_result_ref;
16696 }
16697 wxPyEndAllowThreads(__tstate);
16698 if (PyErr_Occurred()) SWIG_fail;
16699 }
16700 {
16701 #if wxUSE_UNICODE
16702 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16703 #else
16704 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16705 #endif
16706 }
16707 return resultobj;
16708 fail:
16709 return NULL;
16710 }
16711
16712
16713 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16714 PyObject *resultobj = 0;
16715 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16716 int result;
16717 void *argp1 = 0 ;
16718 int res1 = 0 ;
16719 PyObject *swig_obj[1] ;
16720
16721 if (!args) SWIG_fail;
16722 swig_obj[0] = args;
16723 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16724 if (!SWIG_IsOK(res1)) {
16725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconIndex" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16726 }
16727 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16728 {
16729 PyThreadState* __tstate = wxPyBeginAllowThreads();
16730 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
16731 wxPyEndAllowThreads(__tstate);
16732 if (PyErr_Occurred()) SWIG_fail;
16733 }
16734 resultobj = SWIG_From_int(static_cast< int >(result));
16735 return resultobj;
16736 fail:
16737 return NULL;
16738 }
16739
16740
16741 SWIGINTERN PyObject *FileTypeInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16742 PyObject *obj;
16743 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16744 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileTypeInfo, SWIG_NewClientData(obj));
16745 return SWIG_Py_Void();
16746 }
16747
16748 SWIGINTERN PyObject *FileTypeInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16749 return SWIG_Python_InitShadowInstance(args);
16750 }
16751
16752 SWIGINTERN PyObject *_wrap_new_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16753 PyObject *resultobj = 0;
16754 wxFileTypeInfo *arg1 = 0 ;
16755 wxFileType *result = 0 ;
16756 void *argp1 = 0 ;
16757 int res1 = 0 ;
16758 PyObject * obj0 = 0 ;
16759 char * kwnames[] = {
16760 (char *) "ftInfo", NULL
16761 };
16762
16763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) SWIG_fail;
16764 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
16765 if (!SWIG_IsOK(res1)) {
16766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
16767 }
16768 if (!argp1) {
16769 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
16770 }
16771 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16772 {
16773 PyThreadState* __tstate = wxPyBeginAllowThreads();
16774 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
16775 wxPyEndAllowThreads(__tstate);
16776 if (PyErr_Occurred()) SWIG_fail;
16777 }
16778 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_NEW | 0 );
16779 return resultobj;
16780 fail:
16781 return NULL;
16782 }
16783
16784
16785 SWIGINTERN PyObject *_wrap_delete_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16786 PyObject *resultobj = 0;
16787 wxFileType *arg1 = (wxFileType *) 0 ;
16788 void *argp1 = 0 ;
16789 int res1 = 0 ;
16790 PyObject *swig_obj[1] ;
16791
16792 if (!args) SWIG_fail;
16793 swig_obj[0] = args;
16794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, SWIG_POINTER_DISOWN | 0 );
16795 if (!SWIG_IsOK(res1)) {
16796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileType" "', expected argument " "1"" of type '" "wxFileType *""'");
16797 }
16798 arg1 = reinterpret_cast< wxFileType * >(argp1);
16799 {
16800 PyThreadState* __tstate = wxPyBeginAllowThreads();
16801 delete arg1;
16802
16803 wxPyEndAllowThreads(__tstate);
16804 if (PyErr_Occurred()) SWIG_fail;
16805 }
16806 resultobj = SWIG_Py_Void();
16807 return resultobj;
16808 fail:
16809 return NULL;
16810 }
16811
16812
16813 SWIGINTERN PyObject *_wrap_FileType_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16814 PyObject *resultobj = 0;
16815 wxFileType *arg1 = (wxFileType *) 0 ;
16816 PyObject *result = 0 ;
16817 void *argp1 = 0 ;
16818 int res1 = 0 ;
16819 PyObject *swig_obj[1] ;
16820
16821 if (!args) SWIG_fail;
16822 swig_obj[0] = args;
16823 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16824 if (!SWIG_IsOK(res1)) {
16825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeType" "', expected argument " "1"" of type '" "wxFileType *""'");
16826 }
16827 arg1 = reinterpret_cast< wxFileType * >(argp1);
16828 {
16829 PyThreadState* __tstate = wxPyBeginAllowThreads();
16830 result = (PyObject *)wxFileType_GetMimeType(arg1);
16831 wxPyEndAllowThreads(__tstate);
16832 if (PyErr_Occurred()) SWIG_fail;
16833 }
16834 resultobj = result;
16835 return resultobj;
16836 fail:
16837 return NULL;
16838 }
16839
16840
16841 SWIGINTERN PyObject *_wrap_FileType_GetMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16842 PyObject *resultobj = 0;
16843 wxFileType *arg1 = (wxFileType *) 0 ;
16844 PyObject *result = 0 ;
16845 void *argp1 = 0 ;
16846 int res1 = 0 ;
16847 PyObject *swig_obj[1] ;
16848
16849 if (!args) SWIG_fail;
16850 swig_obj[0] = args;
16851 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16852 if (!SWIG_IsOK(res1)) {
16853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeTypes" "', expected argument " "1"" of type '" "wxFileType *""'");
16854 }
16855 arg1 = reinterpret_cast< wxFileType * >(argp1);
16856 {
16857 PyThreadState* __tstate = wxPyBeginAllowThreads();
16858 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
16859 wxPyEndAllowThreads(__tstate);
16860 if (PyErr_Occurred()) SWIG_fail;
16861 }
16862 resultobj = result;
16863 return resultobj;
16864 fail:
16865 return NULL;
16866 }
16867
16868
16869 SWIGINTERN PyObject *_wrap_FileType_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16870 PyObject *resultobj = 0;
16871 wxFileType *arg1 = (wxFileType *) 0 ;
16872 PyObject *result = 0 ;
16873 void *argp1 = 0 ;
16874 int res1 = 0 ;
16875 PyObject *swig_obj[1] ;
16876
16877 if (!args) SWIG_fail;
16878 swig_obj[0] = args;
16879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16880 if (!SWIG_IsOK(res1)) {
16881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetExtensions" "', expected argument " "1"" of type '" "wxFileType *""'");
16882 }
16883 arg1 = reinterpret_cast< wxFileType * >(argp1);
16884 {
16885 PyThreadState* __tstate = wxPyBeginAllowThreads();
16886 result = (PyObject *)wxFileType_GetExtensions(arg1);
16887 wxPyEndAllowThreads(__tstate);
16888 if (PyErr_Occurred()) SWIG_fail;
16889 }
16890 resultobj = result;
16891 return resultobj;
16892 fail:
16893 return NULL;
16894 }
16895
16896
16897 SWIGINTERN PyObject *_wrap_FileType_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16898 PyObject *resultobj = 0;
16899 wxFileType *arg1 = (wxFileType *) 0 ;
16900 wxIcon *result = 0 ;
16901 void *argp1 = 0 ;
16902 int res1 = 0 ;
16903 PyObject *swig_obj[1] ;
16904
16905 if (!args) SWIG_fail;
16906 swig_obj[0] = args;
16907 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16908 if (!SWIG_IsOK(res1)) {
16909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
16910 }
16911 arg1 = reinterpret_cast< wxFileType * >(argp1);
16912 {
16913 PyThreadState* __tstate = wxPyBeginAllowThreads();
16914 result = (wxIcon *)wxFileType_GetIcon(arg1);
16915 wxPyEndAllowThreads(__tstate);
16916 if (PyErr_Occurred()) SWIG_fail;
16917 }
16918 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
16919 return resultobj;
16920 fail:
16921 return NULL;
16922 }
16923
16924
16925 SWIGINTERN PyObject *_wrap_FileType_GetIconInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16926 PyObject *resultobj = 0;
16927 wxFileType *arg1 = (wxFileType *) 0 ;
16928 PyObject *result = 0 ;
16929 void *argp1 = 0 ;
16930 int res1 = 0 ;
16931 PyObject *swig_obj[1] ;
16932
16933 if (!args) SWIG_fail;
16934 swig_obj[0] = args;
16935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16936 if (!SWIG_IsOK(res1)) {
16937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIconInfo" "', expected argument " "1"" of type '" "wxFileType *""'");
16938 }
16939 arg1 = reinterpret_cast< wxFileType * >(argp1);
16940 {
16941 PyThreadState* __tstate = wxPyBeginAllowThreads();
16942 result = (PyObject *)wxFileType_GetIconInfo(arg1);
16943 wxPyEndAllowThreads(__tstate);
16944 if (PyErr_Occurred()) SWIG_fail;
16945 }
16946 resultobj = result;
16947 return resultobj;
16948 fail:
16949 return NULL;
16950 }
16951
16952
16953 SWIGINTERN PyObject *_wrap_FileType_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16954 PyObject *resultobj = 0;
16955 wxFileType *arg1 = (wxFileType *) 0 ;
16956 PyObject *result = 0 ;
16957 void *argp1 = 0 ;
16958 int res1 = 0 ;
16959 PyObject *swig_obj[1] ;
16960
16961 if (!args) SWIG_fail;
16962 swig_obj[0] = args;
16963 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16964 if (!SWIG_IsOK(res1)) {
16965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetDescription" "', expected argument " "1"" of type '" "wxFileType *""'");
16966 }
16967 arg1 = reinterpret_cast< wxFileType * >(argp1);
16968 {
16969 PyThreadState* __tstate = wxPyBeginAllowThreads();
16970 result = (PyObject *)wxFileType_GetDescription(arg1);
16971 wxPyEndAllowThreads(__tstate);
16972 if (PyErr_Occurred()) SWIG_fail;
16973 }
16974 resultobj = result;
16975 return resultobj;
16976 fail:
16977 return NULL;
16978 }
16979
16980
16981 SWIGINTERN PyObject *_wrap_FileType_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16982 PyObject *resultobj = 0;
16983 wxFileType *arg1 = (wxFileType *) 0 ;
16984 wxString *arg2 = 0 ;
16985 wxString const &arg3_defvalue = wxPyEmptyString ;
16986 wxString *arg3 = (wxString *) &arg3_defvalue ;
16987 PyObject *result = 0 ;
16988 void *argp1 = 0 ;
16989 int res1 = 0 ;
16990 bool temp2 = false ;
16991 bool temp3 = false ;
16992 PyObject * obj0 = 0 ;
16993 PyObject * obj1 = 0 ;
16994 PyObject * obj2 = 0 ;
16995 char * kwnames[] = {
16996 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
16997 };
16998
16999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17001 if (!SWIG_IsOK(res1)) {
17002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
17003 }
17004 arg1 = reinterpret_cast< wxFileType * >(argp1);
17005 {
17006 arg2 = wxString_in_helper(obj1);
17007 if (arg2 == NULL) SWIG_fail;
17008 temp2 = true;
17009 }
17010 if (obj2) {
17011 {
17012 arg3 = wxString_in_helper(obj2);
17013 if (arg3 == NULL) SWIG_fail;
17014 temp3 = true;
17015 }
17016 }
17017 {
17018 PyThreadState* __tstate = wxPyBeginAllowThreads();
17019 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
17020 wxPyEndAllowThreads(__tstate);
17021 if (PyErr_Occurred()) SWIG_fail;
17022 }
17023 resultobj = result;
17024 {
17025 if (temp2)
17026 delete arg2;
17027 }
17028 {
17029 if (temp3)
17030 delete arg3;
17031 }
17032 return resultobj;
17033 fail:
17034 {
17035 if (temp2)
17036 delete arg2;
17037 }
17038 {
17039 if (temp3)
17040 delete arg3;
17041 }
17042 return NULL;
17043 }
17044
17045
17046 SWIGINTERN PyObject *_wrap_FileType_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17047 PyObject *resultobj = 0;
17048 wxFileType *arg1 = (wxFileType *) 0 ;
17049 wxString *arg2 = 0 ;
17050 wxString const &arg3_defvalue = wxPyEmptyString ;
17051 wxString *arg3 = (wxString *) &arg3_defvalue ;
17052 PyObject *result = 0 ;
17053 void *argp1 = 0 ;
17054 int res1 = 0 ;
17055 bool temp2 = false ;
17056 bool temp3 = false ;
17057 PyObject * obj0 = 0 ;
17058 PyObject * obj1 = 0 ;
17059 PyObject * obj2 = 0 ;
17060 char * kwnames[] = {
17061 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
17062 };
17063
17064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17065 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17066 if (!SWIG_IsOK(res1)) {
17067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
17068 }
17069 arg1 = reinterpret_cast< wxFileType * >(argp1);
17070 {
17071 arg2 = wxString_in_helper(obj1);
17072 if (arg2 == NULL) SWIG_fail;
17073 temp2 = true;
17074 }
17075 if (obj2) {
17076 {
17077 arg3 = wxString_in_helper(obj2);
17078 if (arg3 == NULL) SWIG_fail;
17079 temp3 = true;
17080 }
17081 }
17082 {
17083 PyThreadState* __tstate = wxPyBeginAllowThreads();
17084 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
17085 wxPyEndAllowThreads(__tstate);
17086 if (PyErr_Occurred()) SWIG_fail;
17087 }
17088 resultobj = result;
17089 {
17090 if (temp2)
17091 delete arg2;
17092 }
17093 {
17094 if (temp3)
17095 delete arg3;
17096 }
17097 return resultobj;
17098 fail:
17099 {
17100 if (temp2)
17101 delete arg2;
17102 }
17103 {
17104 if (temp3)
17105 delete arg3;
17106 }
17107 return NULL;
17108 }
17109
17110
17111 SWIGINTERN PyObject *_wrap_FileType_GetAllCommands(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17112 PyObject *resultobj = 0;
17113 wxFileType *arg1 = (wxFileType *) 0 ;
17114 wxString *arg2 = 0 ;
17115 wxString const &arg3_defvalue = wxPyEmptyString ;
17116 wxString *arg3 = (wxString *) &arg3_defvalue ;
17117 PyObject *result = 0 ;
17118 void *argp1 = 0 ;
17119 int res1 = 0 ;
17120 bool temp2 = false ;
17121 bool temp3 = false ;
17122 PyObject * obj0 = 0 ;
17123 PyObject * obj1 = 0 ;
17124 PyObject * obj2 = 0 ;
17125 char * kwnames[] = {
17126 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
17127 };
17128
17129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17130 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17131 if (!SWIG_IsOK(res1)) {
17132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetAllCommands" "', expected argument " "1"" of type '" "wxFileType *""'");
17133 }
17134 arg1 = reinterpret_cast< wxFileType * >(argp1);
17135 {
17136 arg2 = wxString_in_helper(obj1);
17137 if (arg2 == NULL) SWIG_fail;
17138 temp2 = true;
17139 }
17140 if (obj2) {
17141 {
17142 arg3 = wxString_in_helper(obj2);
17143 if (arg3 == NULL) SWIG_fail;
17144 temp3 = true;
17145 }
17146 }
17147 {
17148 PyThreadState* __tstate = wxPyBeginAllowThreads();
17149 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
17150 wxPyEndAllowThreads(__tstate);
17151 if (PyErr_Occurred()) SWIG_fail;
17152 }
17153 resultobj = result;
17154 {
17155 if (temp2)
17156 delete arg2;
17157 }
17158 {
17159 if (temp3)
17160 delete arg3;
17161 }
17162 return resultobj;
17163 fail:
17164 {
17165 if (temp2)
17166 delete arg2;
17167 }
17168 {
17169 if (temp3)
17170 delete arg3;
17171 }
17172 return NULL;
17173 }
17174
17175
17176 SWIGINTERN PyObject *_wrap_FileType_SetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17177 PyObject *resultobj = 0;
17178 wxFileType *arg1 = (wxFileType *) 0 ;
17179 wxString *arg2 = 0 ;
17180 wxString *arg3 = 0 ;
17181 bool arg4 = (bool) true ;
17182 bool result;
17183 void *argp1 = 0 ;
17184 int res1 = 0 ;
17185 bool temp2 = false ;
17186 bool temp3 = false ;
17187 bool val4 ;
17188 int ecode4 = 0 ;
17189 PyObject * obj0 = 0 ;
17190 PyObject * obj1 = 0 ;
17191 PyObject * obj2 = 0 ;
17192 PyObject * obj3 = 0 ;
17193 char * kwnames[] = {
17194 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
17195 };
17196
17197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17199 if (!SWIG_IsOK(res1)) {
17200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
17201 }
17202 arg1 = reinterpret_cast< wxFileType * >(argp1);
17203 {
17204 arg2 = wxString_in_helper(obj1);
17205 if (arg2 == NULL) SWIG_fail;
17206 temp2 = true;
17207 }
17208 {
17209 arg3 = wxString_in_helper(obj2);
17210 if (arg3 == NULL) SWIG_fail;
17211 temp3 = true;
17212 }
17213 if (obj3) {
17214 ecode4 = SWIG_AsVal_bool(obj3, &val4);
17215 if (!SWIG_IsOK(ecode4)) {
17216 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileType_SetCommand" "', expected argument " "4"" of type '" "bool""'");
17217 }
17218 arg4 = static_cast< bool >(val4);
17219 }
17220 {
17221 PyThreadState* __tstate = wxPyBeginAllowThreads();
17222 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
17223 wxPyEndAllowThreads(__tstate);
17224 if (PyErr_Occurred()) SWIG_fail;
17225 }
17226 {
17227 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17228 }
17229 {
17230 if (temp2)
17231 delete arg2;
17232 }
17233 {
17234 if (temp3)
17235 delete arg3;
17236 }
17237 return resultobj;
17238 fail:
17239 {
17240 if (temp2)
17241 delete arg2;
17242 }
17243 {
17244 if (temp3)
17245 delete arg3;
17246 }
17247 return NULL;
17248 }
17249
17250
17251 SWIGINTERN PyObject *_wrap_FileType_SetDefaultIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17252 PyObject *resultobj = 0;
17253 wxFileType *arg1 = (wxFileType *) 0 ;
17254 wxString const &arg2_defvalue = wxPyEmptyString ;
17255 wxString *arg2 = (wxString *) &arg2_defvalue ;
17256 int arg3 = (int) 0 ;
17257 bool result;
17258 void *argp1 = 0 ;
17259 int res1 = 0 ;
17260 bool temp2 = false ;
17261 int val3 ;
17262 int ecode3 = 0 ;
17263 PyObject * obj0 = 0 ;
17264 PyObject * obj1 = 0 ;
17265 PyObject * obj2 = 0 ;
17266 char * kwnames[] = {
17267 (char *) "self",(char *) "cmd",(char *) "index", NULL
17268 };
17269
17270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17272 if (!SWIG_IsOK(res1)) {
17273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetDefaultIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
17274 }
17275 arg1 = reinterpret_cast< wxFileType * >(argp1);
17276 if (obj1) {
17277 {
17278 arg2 = wxString_in_helper(obj1);
17279 if (arg2 == NULL) SWIG_fail;
17280 temp2 = true;
17281 }
17282 }
17283 if (obj2) {
17284 ecode3 = SWIG_AsVal_int(obj2, &val3);
17285 if (!SWIG_IsOK(ecode3)) {
17286 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileType_SetDefaultIcon" "', expected argument " "3"" of type '" "int""'");
17287 }
17288 arg3 = static_cast< int >(val3);
17289 }
17290 {
17291 PyThreadState* __tstate = wxPyBeginAllowThreads();
17292 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
17293 wxPyEndAllowThreads(__tstate);
17294 if (PyErr_Occurred()) SWIG_fail;
17295 }
17296 {
17297 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17298 }
17299 {
17300 if (temp2)
17301 delete arg2;
17302 }
17303 return resultobj;
17304 fail:
17305 {
17306 if (temp2)
17307 delete arg2;
17308 }
17309 return NULL;
17310 }
17311
17312
17313 SWIGINTERN PyObject *_wrap_FileType_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17314 PyObject *resultobj = 0;
17315 wxFileType *arg1 = (wxFileType *) 0 ;
17316 bool result;
17317 void *argp1 = 0 ;
17318 int res1 = 0 ;
17319 PyObject *swig_obj[1] ;
17320
17321 if (!args) SWIG_fail;
17322 swig_obj[0] = args;
17323 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17324 if (!SWIG_IsOK(res1)) {
17325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_Unassociate" "', expected argument " "1"" of type '" "wxFileType *""'");
17326 }
17327 arg1 = reinterpret_cast< wxFileType * >(argp1);
17328 {
17329 PyThreadState* __tstate = wxPyBeginAllowThreads();
17330 result = (bool)(arg1)->Unassociate();
17331 wxPyEndAllowThreads(__tstate);
17332 if (PyErr_Occurred()) SWIG_fail;
17333 }
17334 {
17335 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17336 }
17337 return resultobj;
17338 fail:
17339 return NULL;
17340 }
17341
17342
17343 SWIGINTERN PyObject *_wrap_FileType_ExpandCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17344 PyObject *resultobj = 0;
17345 wxString *arg1 = 0 ;
17346 wxString *arg2 = 0 ;
17347 wxString const &arg3_defvalue = wxPyEmptyString ;
17348 wxString *arg3 = (wxString *) &arg3_defvalue ;
17349 wxString result;
17350 bool temp1 = false ;
17351 bool temp2 = false ;
17352 bool temp3 = false ;
17353 PyObject * obj0 = 0 ;
17354 PyObject * obj1 = 0 ;
17355 PyObject * obj2 = 0 ;
17356 char * kwnames[] = {
17357 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
17358 };
17359
17360 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17361 {
17362 arg1 = wxString_in_helper(obj0);
17363 if (arg1 == NULL) SWIG_fail;
17364 temp1 = true;
17365 }
17366 {
17367 arg2 = wxString_in_helper(obj1);
17368 if (arg2 == NULL) SWIG_fail;
17369 temp2 = true;
17370 }
17371 if (obj2) {
17372 {
17373 arg3 = wxString_in_helper(obj2);
17374 if (arg3 == NULL) SWIG_fail;
17375 temp3 = true;
17376 }
17377 }
17378 {
17379 PyThreadState* __tstate = wxPyBeginAllowThreads();
17380 result = wxFileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
17381 wxPyEndAllowThreads(__tstate);
17382 if (PyErr_Occurred()) SWIG_fail;
17383 }
17384 {
17385 #if wxUSE_UNICODE
17386 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17387 #else
17388 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17389 #endif
17390 }
17391 {
17392 if (temp1)
17393 delete arg1;
17394 }
17395 {
17396 if (temp2)
17397 delete arg2;
17398 }
17399 {
17400 if (temp3)
17401 delete arg3;
17402 }
17403 return resultobj;
17404 fail:
17405 {
17406 if (temp1)
17407 delete arg1;
17408 }
17409 {
17410 if (temp2)
17411 delete arg2;
17412 }
17413 {
17414 if (temp3)
17415 delete arg3;
17416 }
17417 return NULL;
17418 }
17419
17420
17421 SWIGINTERN PyObject *FileType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17422 PyObject *obj;
17423 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17424 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileType, SWIG_NewClientData(obj));
17425 return SWIG_Py_Void();
17426 }
17427
17428 SWIGINTERN PyObject *FileType_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17429 return SWIG_Python_InitShadowInstance(args);
17430 }
17431
17432 SWIGINTERN int TheMimeTypesManager_set(PyObject *) {
17433 SWIG_Error(SWIG_AttributeError,"Variable TheMimeTypesManager is read-only.");
17434 return 1;
17435 }
17436
17437
17438 SWIGINTERN PyObject *TheMimeTypesManager_get(void) {
17439 PyObject *pyobj = 0;
17440
17441 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0 );
17442 return pyobj;
17443 }
17444
17445
17446 SWIGINTERN PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17447 PyObject *resultobj = 0;
17448 wxString *arg1 = 0 ;
17449 wxString *arg2 = 0 ;
17450 bool result;
17451 bool temp1 = false ;
17452 bool temp2 = false ;
17453 PyObject * obj0 = 0 ;
17454 PyObject * obj1 = 0 ;
17455 char * kwnames[] = {
17456 (char *) "mimeType",(char *) "wildcard", NULL
17457 };
17458
17459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) SWIG_fail;
17460 {
17461 arg1 = wxString_in_helper(obj0);
17462 if (arg1 == NULL) SWIG_fail;
17463 temp1 = true;
17464 }
17465 {
17466 arg2 = wxString_in_helper(obj1);
17467 if (arg2 == NULL) SWIG_fail;
17468 temp2 = true;
17469 }
17470 {
17471 PyThreadState* __tstate = wxPyBeginAllowThreads();
17472 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
17473 wxPyEndAllowThreads(__tstate);
17474 if (PyErr_Occurred()) SWIG_fail;
17475 }
17476 {
17477 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17478 }
17479 {
17480 if (temp1)
17481 delete arg1;
17482 }
17483 {
17484 if (temp2)
17485 delete arg2;
17486 }
17487 return resultobj;
17488 fail:
17489 {
17490 if (temp1)
17491 delete arg1;
17492 }
17493 {
17494 if (temp2)
17495 delete arg2;
17496 }
17497 return NULL;
17498 }
17499
17500
17501 SWIGINTERN PyObject *_wrap_new_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17502 PyObject *resultobj = 0;
17503 wxMimeTypesManager *result = 0 ;
17504
17505 if (!SWIG_Python_UnpackTuple(args,"new_MimeTypesManager",0,0,0)) SWIG_fail;
17506 {
17507 PyThreadState* __tstate = wxPyBeginAllowThreads();
17508 result = (wxMimeTypesManager *)new wxMimeTypesManager();
17509 wxPyEndAllowThreads(__tstate);
17510 if (PyErr_Occurred()) SWIG_fail;
17511 }
17512 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_NEW | 0 );
17513 return resultobj;
17514 fail:
17515 return NULL;
17516 }
17517
17518
17519 SWIGINTERN PyObject *_wrap_MimeTypesManager_Initialize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17520 PyObject *resultobj = 0;
17521 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17522 int arg2 = (int) wxMAILCAP_ALL ;
17523 wxString const &arg3_defvalue = wxPyEmptyString ;
17524 wxString *arg3 = (wxString *) &arg3_defvalue ;
17525 void *argp1 = 0 ;
17526 int res1 = 0 ;
17527 int val2 ;
17528 int ecode2 = 0 ;
17529 bool temp3 = false ;
17530 PyObject * obj0 = 0 ;
17531 PyObject * obj1 = 0 ;
17532 PyObject * obj2 = 0 ;
17533 char * kwnames[] = {
17534 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
17535 };
17536
17537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17538 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17539 if (!SWIG_IsOK(res1)) {
17540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Initialize" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17541 }
17542 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17543 if (obj1) {
17544 ecode2 = SWIG_AsVal_int(obj1, &val2);
17545 if (!SWIG_IsOK(ecode2)) {
17546 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MimeTypesManager_Initialize" "', expected argument " "2"" of type '" "int""'");
17547 }
17548 arg2 = static_cast< int >(val2);
17549 }
17550 if (obj2) {
17551 {
17552 arg3 = wxString_in_helper(obj2);
17553 if (arg3 == NULL) SWIG_fail;
17554 temp3 = true;
17555 }
17556 }
17557 {
17558 PyThreadState* __tstate = wxPyBeginAllowThreads();
17559 (arg1)->Initialize(arg2,(wxString const &)*arg3);
17560 wxPyEndAllowThreads(__tstate);
17561 if (PyErr_Occurred()) SWIG_fail;
17562 }
17563 resultobj = SWIG_Py_Void();
17564 {
17565 if (temp3)
17566 delete arg3;
17567 }
17568 return resultobj;
17569 fail:
17570 {
17571 if (temp3)
17572 delete arg3;
17573 }
17574 return NULL;
17575 }
17576
17577
17578 SWIGINTERN PyObject *_wrap_MimeTypesManager_ClearData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17579 PyObject *resultobj = 0;
17580 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17581 void *argp1 = 0 ;
17582 int res1 = 0 ;
17583 PyObject *swig_obj[1] ;
17584
17585 if (!args) SWIG_fail;
17586 swig_obj[0] = args;
17587 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17588 if (!SWIG_IsOK(res1)) {
17589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ClearData" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17590 }
17591 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17592 {
17593 PyThreadState* __tstate = wxPyBeginAllowThreads();
17594 (arg1)->ClearData();
17595 wxPyEndAllowThreads(__tstate);
17596 if (PyErr_Occurred()) SWIG_fail;
17597 }
17598 resultobj = SWIG_Py_Void();
17599 return resultobj;
17600 fail:
17601 return NULL;
17602 }
17603
17604
17605 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17606 PyObject *resultobj = 0;
17607 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17608 wxString *arg2 = 0 ;
17609 wxFileType *result = 0 ;
17610 void *argp1 = 0 ;
17611 int res1 = 0 ;
17612 bool temp2 = false ;
17613 PyObject * obj0 = 0 ;
17614 PyObject * obj1 = 0 ;
17615 char * kwnames[] = {
17616 (char *) "self",(char *) "ext", NULL
17617 };
17618
17619 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) SWIG_fail;
17620 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17621 if (!SWIG_IsOK(res1)) {
17622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromExtension" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17623 }
17624 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17625 {
17626 arg2 = wxString_in_helper(obj1);
17627 if (arg2 == NULL) SWIG_fail;
17628 temp2 = true;
17629 }
17630 {
17631 PyThreadState* __tstate = wxPyBeginAllowThreads();
17632 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
17633 wxPyEndAllowThreads(__tstate);
17634 if (PyErr_Occurred()) SWIG_fail;
17635 }
17636 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
17637 {
17638 if (temp2)
17639 delete arg2;
17640 }
17641 return resultobj;
17642 fail:
17643 {
17644 if (temp2)
17645 delete arg2;
17646 }
17647 return NULL;
17648 }
17649
17650
17651 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17652 PyObject *resultobj = 0;
17653 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17654 wxString *arg2 = 0 ;
17655 wxFileType *result = 0 ;
17656 void *argp1 = 0 ;
17657 int res1 = 0 ;
17658 bool temp2 = false ;
17659 PyObject * obj0 = 0 ;
17660 PyObject * obj1 = 0 ;
17661 char * kwnames[] = {
17662 (char *) "self",(char *) "mimeType", NULL
17663 };
17664
17665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
17666 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17667 if (!SWIG_IsOK(res1)) {
17668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromMimeType" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17669 }
17670 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17671 {
17672 arg2 = wxString_in_helper(obj1);
17673 if (arg2 == NULL) SWIG_fail;
17674 temp2 = true;
17675 }
17676 {
17677 PyThreadState* __tstate = wxPyBeginAllowThreads();
17678 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
17679 wxPyEndAllowThreads(__tstate);
17680 if (PyErr_Occurred()) SWIG_fail;
17681 }
17682 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
17683 {
17684 if (temp2)
17685 delete arg2;
17686 }
17687 return resultobj;
17688 fail:
17689 {
17690 if (temp2)
17691 delete arg2;
17692 }
17693 return NULL;
17694 }
17695
17696
17697 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17698 PyObject *resultobj = 0;
17699 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17700 wxString *arg2 = 0 ;
17701 bool arg3 = (bool) false ;
17702 bool result;
17703 void *argp1 = 0 ;
17704 int res1 = 0 ;
17705 bool temp2 = false ;
17706 bool val3 ;
17707 int ecode3 = 0 ;
17708 PyObject * obj0 = 0 ;
17709 PyObject * obj1 = 0 ;
17710 PyObject * obj2 = 0 ;
17711 char * kwnames[] = {
17712 (char *) "self",(char *) "filename",(char *) "fallback", NULL
17713 };
17714
17715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17716 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17717 if (!SWIG_IsOK(res1)) {
17718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17719 }
17720 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17721 {
17722 arg2 = wxString_in_helper(obj1);
17723 if (arg2 == NULL) SWIG_fail;
17724 temp2 = true;
17725 }
17726 if (obj2) {
17727 ecode3 = SWIG_AsVal_bool(obj2, &val3);
17728 if (!SWIG_IsOK(ecode3)) {
17729 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "3"" of type '" "bool""'");
17730 }
17731 arg3 = static_cast< bool >(val3);
17732 }
17733 {
17734 PyThreadState* __tstate = wxPyBeginAllowThreads();
17735 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
17736 wxPyEndAllowThreads(__tstate);
17737 if (PyErr_Occurred()) SWIG_fail;
17738 }
17739 {
17740 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17741 }
17742 {
17743 if (temp2)
17744 delete arg2;
17745 }
17746 return resultobj;
17747 fail:
17748 {
17749 if (temp2)
17750 delete arg2;
17751 }
17752 return NULL;
17753 }
17754
17755
17756 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17757 PyObject *resultobj = 0;
17758 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17759 wxString *arg2 = 0 ;
17760 bool result;
17761 void *argp1 = 0 ;
17762 int res1 = 0 ;
17763 bool temp2 = false ;
17764 PyObject * obj0 = 0 ;
17765 PyObject * obj1 = 0 ;
17766 char * kwnames[] = {
17767 (char *) "self",(char *) "filename", NULL
17768 };
17769
17770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) SWIG_fail;
17771 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17772 if (!SWIG_IsOK(res1)) {
17773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMimeTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17774 }
17775 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17776 {
17777 arg2 = wxString_in_helper(obj1);
17778 if (arg2 == NULL) SWIG_fail;
17779 temp2 = true;
17780 }
17781 {
17782 PyThreadState* __tstate = wxPyBeginAllowThreads();
17783 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
17784 wxPyEndAllowThreads(__tstate);
17785 if (PyErr_Occurred()) SWIG_fail;
17786 }
17787 {
17788 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17789 }
17790 {
17791 if (temp2)
17792 delete arg2;
17793 }
17794 return resultobj;
17795 fail:
17796 {
17797 if (temp2)
17798 delete arg2;
17799 }
17800 return NULL;
17801 }
17802
17803
17804 SWIGINTERN PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17805 PyObject *resultobj = 0;
17806 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17807 PyObject *result = 0 ;
17808 void *argp1 = 0 ;
17809 int res1 = 0 ;
17810 PyObject *swig_obj[1] ;
17811
17812 if (!args) SWIG_fail;
17813 swig_obj[0] = args;
17814 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17815 if (!SWIG_IsOK(res1)) {
17816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_EnumAllFileTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17817 }
17818 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17819 {
17820 PyThreadState* __tstate = wxPyBeginAllowThreads();
17821 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
17822 wxPyEndAllowThreads(__tstate);
17823 if (PyErr_Occurred()) SWIG_fail;
17824 }
17825 resultobj = result;
17826 return resultobj;
17827 fail:
17828 return NULL;
17829 }
17830
17831
17832 SWIGINTERN PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17833 PyObject *resultobj = 0;
17834 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17835 wxFileTypeInfo *arg2 = 0 ;
17836 void *argp1 = 0 ;
17837 int res1 = 0 ;
17838 void *argp2 = 0 ;
17839 int res2 = 0 ;
17840 PyObject * obj0 = 0 ;
17841 PyObject * obj1 = 0 ;
17842 char * kwnames[] = {
17843 (char *) "self",(char *) "ft", NULL
17844 };
17845
17846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) SWIG_fail;
17847 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17848 if (!SWIG_IsOK(res1)) {
17849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17850 }
17851 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17852 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
17853 if (!SWIG_IsOK(res2)) {
17854 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
17855 }
17856 if (!argp2) {
17857 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
17858 }
17859 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
17860 {
17861 PyThreadState* __tstate = wxPyBeginAllowThreads();
17862 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
17863 wxPyEndAllowThreads(__tstate);
17864 if (PyErr_Occurred()) SWIG_fail;
17865 }
17866 resultobj = SWIG_Py_Void();
17867 return resultobj;
17868 fail:
17869 return NULL;
17870 }
17871
17872
17873 SWIGINTERN PyObject *_wrap_MimeTypesManager_Associate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17874 PyObject *resultobj = 0;
17875 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17876 wxFileTypeInfo *arg2 = 0 ;
17877 wxFileType *result = 0 ;
17878 void *argp1 = 0 ;
17879 int res1 = 0 ;
17880 void *argp2 = 0 ;
17881 int res2 = 0 ;
17882 PyObject * obj0 = 0 ;
17883 PyObject * obj1 = 0 ;
17884 char * kwnames[] = {
17885 (char *) "self",(char *) "ftInfo", NULL
17886 };
17887
17888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) SWIG_fail;
17889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17890 if (!SWIG_IsOK(res1)) {
17891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Associate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17892 }
17893 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17894 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
17895 if (!SWIG_IsOK(res2)) {
17896 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
17897 }
17898 if (!argp2) {
17899 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
17900 }
17901 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
17902 {
17903 PyThreadState* __tstate = wxPyBeginAllowThreads();
17904 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
17905 wxPyEndAllowThreads(__tstate);
17906 if (PyErr_Occurred()) SWIG_fail;
17907 }
17908 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
17909 return resultobj;
17910 fail:
17911 return NULL;
17912 }
17913
17914
17915 SWIGINTERN PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17916 PyObject *resultobj = 0;
17917 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17918 wxFileType *arg2 = (wxFileType *) 0 ;
17919 bool result;
17920 void *argp1 = 0 ;
17921 int res1 = 0 ;
17922 void *argp2 = 0 ;
17923 int res2 = 0 ;
17924 PyObject * obj0 = 0 ;
17925 PyObject * obj1 = 0 ;
17926 char * kwnames[] = {
17927 (char *) "self",(char *) "ft", NULL
17928 };
17929
17930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) SWIG_fail;
17931 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17932 if (!SWIG_IsOK(res1)) {
17933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17934 }
17935 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17936 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFileType, 0 | 0 );
17937 if (!SWIG_IsOK(res2)) {
17938 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "2"" of type '" "wxFileType *""'");
17939 }
17940 arg2 = reinterpret_cast< wxFileType * >(argp2);
17941 {
17942 PyThreadState* __tstate = wxPyBeginAllowThreads();
17943 result = (bool)(arg1)->Unassociate(arg2);
17944 wxPyEndAllowThreads(__tstate);
17945 if (PyErr_Occurred()) SWIG_fail;
17946 }
17947 {
17948 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17949 }
17950 return resultobj;
17951 fail:
17952 return NULL;
17953 }
17954
17955
17956 SWIGINTERN PyObject *_wrap_delete_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17957 PyObject *resultobj = 0;
17958 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17959 void *argp1 = 0 ;
17960 int res1 = 0 ;
17961 PyObject *swig_obj[1] ;
17962
17963 if (!args) SWIG_fail;
17964 swig_obj[0] = args;
17965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_DISOWN | 0 );
17966 if (!SWIG_IsOK(res1)) {
17967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MimeTypesManager" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17968 }
17969 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17970 {
17971 PyThreadState* __tstate = wxPyBeginAllowThreads();
17972 delete arg1;
17973
17974 wxPyEndAllowThreads(__tstate);
17975 if (PyErr_Occurred()) SWIG_fail;
17976 }
17977 resultobj = SWIG_Py_Void();
17978 return resultobj;
17979 fail:
17980 return NULL;
17981 }
17982
17983
17984 SWIGINTERN PyObject *MimeTypesManager_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17985 PyObject *obj;
17986 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17987 SWIG_TypeNewClientData(SWIGTYPE_p_wxMimeTypesManager, SWIG_NewClientData(obj));
17988 return SWIG_Py_Void();
17989 }
17990
17991 SWIGINTERN PyObject *MimeTypesManager_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17992 return SWIG_Python_InitShadowInstance(args);
17993 }
17994
17995 SWIGINTERN int ART_TOOLBAR_set(PyObject *) {
17996 SWIG_Error(SWIG_AttributeError,"Variable ART_TOOLBAR is read-only.");
17997 return 1;
17998 }
17999
18000
18001 SWIGINTERN PyObject *ART_TOOLBAR_get(void) {
18002 PyObject *pyobj = 0;
18003
18004 {
18005 #if wxUSE_UNICODE
18006 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
18007 #else
18008 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
18009 #endif
18010 }
18011 return pyobj;
18012 }
18013
18014
18015 SWIGINTERN int ART_MENU_set(PyObject *) {
18016 SWIG_Error(SWIG_AttributeError,"Variable ART_MENU is read-only.");
18017 return 1;
18018 }
18019
18020
18021 SWIGINTERN PyObject *ART_MENU_get(void) {
18022 PyObject *pyobj = 0;
18023
18024 {
18025 #if wxUSE_UNICODE
18026 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
18027 #else
18028 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
18029 #endif
18030 }
18031 return pyobj;
18032 }
18033
18034
18035 SWIGINTERN int ART_FRAME_ICON_set(PyObject *) {
18036 SWIG_Error(SWIG_AttributeError,"Variable ART_FRAME_ICON is read-only.");
18037 return 1;
18038 }
18039
18040
18041 SWIGINTERN PyObject *ART_FRAME_ICON_get(void) {
18042 PyObject *pyobj = 0;
18043
18044 {
18045 #if wxUSE_UNICODE
18046 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
18047 #else
18048 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
18049 #endif
18050 }
18051 return pyobj;
18052 }
18053
18054
18055 SWIGINTERN int ART_CMN_DIALOG_set(PyObject *) {
18056 SWIG_Error(SWIG_AttributeError,"Variable ART_CMN_DIALOG is read-only.");
18057 return 1;
18058 }
18059
18060
18061 SWIGINTERN PyObject *ART_CMN_DIALOG_get(void) {
18062 PyObject *pyobj = 0;
18063
18064 {
18065 #if wxUSE_UNICODE
18066 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
18067 #else
18068 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
18069 #endif
18070 }
18071 return pyobj;
18072 }
18073
18074
18075 SWIGINTERN int ART_HELP_BROWSER_set(PyObject *) {
18076 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BROWSER is read-only.");
18077 return 1;
18078 }
18079
18080
18081 SWIGINTERN PyObject *ART_HELP_BROWSER_get(void) {
18082 PyObject *pyobj = 0;
18083
18084 {
18085 #if wxUSE_UNICODE
18086 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
18087 #else
18088 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
18089 #endif
18090 }
18091 return pyobj;
18092 }
18093
18094
18095 SWIGINTERN int ART_MESSAGE_BOX_set(PyObject *) {
18096 SWIG_Error(SWIG_AttributeError,"Variable ART_MESSAGE_BOX is read-only.");
18097 return 1;
18098 }
18099
18100
18101 SWIGINTERN PyObject *ART_MESSAGE_BOX_get(void) {
18102 PyObject *pyobj = 0;
18103
18104 {
18105 #if wxUSE_UNICODE
18106 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
18107 #else
18108 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
18109 #endif
18110 }
18111 return pyobj;
18112 }
18113
18114
18115 SWIGINTERN int ART_BUTTON_set(PyObject *) {
18116 SWIG_Error(SWIG_AttributeError,"Variable ART_BUTTON is read-only.");
18117 return 1;
18118 }
18119
18120
18121 SWIGINTERN PyObject *ART_BUTTON_get(void) {
18122 PyObject *pyobj = 0;
18123
18124 {
18125 #if wxUSE_UNICODE
18126 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
18127 #else
18128 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
18129 #endif
18130 }
18131 return pyobj;
18132 }
18133
18134
18135 SWIGINTERN int ART_OTHER_set(PyObject *) {
18136 SWIG_Error(SWIG_AttributeError,"Variable ART_OTHER is read-only.");
18137 return 1;
18138 }
18139
18140
18141 SWIGINTERN PyObject *ART_OTHER_get(void) {
18142 PyObject *pyobj = 0;
18143
18144 {
18145 #if wxUSE_UNICODE
18146 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
18147 #else
18148 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
18149 #endif
18150 }
18151 return pyobj;
18152 }
18153
18154
18155 SWIGINTERN int ART_ADD_BOOKMARK_set(PyObject *) {
18156 SWIG_Error(SWIG_AttributeError,"Variable ART_ADD_BOOKMARK is read-only.");
18157 return 1;
18158 }
18159
18160
18161 SWIGINTERN PyObject *ART_ADD_BOOKMARK_get(void) {
18162 PyObject *pyobj = 0;
18163
18164 {
18165 #if wxUSE_UNICODE
18166 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
18167 #else
18168 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
18169 #endif
18170 }
18171 return pyobj;
18172 }
18173
18174
18175 SWIGINTERN int ART_DEL_BOOKMARK_set(PyObject *) {
18176 SWIG_Error(SWIG_AttributeError,"Variable ART_DEL_BOOKMARK is read-only.");
18177 return 1;
18178 }
18179
18180
18181 SWIGINTERN PyObject *ART_DEL_BOOKMARK_get(void) {
18182 PyObject *pyobj = 0;
18183
18184 {
18185 #if wxUSE_UNICODE
18186 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
18187 #else
18188 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
18189 #endif
18190 }
18191 return pyobj;
18192 }
18193
18194
18195 SWIGINTERN int ART_HELP_SIDE_PANEL_set(PyObject *) {
18196 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
18197 return 1;
18198 }
18199
18200
18201 SWIGINTERN PyObject *ART_HELP_SIDE_PANEL_get(void) {
18202 PyObject *pyobj = 0;
18203
18204 {
18205 #if wxUSE_UNICODE
18206 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
18207 #else
18208 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
18209 #endif
18210 }
18211 return pyobj;
18212 }
18213
18214
18215 SWIGINTERN int ART_HELP_SETTINGS_set(PyObject *) {
18216 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SETTINGS is read-only.");
18217 return 1;
18218 }
18219
18220
18221 SWIGINTERN PyObject *ART_HELP_SETTINGS_get(void) {
18222 PyObject *pyobj = 0;
18223
18224 {
18225 #if wxUSE_UNICODE
18226 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
18227 #else
18228 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
18229 #endif
18230 }
18231 return pyobj;
18232 }
18233
18234
18235 SWIGINTERN int ART_HELP_BOOK_set(PyObject *) {
18236 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BOOK is read-only.");
18237 return 1;
18238 }
18239
18240
18241 SWIGINTERN PyObject *ART_HELP_BOOK_get(void) {
18242 PyObject *pyobj = 0;
18243
18244 {
18245 #if wxUSE_UNICODE
18246 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
18247 #else
18248 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
18249 #endif
18250 }
18251 return pyobj;
18252 }
18253
18254
18255 SWIGINTERN int ART_HELP_FOLDER_set(PyObject *) {
18256 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_FOLDER is read-only.");
18257 return 1;
18258 }
18259
18260
18261 SWIGINTERN PyObject *ART_HELP_FOLDER_get(void) {
18262 PyObject *pyobj = 0;
18263
18264 {
18265 #if wxUSE_UNICODE
18266 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
18267 #else
18268 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
18269 #endif
18270 }
18271 return pyobj;
18272 }
18273
18274
18275 SWIGINTERN int ART_HELP_PAGE_set(PyObject *) {
18276 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_PAGE is read-only.");
18277 return 1;
18278 }
18279
18280
18281 SWIGINTERN PyObject *ART_HELP_PAGE_get(void) {
18282 PyObject *pyobj = 0;
18283
18284 {
18285 #if wxUSE_UNICODE
18286 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
18287 #else
18288 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
18289 #endif
18290 }
18291 return pyobj;
18292 }
18293
18294
18295 SWIGINTERN int ART_GO_BACK_set(PyObject *) {
18296 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_BACK is read-only.");
18297 return 1;
18298 }
18299
18300
18301 SWIGINTERN PyObject *ART_GO_BACK_get(void) {
18302 PyObject *pyobj = 0;
18303
18304 {
18305 #if wxUSE_UNICODE
18306 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
18307 #else
18308 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
18309 #endif
18310 }
18311 return pyobj;
18312 }
18313
18314
18315 SWIGINTERN int ART_GO_FORWARD_set(PyObject *) {
18316 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_FORWARD is read-only.");
18317 return 1;
18318 }
18319
18320
18321 SWIGINTERN PyObject *ART_GO_FORWARD_get(void) {
18322 PyObject *pyobj = 0;
18323
18324 {
18325 #if wxUSE_UNICODE
18326 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
18327 #else
18328 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
18329 #endif
18330 }
18331 return pyobj;
18332 }
18333
18334
18335 SWIGINTERN int ART_GO_UP_set(PyObject *) {
18336 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_UP is read-only.");
18337 return 1;
18338 }
18339
18340
18341 SWIGINTERN PyObject *ART_GO_UP_get(void) {
18342 PyObject *pyobj = 0;
18343
18344 {
18345 #if wxUSE_UNICODE
18346 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
18347 #else
18348 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
18349 #endif
18350 }
18351 return pyobj;
18352 }
18353
18354
18355 SWIGINTERN int ART_GO_DOWN_set(PyObject *) {
18356 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DOWN is read-only.");
18357 return 1;
18358 }
18359
18360
18361 SWIGINTERN PyObject *ART_GO_DOWN_get(void) {
18362 PyObject *pyobj = 0;
18363
18364 {
18365 #if wxUSE_UNICODE
18366 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
18367 #else
18368 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
18369 #endif
18370 }
18371 return pyobj;
18372 }
18373
18374
18375 SWIGINTERN int ART_GO_TO_PARENT_set(PyObject *) {
18376 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_TO_PARENT is read-only.");
18377 return 1;
18378 }
18379
18380
18381 SWIGINTERN PyObject *ART_GO_TO_PARENT_get(void) {
18382 PyObject *pyobj = 0;
18383
18384 {
18385 #if wxUSE_UNICODE
18386 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
18387 #else
18388 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
18389 #endif
18390 }
18391 return pyobj;
18392 }
18393
18394
18395 SWIGINTERN int ART_GO_HOME_set(PyObject *) {
18396 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_HOME is read-only.");
18397 return 1;
18398 }
18399
18400
18401 SWIGINTERN PyObject *ART_GO_HOME_get(void) {
18402 PyObject *pyobj = 0;
18403
18404 {
18405 #if wxUSE_UNICODE
18406 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
18407 #else
18408 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
18409 #endif
18410 }
18411 return pyobj;
18412 }
18413
18414
18415 SWIGINTERN int ART_FILE_OPEN_set(PyObject *) {
18416 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_OPEN is read-only.");
18417 return 1;
18418 }
18419
18420
18421 SWIGINTERN PyObject *ART_FILE_OPEN_get(void) {
18422 PyObject *pyobj = 0;
18423
18424 {
18425 #if wxUSE_UNICODE
18426 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
18427 #else
18428 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
18429 #endif
18430 }
18431 return pyobj;
18432 }
18433
18434
18435 SWIGINTERN int ART_FILE_SAVE_set(PyObject *) {
18436 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE is read-only.");
18437 return 1;
18438 }
18439
18440
18441 SWIGINTERN PyObject *ART_FILE_SAVE_get(void) {
18442 PyObject *pyobj = 0;
18443
18444 {
18445 #if wxUSE_UNICODE
18446 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
18447 #else
18448 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
18449 #endif
18450 }
18451 return pyobj;
18452 }
18453
18454
18455 SWIGINTERN int ART_FILE_SAVE_AS_set(PyObject *) {
18456 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE_AS is read-only.");
18457 return 1;
18458 }
18459
18460
18461 SWIGINTERN PyObject *ART_FILE_SAVE_AS_get(void) {
18462 PyObject *pyobj = 0;
18463
18464 {
18465 #if wxUSE_UNICODE
18466 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
18467 #else
18468 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
18469 #endif
18470 }
18471 return pyobj;
18472 }
18473
18474
18475 SWIGINTERN int ART_PRINT_set(PyObject *) {
18476 SWIG_Error(SWIG_AttributeError,"Variable ART_PRINT is read-only.");
18477 return 1;
18478 }
18479
18480
18481 SWIGINTERN PyObject *ART_PRINT_get(void) {
18482 PyObject *pyobj = 0;
18483
18484 {
18485 #if wxUSE_UNICODE
18486 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
18487 #else
18488 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
18489 #endif
18490 }
18491 return pyobj;
18492 }
18493
18494
18495 SWIGINTERN int ART_HELP_set(PyObject *) {
18496 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP is read-only.");
18497 return 1;
18498 }
18499
18500
18501 SWIGINTERN PyObject *ART_HELP_get(void) {
18502 PyObject *pyobj = 0;
18503
18504 {
18505 #if wxUSE_UNICODE
18506 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
18507 #else
18508 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
18509 #endif
18510 }
18511 return pyobj;
18512 }
18513
18514
18515 SWIGINTERN int ART_TIP_set(PyObject *) {
18516 SWIG_Error(SWIG_AttributeError,"Variable ART_TIP is read-only.");
18517 return 1;
18518 }
18519
18520
18521 SWIGINTERN PyObject *ART_TIP_get(void) {
18522 PyObject *pyobj = 0;
18523
18524 {
18525 #if wxUSE_UNICODE
18526 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
18527 #else
18528 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
18529 #endif
18530 }
18531 return pyobj;
18532 }
18533
18534
18535 SWIGINTERN int ART_REPORT_VIEW_set(PyObject *) {
18536 SWIG_Error(SWIG_AttributeError,"Variable ART_REPORT_VIEW is read-only.");
18537 return 1;
18538 }
18539
18540
18541 SWIGINTERN PyObject *ART_REPORT_VIEW_get(void) {
18542 PyObject *pyobj = 0;
18543
18544 {
18545 #if wxUSE_UNICODE
18546 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
18547 #else
18548 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
18549 #endif
18550 }
18551 return pyobj;
18552 }
18553
18554
18555 SWIGINTERN int ART_LIST_VIEW_set(PyObject *) {
18556 SWIG_Error(SWIG_AttributeError,"Variable ART_LIST_VIEW is read-only.");
18557 return 1;
18558 }
18559
18560
18561 SWIGINTERN PyObject *ART_LIST_VIEW_get(void) {
18562 PyObject *pyobj = 0;
18563
18564 {
18565 #if wxUSE_UNICODE
18566 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
18567 #else
18568 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
18569 #endif
18570 }
18571 return pyobj;
18572 }
18573
18574
18575 SWIGINTERN int ART_NEW_DIR_set(PyObject *) {
18576 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW_DIR is read-only.");
18577 return 1;
18578 }
18579
18580
18581 SWIGINTERN PyObject *ART_NEW_DIR_get(void) {
18582 PyObject *pyobj = 0;
18583
18584 {
18585 #if wxUSE_UNICODE
18586 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
18587 #else
18588 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
18589 #endif
18590 }
18591 return pyobj;
18592 }
18593
18594
18595 SWIGINTERN int ART_HARDDISK_set(PyObject *) {
18596 SWIG_Error(SWIG_AttributeError,"Variable ART_HARDDISK is read-only.");
18597 return 1;
18598 }
18599
18600
18601 SWIGINTERN PyObject *ART_HARDDISK_get(void) {
18602 PyObject *pyobj = 0;
18603
18604 {
18605 #if wxUSE_UNICODE
18606 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
18607 #else
18608 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
18609 #endif
18610 }
18611 return pyobj;
18612 }
18613
18614
18615 SWIGINTERN int ART_FLOPPY_set(PyObject *) {
18616 SWIG_Error(SWIG_AttributeError,"Variable ART_FLOPPY is read-only.");
18617 return 1;
18618 }
18619
18620
18621 SWIGINTERN PyObject *ART_FLOPPY_get(void) {
18622 PyObject *pyobj = 0;
18623
18624 {
18625 #if wxUSE_UNICODE
18626 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
18627 #else
18628 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
18629 #endif
18630 }
18631 return pyobj;
18632 }
18633
18634
18635 SWIGINTERN int ART_CDROM_set(PyObject *) {
18636 SWIG_Error(SWIG_AttributeError,"Variable ART_CDROM is read-only.");
18637 return 1;
18638 }
18639
18640
18641 SWIGINTERN PyObject *ART_CDROM_get(void) {
18642 PyObject *pyobj = 0;
18643
18644 {
18645 #if wxUSE_UNICODE
18646 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
18647 #else
18648 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
18649 #endif
18650 }
18651 return pyobj;
18652 }
18653
18654
18655 SWIGINTERN int ART_REMOVABLE_set(PyObject *) {
18656 SWIG_Error(SWIG_AttributeError,"Variable ART_REMOVABLE is read-only.");
18657 return 1;
18658 }
18659
18660
18661 SWIGINTERN PyObject *ART_REMOVABLE_get(void) {
18662 PyObject *pyobj = 0;
18663
18664 {
18665 #if wxUSE_UNICODE
18666 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
18667 #else
18668 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
18669 #endif
18670 }
18671 return pyobj;
18672 }
18673
18674
18675 SWIGINTERN int ART_FOLDER_set(PyObject *) {
18676 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER is read-only.");
18677 return 1;
18678 }
18679
18680
18681 SWIGINTERN PyObject *ART_FOLDER_get(void) {
18682 PyObject *pyobj = 0;
18683
18684 {
18685 #if wxUSE_UNICODE
18686 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
18687 #else
18688 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
18689 #endif
18690 }
18691 return pyobj;
18692 }
18693
18694
18695 SWIGINTERN int ART_FOLDER_OPEN_set(PyObject *) {
18696 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER_OPEN is read-only.");
18697 return 1;
18698 }
18699
18700
18701 SWIGINTERN PyObject *ART_FOLDER_OPEN_get(void) {
18702 PyObject *pyobj = 0;
18703
18704 {
18705 #if wxUSE_UNICODE
18706 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
18707 #else
18708 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
18709 #endif
18710 }
18711 return pyobj;
18712 }
18713
18714
18715 SWIGINTERN int ART_GO_DIR_UP_set(PyObject *) {
18716 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DIR_UP is read-only.");
18717 return 1;
18718 }
18719
18720
18721 SWIGINTERN PyObject *ART_GO_DIR_UP_get(void) {
18722 PyObject *pyobj = 0;
18723
18724 {
18725 #if wxUSE_UNICODE
18726 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
18727 #else
18728 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
18729 #endif
18730 }
18731 return pyobj;
18732 }
18733
18734
18735 SWIGINTERN int ART_EXECUTABLE_FILE_set(PyObject *) {
18736 SWIG_Error(SWIG_AttributeError,"Variable ART_EXECUTABLE_FILE is read-only.");
18737 return 1;
18738 }
18739
18740
18741 SWIGINTERN PyObject *ART_EXECUTABLE_FILE_get(void) {
18742 PyObject *pyobj = 0;
18743
18744 {
18745 #if wxUSE_UNICODE
18746 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
18747 #else
18748 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
18749 #endif
18750 }
18751 return pyobj;
18752 }
18753
18754
18755 SWIGINTERN int ART_NORMAL_FILE_set(PyObject *) {
18756 SWIG_Error(SWIG_AttributeError,"Variable ART_NORMAL_FILE is read-only.");
18757 return 1;
18758 }
18759
18760
18761 SWIGINTERN PyObject *ART_NORMAL_FILE_get(void) {
18762 PyObject *pyobj = 0;
18763
18764 {
18765 #if wxUSE_UNICODE
18766 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
18767 #else
18768 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
18769 #endif
18770 }
18771 return pyobj;
18772 }
18773
18774
18775 SWIGINTERN int ART_TICK_MARK_set(PyObject *) {
18776 SWIG_Error(SWIG_AttributeError,"Variable ART_TICK_MARK is read-only.");
18777 return 1;
18778 }
18779
18780
18781 SWIGINTERN PyObject *ART_TICK_MARK_get(void) {
18782 PyObject *pyobj = 0;
18783
18784 {
18785 #if wxUSE_UNICODE
18786 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
18787 #else
18788 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
18789 #endif
18790 }
18791 return pyobj;
18792 }
18793
18794
18795 SWIGINTERN int ART_CROSS_MARK_set(PyObject *) {
18796 SWIG_Error(SWIG_AttributeError,"Variable ART_CROSS_MARK is read-only.");
18797 return 1;
18798 }
18799
18800
18801 SWIGINTERN PyObject *ART_CROSS_MARK_get(void) {
18802 PyObject *pyobj = 0;
18803
18804 {
18805 #if wxUSE_UNICODE
18806 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
18807 #else
18808 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
18809 #endif
18810 }
18811 return pyobj;
18812 }
18813
18814
18815 SWIGINTERN int ART_ERROR_set(PyObject *) {
18816 SWIG_Error(SWIG_AttributeError,"Variable ART_ERROR is read-only.");
18817 return 1;
18818 }
18819
18820
18821 SWIGINTERN PyObject *ART_ERROR_get(void) {
18822 PyObject *pyobj = 0;
18823
18824 {
18825 #if wxUSE_UNICODE
18826 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
18827 #else
18828 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
18829 #endif
18830 }
18831 return pyobj;
18832 }
18833
18834
18835 SWIGINTERN int ART_QUESTION_set(PyObject *) {
18836 SWIG_Error(SWIG_AttributeError,"Variable ART_QUESTION is read-only.");
18837 return 1;
18838 }
18839
18840
18841 SWIGINTERN PyObject *ART_QUESTION_get(void) {
18842 PyObject *pyobj = 0;
18843
18844 {
18845 #if wxUSE_UNICODE
18846 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
18847 #else
18848 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
18849 #endif
18850 }
18851 return pyobj;
18852 }
18853
18854
18855 SWIGINTERN int ART_WARNING_set(PyObject *) {
18856 SWIG_Error(SWIG_AttributeError,"Variable ART_WARNING is read-only.");
18857 return 1;
18858 }
18859
18860
18861 SWIGINTERN PyObject *ART_WARNING_get(void) {
18862 PyObject *pyobj = 0;
18863
18864 {
18865 #if wxUSE_UNICODE
18866 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
18867 #else
18868 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
18869 #endif
18870 }
18871 return pyobj;
18872 }
18873
18874
18875 SWIGINTERN int ART_INFORMATION_set(PyObject *) {
18876 SWIG_Error(SWIG_AttributeError,"Variable ART_INFORMATION is read-only.");
18877 return 1;
18878 }
18879
18880
18881 SWIGINTERN PyObject *ART_INFORMATION_get(void) {
18882 PyObject *pyobj = 0;
18883
18884 {
18885 #if wxUSE_UNICODE
18886 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
18887 #else
18888 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
18889 #endif
18890 }
18891 return pyobj;
18892 }
18893
18894
18895 SWIGINTERN int ART_MISSING_IMAGE_set(PyObject *) {
18896 SWIG_Error(SWIG_AttributeError,"Variable ART_MISSING_IMAGE is read-only.");
18897 return 1;
18898 }
18899
18900
18901 SWIGINTERN PyObject *ART_MISSING_IMAGE_get(void) {
18902 PyObject *pyobj = 0;
18903
18904 {
18905 #if wxUSE_UNICODE
18906 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
18907 #else
18908 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
18909 #endif
18910 }
18911 return pyobj;
18912 }
18913
18914
18915 SWIGINTERN int ART_COPY_set(PyObject *) {
18916 SWIG_Error(SWIG_AttributeError,"Variable ART_COPY is read-only.");
18917 return 1;
18918 }
18919
18920
18921 SWIGINTERN PyObject *ART_COPY_get(void) {
18922 PyObject *pyobj = 0;
18923
18924 {
18925 #if wxUSE_UNICODE
18926 pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
18927 #else
18928 pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
18929 #endif
18930 }
18931 return pyobj;
18932 }
18933
18934
18935 SWIGINTERN int ART_CUT_set(PyObject *) {
18936 SWIG_Error(SWIG_AttributeError,"Variable ART_CUT is read-only.");
18937 return 1;
18938 }
18939
18940
18941 SWIGINTERN PyObject *ART_CUT_get(void) {
18942 PyObject *pyobj = 0;
18943
18944 {
18945 #if wxUSE_UNICODE
18946 pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
18947 #else
18948 pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
18949 #endif
18950 }
18951 return pyobj;
18952 }
18953
18954
18955 SWIGINTERN int ART_PASTE_set(PyObject *) {
18956 SWIG_Error(SWIG_AttributeError,"Variable ART_PASTE is read-only.");
18957 return 1;
18958 }
18959
18960
18961 SWIGINTERN PyObject *ART_PASTE_get(void) {
18962 PyObject *pyobj = 0;
18963
18964 {
18965 #if wxUSE_UNICODE
18966 pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
18967 #else
18968 pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
18969 #endif
18970 }
18971 return pyobj;
18972 }
18973
18974
18975 SWIGINTERN int ART_DELETE_set(PyObject *) {
18976 SWIG_Error(SWIG_AttributeError,"Variable ART_DELETE is read-only.");
18977 return 1;
18978 }
18979
18980
18981 SWIGINTERN PyObject *ART_DELETE_get(void) {
18982 PyObject *pyobj = 0;
18983
18984 {
18985 #if wxUSE_UNICODE
18986 pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
18987 #else
18988 pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
18989 #endif
18990 }
18991 return pyobj;
18992 }
18993
18994
18995 SWIGINTERN int ART_NEW_set(PyObject *) {
18996 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW is read-only.");
18997 return 1;
18998 }
18999
19000
19001 SWIGINTERN PyObject *ART_NEW_get(void) {
19002 PyObject *pyobj = 0;
19003
19004 {
19005 #if wxUSE_UNICODE
19006 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
19007 #else
19008 pyobj = PyString_FromStringAndSize((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
19009 #endif
19010 }
19011 return pyobj;
19012 }
19013
19014
19015 SWIGINTERN int ART_UNDO_set(PyObject *) {
19016 SWIG_Error(SWIG_AttributeError,"Variable ART_UNDO is read-only.");
19017 return 1;
19018 }
19019
19020
19021 SWIGINTERN PyObject *ART_UNDO_get(void) {
19022 PyObject *pyobj = 0;
19023
19024 {
19025 #if wxUSE_UNICODE
19026 pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
19027 #else
19028 pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
19029 #endif
19030 }
19031 return pyobj;
19032 }
19033
19034
19035 SWIGINTERN int ART_REDO_set(PyObject *) {
19036 SWIG_Error(SWIG_AttributeError,"Variable ART_REDO is read-only.");
19037 return 1;
19038 }
19039
19040
19041 SWIGINTERN PyObject *ART_REDO_get(void) {
19042 PyObject *pyobj = 0;
19043
19044 {
19045 #if wxUSE_UNICODE
19046 pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
19047 #else
19048 pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
19049 #endif
19050 }
19051 return pyobj;
19052 }
19053
19054
19055 SWIGINTERN int ART_QUIT_set(PyObject *) {
19056 SWIG_Error(SWIG_AttributeError,"Variable ART_QUIT is read-only.");
19057 return 1;
19058 }
19059
19060
19061 SWIGINTERN PyObject *ART_QUIT_get(void) {
19062 PyObject *pyobj = 0;
19063
19064 {
19065 #if wxUSE_UNICODE
19066 pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
19067 #else
19068 pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
19069 #endif
19070 }
19071 return pyobj;
19072 }
19073
19074
19075 SWIGINTERN int ART_FIND_set(PyObject *) {
19076 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND is read-only.");
19077 return 1;
19078 }
19079
19080
19081 SWIGINTERN PyObject *ART_FIND_get(void) {
19082 PyObject *pyobj = 0;
19083
19084 {
19085 #if wxUSE_UNICODE
19086 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
19087 #else
19088 pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
19089 #endif
19090 }
19091 return pyobj;
19092 }
19093
19094
19095 SWIGINTERN int ART_FIND_AND_REPLACE_set(PyObject *) {
19096 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND_AND_REPLACE is read-only.");
19097 return 1;
19098 }
19099
19100
19101 SWIGINTERN PyObject *ART_FIND_AND_REPLACE_get(void) {
19102 PyObject *pyobj = 0;
19103
19104 {
19105 #if wxUSE_UNICODE
19106 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
19107 #else
19108 pyobj = PyString_FromStringAndSize((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
19109 #endif
19110 }
19111 return pyobj;
19112 }
19113
19114
19115 SWIGINTERN PyObject *_wrap_new_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19116 PyObject *resultobj = 0;
19117 wxPyArtProvider *result = 0 ;
19118
19119 if (!SWIG_Python_UnpackTuple(args,"new_ArtProvider",0,0,0)) SWIG_fail;
19120 {
19121 if (!wxPyCheckForApp()) SWIG_fail;
19122 PyThreadState* __tstate = wxPyBeginAllowThreads();
19123 result = (wxPyArtProvider *)new wxPyArtProvider();
19124 wxPyEndAllowThreads(__tstate);
19125 if (PyErr_Occurred()) SWIG_fail;
19126 }
19127 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_NEW | 0 );
19128 return resultobj;
19129 fail:
19130 return NULL;
19131 }
19132
19133
19134 SWIGINTERN PyObject *_wrap_delete_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19135 PyObject *resultobj = 0;
19136 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19137 void *argp1 = 0 ;
19138 int res1 = 0 ;
19139 PyObject *swig_obj[1] ;
19140
19141 if (!args) SWIG_fail;
19142 swig_obj[0] = args;
19143 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
19144 if (!SWIG_IsOK(res1)) {
19145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArtProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19146 }
19147 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
19148 {
19149 PyThreadState* __tstate = wxPyBeginAllowThreads();
19150 delete arg1;
19151
19152 wxPyEndAllowThreads(__tstate);
19153 if (PyErr_Occurred()) SWIG_fail;
19154 }
19155 resultobj = SWIG_Py_Void();
19156 return resultobj;
19157 fail:
19158 return NULL;
19159 }
19160
19161
19162 SWIGINTERN PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19163 PyObject *resultobj = 0;
19164 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19165 PyObject *arg2 = (PyObject *) 0 ;
19166 PyObject *arg3 = (PyObject *) 0 ;
19167 void *argp1 = 0 ;
19168 int res1 = 0 ;
19169 PyObject * obj0 = 0 ;
19170 PyObject * obj1 = 0 ;
19171 PyObject * obj2 = 0 ;
19172 char * kwnames[] = {
19173 (char *) "self",(char *) "self",(char *) "_class", NULL
19174 };
19175
19176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
19178 if (!SWIG_IsOK(res1)) {
19179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19180 }
19181 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
19182 arg2 = obj1;
19183 arg3 = obj2;
19184 {
19185 PyThreadState* __tstate = wxPyBeginAllowThreads();
19186 (arg1)->_setCallbackInfo(arg2,arg3);
19187 wxPyEndAllowThreads(__tstate);
19188 if (PyErr_Occurred()) SWIG_fail;
19189 }
19190 resultobj = SWIG_Py_Void();
19191 return resultobj;
19192 fail:
19193 return NULL;
19194 }
19195
19196
19197 SWIGINTERN PyObject *_wrap_ArtProvider_PushProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19198 PyObject *resultobj = 0;
19199 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19200 int res1 = 0 ;
19201 PyObject * obj0 = 0 ;
19202 char * kwnames[] = {
19203 (char *) "provider", NULL
19204 };
19205
19206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_PushProvider",kwnames,&obj0)) SWIG_fail;
19207 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
19208 if (!SWIG_IsOK(res1)) {
19209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_PushProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19210 }
19211 {
19212 PyThreadState* __tstate = wxPyBeginAllowThreads();
19213 wxPyArtProvider::PushProvider(arg1);
19214 wxPyEndAllowThreads(__tstate);
19215 if (PyErr_Occurred()) SWIG_fail;
19216 }
19217 resultobj = SWIG_Py_Void();
19218 return resultobj;
19219 fail:
19220 return NULL;
19221 }
19222
19223
19224 SWIGINTERN PyObject *_wrap_ArtProvider_PopProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19225 PyObject *resultobj = 0;
19226 bool result;
19227
19228 if (!SWIG_Python_UnpackTuple(args,"ArtProvider_PopProvider",0,0,0)) SWIG_fail;
19229 {
19230 PyThreadState* __tstate = wxPyBeginAllowThreads();
19231 result = (bool)wxPyArtProvider::PopProvider();
19232 wxPyEndAllowThreads(__tstate);
19233 if (PyErr_Occurred()) SWIG_fail;
19234 }
19235 {
19236 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19237 }
19238 return resultobj;
19239 fail:
19240 return NULL;
19241 }
19242
19243
19244 SWIGINTERN PyObject *_wrap_ArtProvider_RemoveProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19245 PyObject *resultobj = 0;
19246 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19247 bool result;
19248 void *argp1 = 0 ;
19249 int res1 = 0 ;
19250 PyObject * obj0 = 0 ;
19251 char * kwnames[] = {
19252 (char *) "provider", NULL
19253 };
19254
19255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_RemoveProvider",kwnames,&obj0)) SWIG_fail;
19256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
19257 if (!SWIG_IsOK(res1)) {
19258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_RemoveProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19259 }
19260 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
19261 {
19262 PyThreadState* __tstate = wxPyBeginAllowThreads();
19263 result = (bool)wxPyArtProvider::RemoveProvider(arg1);
19264 wxPyEndAllowThreads(__tstate);
19265 if (PyErr_Occurred()) SWIG_fail;
19266 }
19267 {
19268 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19269 }
19270 return resultobj;
19271 fail:
19272 return NULL;
19273 }
19274
19275
19276 SWIGINTERN PyObject *_wrap_ArtProvider_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19277 PyObject *resultobj = 0;
19278 wxString *arg1 = 0 ;
19279 wxString const &arg2_defvalue = wxPyART_OTHER ;
19280 wxString *arg2 = (wxString *) &arg2_defvalue ;
19281 wxSize const &arg3_defvalue = wxDefaultSize ;
19282 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
19283 wxBitmap result;
19284 bool temp1 = false ;
19285 bool temp2 = false ;
19286 wxSize temp3 ;
19287 PyObject * obj0 = 0 ;
19288 PyObject * obj1 = 0 ;
19289 PyObject * obj2 = 0 ;
19290 char * kwnames[] = {
19291 (char *) "id",(char *) "client",(char *) "size", NULL
19292 };
19293
19294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19295 {
19296 arg1 = wxString_in_helper(obj0);
19297 if (arg1 == NULL) SWIG_fail;
19298 temp1 = true;
19299 }
19300 if (obj1) {
19301 {
19302 arg2 = wxString_in_helper(obj1);
19303 if (arg2 == NULL) SWIG_fail;
19304 temp2 = true;
19305 }
19306 }
19307 if (obj2) {
19308 {
19309 arg3 = &temp3;
19310 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
19311 }
19312 }
19313 {
19314 if (!wxPyCheckForApp()) SWIG_fail;
19315 PyThreadState* __tstate = wxPyBeginAllowThreads();
19316 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
19317 wxPyEndAllowThreads(__tstate);
19318 if (PyErr_Occurred()) SWIG_fail;
19319 }
19320 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
19321 {
19322 if (temp1)
19323 delete arg1;
19324 }
19325 {
19326 if (temp2)
19327 delete arg2;
19328 }
19329 return resultobj;
19330 fail:
19331 {
19332 if (temp1)
19333 delete arg1;
19334 }
19335 {
19336 if (temp2)
19337 delete arg2;
19338 }
19339 return NULL;
19340 }
19341
19342
19343 SWIGINTERN PyObject *_wrap_ArtProvider_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19344 PyObject *resultobj = 0;
19345 wxString *arg1 = 0 ;
19346 wxString const &arg2_defvalue = wxPyART_OTHER ;
19347 wxString *arg2 = (wxString *) &arg2_defvalue ;
19348 wxSize const &arg3_defvalue = wxDefaultSize ;
19349 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
19350 wxIcon result;
19351 bool temp1 = false ;
19352 bool temp2 = false ;
19353 wxSize temp3 ;
19354 PyObject * obj0 = 0 ;
19355 PyObject * obj1 = 0 ;
19356 PyObject * obj2 = 0 ;
19357 char * kwnames[] = {
19358 (char *) "id",(char *) "client",(char *) "size", NULL
19359 };
19360
19361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19362 {
19363 arg1 = wxString_in_helper(obj0);
19364 if (arg1 == NULL) SWIG_fail;
19365 temp1 = true;
19366 }
19367 if (obj1) {
19368 {
19369 arg2 = wxString_in_helper(obj1);
19370 if (arg2 == NULL) SWIG_fail;
19371 temp2 = true;
19372 }
19373 }
19374 if (obj2) {
19375 {
19376 arg3 = &temp3;
19377 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
19378 }
19379 }
19380 {
19381 if (!wxPyCheckForApp()) SWIG_fail;
19382 PyThreadState* __tstate = wxPyBeginAllowThreads();
19383 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
19384 wxPyEndAllowThreads(__tstate);
19385 if (PyErr_Occurred()) SWIG_fail;
19386 }
19387 resultobj = SWIG_NewPointerObj((new wxIcon(static_cast< const wxIcon& >(result))), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
19388 {
19389 if (temp1)
19390 delete arg1;
19391 }
19392 {
19393 if (temp2)
19394 delete arg2;
19395 }
19396 return resultobj;
19397 fail:
19398 {
19399 if (temp1)
19400 delete arg1;
19401 }
19402 {
19403 if (temp2)
19404 delete arg2;
19405 }
19406 return NULL;
19407 }
19408
19409
19410 SWIGINTERN PyObject *_wrap_ArtProvider_GetSizeHint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19411 PyObject *resultobj = 0;
19412 wxString *arg1 = 0 ;
19413 bool arg2 = (bool) false ;
19414 wxSize result;
19415 bool temp1 = false ;
19416 bool val2 ;
19417 int ecode2 = 0 ;
19418 PyObject * obj0 = 0 ;
19419 PyObject * obj1 = 0 ;
19420 char * kwnames[] = {
19421 (char *) "client",(char *) "platform_dependent", NULL
19422 };
19423
19424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ArtProvider_GetSizeHint",kwnames,&obj0,&obj1)) SWIG_fail;
19425 {
19426 arg1 = wxString_in_helper(obj0);
19427 if (arg1 == NULL) SWIG_fail;
19428 temp1 = true;
19429 }
19430 if (obj1) {
19431 ecode2 = SWIG_AsVal_bool(obj1, &val2);
19432 if (!SWIG_IsOK(ecode2)) {
19433 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ArtProvider_GetSizeHint" "', expected argument " "2"" of type '" "bool""'");
19434 }
19435 arg2 = static_cast< bool >(val2);
19436 }
19437 {
19438 PyThreadState* __tstate = wxPyBeginAllowThreads();
19439 result = wxPyArtProvider::GetSizeHint((wxString const &)*arg1,arg2);
19440 wxPyEndAllowThreads(__tstate);
19441 if (PyErr_Occurred()) SWIG_fail;
19442 }
19443 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
19444 {
19445 if (temp1)
19446 delete arg1;
19447 }
19448 return resultobj;
19449 fail:
19450 {
19451 if (temp1)
19452 delete arg1;
19453 }
19454 return NULL;
19455 }
19456
19457
19458 SWIGINTERN PyObject *_wrap_ArtProvider_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19459 PyObject *resultobj = 0;
19460 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19461 void *argp1 = 0 ;
19462 int res1 = 0 ;
19463 PyObject *swig_obj[1] ;
19464
19465 if (!args) SWIG_fail;
19466 swig_obj[0] = args;
19467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
19468 if (!SWIG_IsOK(res1)) {
19469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Destroy" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19470 }
19471 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
19472 {
19473 PyThreadState* __tstate = wxPyBeginAllowThreads();
19474 wxPyArtProvider_Destroy(arg1);
19475 wxPyEndAllowThreads(__tstate);
19476 if (PyErr_Occurred()) SWIG_fail;
19477 }
19478 resultobj = SWIG_Py_Void();
19479 return resultobj;
19480 fail:
19481 return NULL;
19482 }
19483
19484
19485 SWIGINTERN PyObject *ArtProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19486 PyObject *obj;
19487 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19488 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyArtProvider, SWIG_NewClientData(obj));
19489 return SWIG_Py_Void();
19490 }
19491
19492 SWIGINTERN PyObject *ArtProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19493 return SWIG_Python_InitShadowInstance(args);
19494 }
19495
19496 SWIGINTERN PyObject *_wrap_delete_ConfigBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19497 PyObject *resultobj = 0;
19498 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19499 void *argp1 = 0 ;
19500 int res1 = 0 ;
19501 PyObject *swig_obj[1] ;
19502
19503 if (!args) SWIG_fail;
19504 swig_obj[0] = args;
19505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
19506 if (!SWIG_IsOK(res1)) {
19507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigBase" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19508 }
19509 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19510 {
19511 PyThreadState* __tstate = wxPyBeginAllowThreads();
19512 delete arg1;
19513
19514 wxPyEndAllowThreads(__tstate);
19515 if (PyErr_Occurred()) SWIG_fail;
19516 }
19517 resultobj = SWIG_Py_Void();
19518 return resultobj;
19519 fail:
19520 return NULL;
19521 }
19522
19523
19524 SWIGINTERN PyObject *_wrap_ConfigBase_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19525 PyObject *resultobj = 0;
19526 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19527 wxConfigBase *result = 0 ;
19528 int res1 = 0 ;
19529 PyObject * obj0 = 0 ;
19530 char * kwnames[] = {
19531 (char *) "config", NULL
19532 };
19533
19534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) SWIG_fail;
19535 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
19536 if (!SWIG_IsOK(res1)) {
19537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Set" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19538 }
19539 {
19540 PyThreadState* __tstate = wxPyBeginAllowThreads();
19541 result = (wxConfigBase *)wxConfigBase::Set(arg1);
19542 wxPyEndAllowThreads(__tstate);
19543 if (PyErr_Occurred()) SWIG_fail;
19544 }
19545 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
19546 return resultobj;
19547 fail:
19548 return NULL;
19549 }
19550
19551
19552 SWIGINTERN PyObject *_wrap_ConfigBase_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19553 PyObject *resultobj = 0;
19554 bool arg1 = (bool) true ;
19555 wxConfigBase *result = 0 ;
19556 bool val1 ;
19557 int ecode1 = 0 ;
19558 PyObject * obj0 = 0 ;
19559 char * kwnames[] = {
19560 (char *) "createOnDemand", NULL
19561 };
19562
19563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) SWIG_fail;
19564 if (obj0) {
19565 ecode1 = SWIG_AsVal_bool(obj0, &val1);
19566 if (!SWIG_IsOK(ecode1)) {
19567 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ConfigBase_Get" "', expected argument " "1"" of type '" "bool""'");
19568 }
19569 arg1 = static_cast< bool >(val1);
19570 }
19571 {
19572 PyThreadState* __tstate = wxPyBeginAllowThreads();
19573 result = (wxConfigBase *)wxConfigBase::Get(arg1);
19574 wxPyEndAllowThreads(__tstate);
19575 if (PyErr_Occurred()) SWIG_fail;
19576 }
19577 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
19578 return resultobj;
19579 fail:
19580 return NULL;
19581 }
19582
19583
19584 SWIGINTERN PyObject *_wrap_ConfigBase_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19585 PyObject *resultobj = 0;
19586 wxConfigBase *result = 0 ;
19587
19588 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_Create",0,0,0)) SWIG_fail;
19589 {
19590 PyThreadState* __tstate = wxPyBeginAllowThreads();
19591 result = (wxConfigBase *)wxConfigBase::Create();
19592 wxPyEndAllowThreads(__tstate);
19593 if (PyErr_Occurred()) SWIG_fail;
19594 }
19595 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
19596 return resultobj;
19597 fail:
19598 return NULL;
19599 }
19600
19601
19602 SWIGINTERN PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19603 PyObject *resultobj = 0;
19604
19605 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_DontCreateOnDemand",0,0,0)) SWIG_fail;
19606 {
19607 PyThreadState* __tstate = wxPyBeginAllowThreads();
19608 wxConfigBase::DontCreateOnDemand();
19609 wxPyEndAllowThreads(__tstate);
19610 if (PyErr_Occurred()) SWIG_fail;
19611 }
19612 resultobj = SWIG_Py_Void();
19613 return resultobj;
19614 fail:
19615 return NULL;
19616 }
19617
19618
19619 SWIGINTERN PyObject *_wrap_ConfigBase_SetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19620 PyObject *resultobj = 0;
19621 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19622 wxString *arg2 = 0 ;
19623 void *argp1 = 0 ;
19624 int res1 = 0 ;
19625 bool temp2 = false ;
19626 PyObject * obj0 = 0 ;
19627 PyObject * obj1 = 0 ;
19628 char * kwnames[] = {
19629 (char *) "self",(char *) "path", NULL
19630 };
19631
19632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) SWIG_fail;
19633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19634 if (!SWIG_IsOK(res1)) {
19635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetPath" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19636 }
19637 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19638 {
19639 arg2 = wxString_in_helper(obj1);
19640 if (arg2 == NULL) SWIG_fail;
19641 temp2 = true;
19642 }
19643 {
19644 PyThreadState* __tstate = wxPyBeginAllowThreads();
19645 (arg1)->SetPath((wxString const &)*arg2);
19646 wxPyEndAllowThreads(__tstate);
19647 if (PyErr_Occurred()) SWIG_fail;
19648 }
19649 resultobj = SWIG_Py_Void();
19650 {
19651 if (temp2)
19652 delete arg2;
19653 }
19654 return resultobj;
19655 fail:
19656 {
19657 if (temp2)
19658 delete arg2;
19659 }
19660 return NULL;
19661 }
19662
19663
19664 SWIGINTERN PyObject *_wrap_ConfigBase_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19665 PyObject *resultobj = 0;
19666 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19667 wxString *result = 0 ;
19668 void *argp1 = 0 ;
19669 int res1 = 0 ;
19670 PyObject *swig_obj[1] ;
19671
19672 if (!args) SWIG_fail;
19673 swig_obj[0] = args;
19674 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19675 if (!SWIG_IsOK(res1)) {
19676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetPath" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
19677 }
19678 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19679 {
19680 PyThreadState* __tstate = wxPyBeginAllowThreads();
19681 {
19682 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
19683 result = (wxString *) &_result_ref;
19684 }
19685 wxPyEndAllowThreads(__tstate);
19686 if (PyErr_Occurred()) SWIG_fail;
19687 }
19688 {
19689 #if wxUSE_UNICODE
19690 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
19691 #else
19692 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
19693 #endif
19694 }
19695 return resultobj;
19696 fail:
19697 return NULL;
19698 }
19699
19700
19701 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19702 PyObject *resultobj = 0;
19703 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19704 PyObject *result = 0 ;
19705 void *argp1 = 0 ;
19706 int res1 = 0 ;
19707 PyObject *swig_obj[1] ;
19708
19709 if (!args) SWIG_fail;
19710 swig_obj[0] = args;
19711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19712 if (!SWIG_IsOK(res1)) {
19713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19714 }
19715 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19716 {
19717 PyThreadState* __tstate = wxPyBeginAllowThreads();
19718 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
19719 wxPyEndAllowThreads(__tstate);
19720 if (PyErr_Occurred()) SWIG_fail;
19721 }
19722 resultobj = result;
19723 return resultobj;
19724 fail:
19725 return NULL;
19726 }
19727
19728
19729 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19730 PyObject *resultobj = 0;
19731 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19732 long arg2 ;
19733 PyObject *result = 0 ;
19734 void *argp1 = 0 ;
19735 int res1 = 0 ;
19736 long val2 ;
19737 int ecode2 = 0 ;
19738 PyObject * obj0 = 0 ;
19739 PyObject * obj1 = 0 ;
19740 char * kwnames[] = {
19741 (char *) "self",(char *) "index", NULL
19742 };
19743
19744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) SWIG_fail;
19745 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19746 if (!SWIG_IsOK(res1)) {
19747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19748 }
19749 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19750 ecode2 = SWIG_AsVal_long(obj1, &val2);
19751 if (!SWIG_IsOK(ecode2)) {
19752 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "2"" of type '" "long""'");
19753 }
19754 arg2 = static_cast< long >(val2);
19755 {
19756 PyThreadState* __tstate = wxPyBeginAllowThreads();
19757 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
19758 wxPyEndAllowThreads(__tstate);
19759 if (PyErr_Occurred()) SWIG_fail;
19760 }
19761 resultobj = result;
19762 return resultobj;
19763 fail:
19764 return NULL;
19765 }
19766
19767
19768 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19769 PyObject *resultobj = 0;
19770 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19771 PyObject *result = 0 ;
19772 void *argp1 = 0 ;
19773 int res1 = 0 ;
19774 PyObject *swig_obj[1] ;
19775
19776 if (!args) SWIG_fail;
19777 swig_obj[0] = args;
19778 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19779 if (!SWIG_IsOK(res1)) {
19780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19781 }
19782 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19783 {
19784 PyThreadState* __tstate = wxPyBeginAllowThreads();
19785 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
19786 wxPyEndAllowThreads(__tstate);
19787 if (PyErr_Occurred()) SWIG_fail;
19788 }
19789 resultobj = result;
19790 return resultobj;
19791 fail:
19792 return NULL;
19793 }
19794
19795
19796 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19797 PyObject *resultobj = 0;
19798 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19799 long arg2 ;
19800 PyObject *result = 0 ;
19801 void *argp1 = 0 ;
19802 int res1 = 0 ;
19803 long val2 ;
19804 int ecode2 = 0 ;
19805 PyObject * obj0 = 0 ;
19806 PyObject * obj1 = 0 ;
19807 char * kwnames[] = {
19808 (char *) "self",(char *) "index", NULL
19809 };
19810
19811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) SWIG_fail;
19812 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19813 if (!SWIG_IsOK(res1)) {
19814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19815 }
19816 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19817 ecode2 = SWIG_AsVal_long(obj1, &val2);
19818 if (!SWIG_IsOK(ecode2)) {
19819 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "2"" of type '" "long""'");
19820 }
19821 arg2 = static_cast< long >(val2);
19822 {
19823 PyThreadState* __tstate = wxPyBeginAllowThreads();
19824 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
19825 wxPyEndAllowThreads(__tstate);
19826 if (PyErr_Occurred()) SWIG_fail;
19827 }
19828 resultobj = result;
19829 return resultobj;
19830 fail:
19831 return NULL;
19832 }
19833
19834
19835 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19836 PyObject *resultobj = 0;
19837 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19838 bool arg2 = (bool) false ;
19839 size_t result;
19840 void *argp1 = 0 ;
19841 int res1 = 0 ;
19842 bool val2 ;
19843 int ecode2 = 0 ;
19844 PyObject * obj0 = 0 ;
19845 PyObject * obj1 = 0 ;
19846 char * kwnames[] = {
19847 (char *) "self",(char *) "recursive", NULL
19848 };
19849
19850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) SWIG_fail;
19851 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19852 if (!SWIG_IsOK(res1)) {
19853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
19854 }
19855 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19856 if (obj1) {
19857 ecode2 = SWIG_AsVal_bool(obj1, &val2);
19858 if (!SWIG_IsOK(ecode2)) {
19859 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "2"" of type '" "bool""'");
19860 }
19861 arg2 = static_cast< bool >(val2);
19862 }
19863 {
19864 PyThreadState* __tstate = wxPyBeginAllowThreads();
19865 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
19866 wxPyEndAllowThreads(__tstate);
19867 if (PyErr_Occurred()) SWIG_fail;
19868 }
19869 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
19870 return resultobj;
19871 fail:
19872 return NULL;
19873 }
19874
19875
19876 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19877 PyObject *resultobj = 0;
19878 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19879 bool arg2 = (bool) false ;
19880 size_t result;
19881 void *argp1 = 0 ;
19882 int res1 = 0 ;
19883 bool val2 ;
19884 int ecode2 = 0 ;
19885 PyObject * obj0 = 0 ;
19886 PyObject * obj1 = 0 ;
19887 char * kwnames[] = {
19888 (char *) "self",(char *) "recursive", NULL
19889 };
19890
19891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) SWIG_fail;
19892 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19893 if (!SWIG_IsOK(res1)) {
19894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
19895 }
19896 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19897 if (obj1) {
19898 ecode2 = SWIG_AsVal_bool(obj1, &val2);
19899 if (!SWIG_IsOK(ecode2)) {
19900 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "2"" of type '" "bool""'");
19901 }
19902 arg2 = static_cast< bool >(val2);
19903 }
19904 {
19905 PyThreadState* __tstate = wxPyBeginAllowThreads();
19906 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
19907 wxPyEndAllowThreads(__tstate);
19908 if (PyErr_Occurred()) SWIG_fail;
19909 }
19910 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
19911 return resultobj;
19912 fail:
19913 return NULL;
19914 }
19915
19916
19917 SWIGINTERN PyObject *_wrap_ConfigBase_HasGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19918 PyObject *resultobj = 0;
19919 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19920 wxString *arg2 = 0 ;
19921 bool result;
19922 void *argp1 = 0 ;
19923 int res1 = 0 ;
19924 bool temp2 = false ;
19925 PyObject * obj0 = 0 ;
19926 PyObject * obj1 = 0 ;
19927 char * kwnames[] = {
19928 (char *) "self",(char *) "name", NULL
19929 };
19930
19931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) SWIG_fail;
19932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19933 if (!SWIG_IsOK(res1)) {
19934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasGroup" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
19935 }
19936 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19937 {
19938 arg2 = wxString_in_helper(obj1);
19939 if (arg2 == NULL) SWIG_fail;
19940 temp2 = true;
19941 }
19942 {
19943 PyThreadState* __tstate = wxPyBeginAllowThreads();
19944 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
19945 wxPyEndAllowThreads(__tstate);
19946 if (PyErr_Occurred()) SWIG_fail;
19947 }
19948 {
19949 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19950 }
19951 {
19952 if (temp2)
19953 delete arg2;
19954 }
19955 return resultobj;
19956 fail:
19957 {
19958 if (temp2)
19959 delete arg2;
19960 }
19961 return NULL;
19962 }
19963
19964
19965 SWIGINTERN PyObject *_wrap_ConfigBase_HasEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19966 PyObject *resultobj = 0;
19967 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19968 wxString *arg2 = 0 ;
19969 bool result;
19970 void *argp1 = 0 ;
19971 int res1 = 0 ;
19972 bool temp2 = false ;
19973 PyObject * obj0 = 0 ;
19974 PyObject * obj1 = 0 ;
19975 char * kwnames[] = {
19976 (char *) "self",(char *) "name", NULL
19977 };
19978
19979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) SWIG_fail;
19980 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19981 if (!SWIG_IsOK(res1)) {
19982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasEntry" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
19983 }
19984 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19985 {
19986 arg2 = wxString_in_helper(obj1);
19987 if (arg2 == NULL) SWIG_fail;
19988 temp2 = true;
19989 }
19990 {
19991 PyThreadState* __tstate = wxPyBeginAllowThreads();
19992 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
19993 wxPyEndAllowThreads(__tstate);
19994 if (PyErr_Occurred()) SWIG_fail;
19995 }
19996 {
19997 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19998 }
19999 {
20000 if (temp2)
20001 delete arg2;
20002 }
20003 return resultobj;
20004 fail:
20005 {
20006 if (temp2)
20007 delete arg2;
20008 }
20009 return NULL;
20010 }
20011
20012
20013 SWIGINTERN PyObject *_wrap_ConfigBase_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20014 PyObject *resultobj = 0;
20015 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20016 wxString *arg2 = 0 ;
20017 bool result;
20018 void *argp1 = 0 ;
20019 int res1 = 0 ;
20020 bool temp2 = false ;
20021 PyObject * obj0 = 0 ;
20022 PyObject * obj1 = 0 ;
20023 char * kwnames[] = {
20024 (char *) "self",(char *) "name", NULL
20025 };
20026
20027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) SWIG_fail;
20028 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20029 if (!SWIG_IsOK(res1)) {
20030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Exists" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20031 }
20032 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20033 {
20034 arg2 = wxString_in_helper(obj1);
20035 if (arg2 == NULL) SWIG_fail;
20036 temp2 = true;
20037 }
20038 {
20039 PyThreadState* __tstate = wxPyBeginAllowThreads();
20040 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
20041 wxPyEndAllowThreads(__tstate);
20042 if (PyErr_Occurred()) SWIG_fail;
20043 }
20044 {
20045 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20046 }
20047 {
20048 if (temp2)
20049 delete arg2;
20050 }
20051 return resultobj;
20052 fail:
20053 {
20054 if (temp2)
20055 delete arg2;
20056 }
20057 return NULL;
20058 }
20059
20060
20061 SWIGINTERN PyObject *_wrap_ConfigBase_GetEntryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20062 PyObject *resultobj = 0;
20063 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20064 wxString *arg2 = 0 ;
20065 wxConfigBase::EntryType result;
20066 void *argp1 = 0 ;
20067 int res1 = 0 ;
20068 bool temp2 = false ;
20069 PyObject * obj0 = 0 ;
20070 PyObject * obj1 = 0 ;
20071 char * kwnames[] = {
20072 (char *) "self",(char *) "name", NULL
20073 };
20074
20075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) SWIG_fail;
20076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20077 if (!SWIG_IsOK(res1)) {
20078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetEntryType" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20079 }
20080 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20081 {
20082 arg2 = wxString_in_helper(obj1);
20083 if (arg2 == NULL) SWIG_fail;
20084 temp2 = true;
20085 }
20086 {
20087 PyThreadState* __tstate = wxPyBeginAllowThreads();
20088 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
20089 wxPyEndAllowThreads(__tstate);
20090 if (PyErr_Occurred()) SWIG_fail;
20091 }
20092 resultobj = SWIG_From_int(static_cast< int >(result));
20093 {
20094 if (temp2)
20095 delete arg2;
20096 }
20097 return resultobj;
20098 fail:
20099 {
20100 if (temp2)
20101 delete arg2;
20102 }
20103 return NULL;
20104 }
20105
20106
20107 SWIGINTERN PyObject *_wrap_ConfigBase_Read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20108 PyObject *resultobj = 0;
20109 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20110 wxString *arg2 = 0 ;
20111 wxString const &arg3_defvalue = wxPyEmptyString ;
20112 wxString *arg3 = (wxString *) &arg3_defvalue ;
20113 wxString result;
20114 void *argp1 = 0 ;
20115 int res1 = 0 ;
20116 bool temp2 = false ;
20117 bool temp3 = false ;
20118 PyObject * obj0 = 0 ;
20119 PyObject * obj1 = 0 ;
20120 PyObject * obj2 = 0 ;
20121 char * kwnames[] = {
20122 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
20123 };
20124
20125 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20126 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20127 if (!SWIG_IsOK(res1)) {
20128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Read" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20129 }
20130 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20131 {
20132 arg2 = wxString_in_helper(obj1);
20133 if (arg2 == NULL) SWIG_fail;
20134 temp2 = true;
20135 }
20136 if (obj2) {
20137 {
20138 arg3 = wxString_in_helper(obj2);
20139 if (arg3 == NULL) SWIG_fail;
20140 temp3 = true;
20141 }
20142 }
20143 {
20144 PyThreadState* __tstate = wxPyBeginAllowThreads();
20145 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
20146 wxPyEndAllowThreads(__tstate);
20147 if (PyErr_Occurred()) SWIG_fail;
20148 }
20149 {
20150 #if wxUSE_UNICODE
20151 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20152 #else
20153 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20154 #endif
20155 }
20156 {
20157 if (temp2)
20158 delete arg2;
20159 }
20160 {
20161 if (temp3)
20162 delete arg3;
20163 }
20164 return resultobj;
20165 fail:
20166 {
20167 if (temp2)
20168 delete arg2;
20169 }
20170 {
20171 if (temp3)
20172 delete arg3;
20173 }
20174 return NULL;
20175 }
20176
20177
20178 SWIGINTERN PyObject *_wrap_ConfigBase_ReadInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20179 PyObject *resultobj = 0;
20180 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20181 wxString *arg2 = 0 ;
20182 long arg3 = (long) 0 ;
20183 long result;
20184 void *argp1 = 0 ;
20185 int res1 = 0 ;
20186 bool temp2 = false ;
20187 long val3 ;
20188 int ecode3 = 0 ;
20189 PyObject * obj0 = 0 ;
20190 PyObject * obj1 = 0 ;
20191 PyObject * obj2 = 0 ;
20192 char * kwnames[] = {
20193 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
20194 };
20195
20196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20197 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20198 if (!SWIG_IsOK(res1)) {
20199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20200 }
20201 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20202 {
20203 arg2 = wxString_in_helper(obj1);
20204 if (arg2 == NULL) SWIG_fail;
20205 temp2 = true;
20206 }
20207 if (obj2) {
20208 ecode3 = SWIG_AsVal_long(obj2, &val3);
20209 if (!SWIG_IsOK(ecode3)) {
20210 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadInt" "', expected argument " "3"" of type '" "long""'");
20211 }
20212 arg3 = static_cast< long >(val3);
20213 }
20214 {
20215 PyThreadState* __tstate = wxPyBeginAllowThreads();
20216 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
20217 wxPyEndAllowThreads(__tstate);
20218 if (PyErr_Occurred()) SWIG_fail;
20219 }
20220 resultobj = SWIG_From_long(static_cast< long >(result));
20221 {
20222 if (temp2)
20223 delete arg2;
20224 }
20225 return resultobj;
20226 fail:
20227 {
20228 if (temp2)
20229 delete arg2;
20230 }
20231 return NULL;
20232 }
20233
20234
20235 SWIGINTERN PyObject *_wrap_ConfigBase_ReadFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20236 PyObject *resultobj = 0;
20237 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20238 wxString *arg2 = 0 ;
20239 double arg3 = (double) 0.0 ;
20240 double result;
20241 void *argp1 = 0 ;
20242 int res1 = 0 ;
20243 bool temp2 = false ;
20244 double val3 ;
20245 int ecode3 = 0 ;
20246 PyObject * obj0 = 0 ;
20247 PyObject * obj1 = 0 ;
20248 PyObject * obj2 = 0 ;
20249 char * kwnames[] = {
20250 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
20251 };
20252
20253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20254 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20255 if (!SWIG_IsOK(res1)) {
20256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20257 }
20258 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20259 {
20260 arg2 = wxString_in_helper(obj1);
20261 if (arg2 == NULL) SWIG_fail;
20262 temp2 = true;
20263 }
20264 if (obj2) {
20265 ecode3 = SWIG_AsVal_double(obj2, &val3);
20266 if (!SWIG_IsOK(ecode3)) {
20267 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadFloat" "', expected argument " "3"" of type '" "double""'");
20268 }
20269 arg3 = static_cast< double >(val3);
20270 }
20271 {
20272 PyThreadState* __tstate = wxPyBeginAllowThreads();
20273 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
20274 wxPyEndAllowThreads(__tstate);
20275 if (PyErr_Occurred()) SWIG_fail;
20276 }
20277 resultobj = SWIG_From_double(static_cast< double >(result));
20278 {
20279 if (temp2)
20280 delete arg2;
20281 }
20282 return resultobj;
20283 fail:
20284 {
20285 if (temp2)
20286 delete arg2;
20287 }
20288 return NULL;
20289 }
20290
20291
20292 SWIGINTERN PyObject *_wrap_ConfigBase_ReadBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20293 PyObject *resultobj = 0;
20294 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20295 wxString *arg2 = 0 ;
20296 bool arg3 = (bool) false ;
20297 bool result;
20298 void *argp1 = 0 ;
20299 int res1 = 0 ;
20300 bool temp2 = false ;
20301 bool val3 ;
20302 int ecode3 = 0 ;
20303 PyObject * obj0 = 0 ;
20304 PyObject * obj1 = 0 ;
20305 PyObject * obj2 = 0 ;
20306 char * kwnames[] = {
20307 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
20308 };
20309
20310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20311 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20312 if (!SWIG_IsOK(res1)) {
20313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20314 }
20315 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20316 {
20317 arg2 = wxString_in_helper(obj1);
20318 if (arg2 == NULL) SWIG_fail;
20319 temp2 = true;
20320 }
20321 if (obj2) {
20322 ecode3 = SWIG_AsVal_bool(obj2, &val3);
20323 if (!SWIG_IsOK(ecode3)) {
20324 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadBool" "', expected argument " "3"" of type '" "bool""'");
20325 }
20326 arg3 = static_cast< bool >(val3);
20327 }
20328 {
20329 PyThreadState* __tstate = wxPyBeginAllowThreads();
20330 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
20331 wxPyEndAllowThreads(__tstate);
20332 if (PyErr_Occurred()) SWIG_fail;
20333 }
20334 {
20335 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20336 }
20337 {
20338 if (temp2)
20339 delete arg2;
20340 }
20341 return resultobj;
20342 fail:
20343 {
20344 if (temp2)
20345 delete arg2;
20346 }
20347 return NULL;
20348 }
20349
20350
20351 SWIGINTERN PyObject *_wrap_ConfigBase_Write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20352 PyObject *resultobj = 0;
20353 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20354 wxString *arg2 = 0 ;
20355 wxString *arg3 = 0 ;
20356 bool result;
20357 void *argp1 = 0 ;
20358 int res1 = 0 ;
20359 bool temp2 = false ;
20360 bool temp3 = false ;
20361 PyObject * obj0 = 0 ;
20362 PyObject * obj1 = 0 ;
20363 PyObject * obj2 = 0 ;
20364 char * kwnames[] = {
20365 (char *) "self",(char *) "key",(char *) "value", NULL
20366 };
20367
20368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20369 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20370 if (!SWIG_IsOK(res1)) {
20371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Write" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20372 }
20373 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20374 {
20375 arg2 = wxString_in_helper(obj1);
20376 if (arg2 == NULL) SWIG_fail;
20377 temp2 = true;
20378 }
20379 {
20380 arg3 = wxString_in_helper(obj2);
20381 if (arg3 == NULL) SWIG_fail;
20382 temp3 = true;
20383 }
20384 {
20385 PyThreadState* __tstate = wxPyBeginAllowThreads();
20386 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
20387 wxPyEndAllowThreads(__tstate);
20388 if (PyErr_Occurred()) SWIG_fail;
20389 }
20390 {
20391 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20392 }
20393 {
20394 if (temp2)
20395 delete arg2;
20396 }
20397 {
20398 if (temp3)
20399 delete arg3;
20400 }
20401 return resultobj;
20402 fail:
20403 {
20404 if (temp2)
20405 delete arg2;
20406 }
20407 {
20408 if (temp3)
20409 delete arg3;
20410 }
20411 return NULL;
20412 }
20413
20414
20415 SWIGINTERN PyObject *_wrap_ConfigBase_WriteInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20416 PyObject *resultobj = 0;
20417 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20418 wxString *arg2 = 0 ;
20419 long arg3 ;
20420 bool result;
20421 void *argp1 = 0 ;
20422 int res1 = 0 ;
20423 bool temp2 = false ;
20424 long val3 ;
20425 int ecode3 = 0 ;
20426 PyObject * obj0 = 0 ;
20427 PyObject * obj1 = 0 ;
20428 PyObject * obj2 = 0 ;
20429 char * kwnames[] = {
20430 (char *) "self",(char *) "key",(char *) "value", NULL
20431 };
20432
20433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20434 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20435 if (!SWIG_IsOK(res1)) {
20436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20437 }
20438 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20439 {
20440 arg2 = wxString_in_helper(obj1);
20441 if (arg2 == NULL) SWIG_fail;
20442 temp2 = true;
20443 }
20444 ecode3 = SWIG_AsVal_long(obj2, &val3);
20445 if (!SWIG_IsOK(ecode3)) {
20446 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteInt" "', expected argument " "3"" of type '" "long""'");
20447 }
20448 arg3 = static_cast< long >(val3);
20449 {
20450 PyThreadState* __tstate = wxPyBeginAllowThreads();
20451 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
20452 wxPyEndAllowThreads(__tstate);
20453 if (PyErr_Occurred()) SWIG_fail;
20454 }
20455 {
20456 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20457 }
20458 {
20459 if (temp2)
20460 delete arg2;
20461 }
20462 return resultobj;
20463 fail:
20464 {
20465 if (temp2)
20466 delete arg2;
20467 }
20468 return NULL;
20469 }
20470
20471
20472 SWIGINTERN PyObject *_wrap_ConfigBase_WriteFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20473 PyObject *resultobj = 0;
20474 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20475 wxString *arg2 = 0 ;
20476 double arg3 ;
20477 bool result;
20478 void *argp1 = 0 ;
20479 int res1 = 0 ;
20480 bool temp2 = false ;
20481 double val3 ;
20482 int ecode3 = 0 ;
20483 PyObject * obj0 = 0 ;
20484 PyObject * obj1 = 0 ;
20485 PyObject * obj2 = 0 ;
20486 char * kwnames[] = {
20487 (char *) "self",(char *) "key",(char *) "value", NULL
20488 };
20489
20490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20491 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20492 if (!SWIG_IsOK(res1)) {
20493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20494 }
20495 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20496 {
20497 arg2 = wxString_in_helper(obj1);
20498 if (arg2 == NULL) SWIG_fail;
20499 temp2 = true;
20500 }
20501 ecode3 = SWIG_AsVal_double(obj2, &val3);
20502 if (!SWIG_IsOK(ecode3)) {
20503 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteFloat" "', expected argument " "3"" of type '" "double""'");
20504 }
20505 arg3 = static_cast< double >(val3);
20506 {
20507 PyThreadState* __tstate = wxPyBeginAllowThreads();
20508 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
20509 wxPyEndAllowThreads(__tstate);
20510 if (PyErr_Occurred()) SWIG_fail;
20511 }
20512 {
20513 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20514 }
20515 {
20516 if (temp2)
20517 delete arg2;
20518 }
20519 return resultobj;
20520 fail:
20521 {
20522 if (temp2)
20523 delete arg2;
20524 }
20525 return NULL;
20526 }
20527
20528
20529 SWIGINTERN PyObject *_wrap_ConfigBase_WriteBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20530 PyObject *resultobj = 0;
20531 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20532 wxString *arg2 = 0 ;
20533 bool arg3 ;
20534 bool result;
20535 void *argp1 = 0 ;
20536 int res1 = 0 ;
20537 bool temp2 = false ;
20538 bool val3 ;
20539 int ecode3 = 0 ;
20540 PyObject * obj0 = 0 ;
20541 PyObject * obj1 = 0 ;
20542 PyObject * obj2 = 0 ;
20543 char * kwnames[] = {
20544 (char *) "self",(char *) "key",(char *) "value", NULL
20545 };
20546
20547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20549 if (!SWIG_IsOK(res1)) {
20550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20551 }
20552 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20553 {
20554 arg2 = wxString_in_helper(obj1);
20555 if (arg2 == NULL) SWIG_fail;
20556 temp2 = true;
20557 }
20558 ecode3 = SWIG_AsVal_bool(obj2, &val3);
20559 if (!SWIG_IsOK(ecode3)) {
20560 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteBool" "', expected argument " "3"" of type '" "bool""'");
20561 }
20562 arg3 = static_cast< bool >(val3);
20563 {
20564 PyThreadState* __tstate = wxPyBeginAllowThreads();
20565 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
20566 wxPyEndAllowThreads(__tstate);
20567 if (PyErr_Occurred()) SWIG_fail;
20568 }
20569 {
20570 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20571 }
20572 {
20573 if (temp2)
20574 delete arg2;
20575 }
20576 return resultobj;
20577 fail:
20578 {
20579 if (temp2)
20580 delete arg2;
20581 }
20582 return NULL;
20583 }
20584
20585
20586 SWIGINTERN PyObject *_wrap_ConfigBase_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20587 PyObject *resultobj = 0;
20588 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20589 bool arg2 = (bool) false ;
20590 bool result;
20591 void *argp1 = 0 ;
20592 int res1 = 0 ;
20593 bool val2 ;
20594 int ecode2 = 0 ;
20595 PyObject * obj0 = 0 ;
20596 PyObject * obj1 = 0 ;
20597 char * kwnames[] = {
20598 (char *) "self",(char *) "currentOnly", NULL
20599 };
20600
20601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) SWIG_fail;
20602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20603 if (!SWIG_IsOK(res1)) {
20604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Flush" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20605 }
20606 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20607 if (obj1) {
20608 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20609 if (!SWIG_IsOK(ecode2)) {
20610 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_Flush" "', expected argument " "2"" of type '" "bool""'");
20611 }
20612 arg2 = static_cast< bool >(val2);
20613 }
20614 {
20615 PyThreadState* __tstate = wxPyBeginAllowThreads();
20616 result = (bool)(arg1)->Flush(arg2);
20617 wxPyEndAllowThreads(__tstate);
20618 if (PyErr_Occurred()) SWIG_fail;
20619 }
20620 {
20621 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20622 }
20623 return resultobj;
20624 fail:
20625 return NULL;
20626 }
20627
20628
20629 SWIGINTERN PyObject *_wrap_ConfigBase_RenameEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20630 PyObject *resultobj = 0;
20631 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20632 wxString *arg2 = 0 ;
20633 wxString *arg3 = 0 ;
20634 bool result;
20635 void *argp1 = 0 ;
20636 int res1 = 0 ;
20637 bool temp2 = false ;
20638 bool temp3 = false ;
20639 PyObject * obj0 = 0 ;
20640 PyObject * obj1 = 0 ;
20641 PyObject * obj2 = 0 ;
20642 char * kwnames[] = {
20643 (char *) "self",(char *) "oldName",(char *) "newName", NULL
20644 };
20645
20646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20648 if (!SWIG_IsOK(res1)) {
20649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20650 }
20651 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20652 {
20653 arg2 = wxString_in_helper(obj1);
20654 if (arg2 == NULL) SWIG_fail;
20655 temp2 = true;
20656 }
20657 {
20658 arg3 = wxString_in_helper(obj2);
20659 if (arg3 == NULL) SWIG_fail;
20660 temp3 = true;
20661 }
20662 {
20663 PyThreadState* __tstate = wxPyBeginAllowThreads();
20664 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
20665 wxPyEndAllowThreads(__tstate);
20666 if (PyErr_Occurred()) SWIG_fail;
20667 }
20668 {
20669 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20670 }
20671 {
20672 if (temp2)
20673 delete arg2;
20674 }
20675 {
20676 if (temp3)
20677 delete arg3;
20678 }
20679 return resultobj;
20680 fail:
20681 {
20682 if (temp2)
20683 delete arg2;
20684 }
20685 {
20686 if (temp3)
20687 delete arg3;
20688 }
20689 return NULL;
20690 }
20691
20692
20693 SWIGINTERN PyObject *_wrap_ConfigBase_RenameGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20694 PyObject *resultobj = 0;
20695 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20696 wxString *arg2 = 0 ;
20697 wxString *arg3 = 0 ;
20698 bool result;
20699 void *argp1 = 0 ;
20700 int res1 = 0 ;
20701 bool temp2 = false ;
20702 bool temp3 = false ;
20703 PyObject * obj0 = 0 ;
20704 PyObject * obj1 = 0 ;
20705 PyObject * obj2 = 0 ;
20706 char * kwnames[] = {
20707 (char *) "self",(char *) "oldName",(char *) "newName", NULL
20708 };
20709
20710 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20711 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20712 if (!SWIG_IsOK(res1)) {
20713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20714 }
20715 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20716 {
20717 arg2 = wxString_in_helper(obj1);
20718 if (arg2 == NULL) SWIG_fail;
20719 temp2 = true;
20720 }
20721 {
20722 arg3 = wxString_in_helper(obj2);
20723 if (arg3 == NULL) SWIG_fail;
20724 temp3 = true;
20725 }
20726 {
20727 PyThreadState* __tstate = wxPyBeginAllowThreads();
20728 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
20729 wxPyEndAllowThreads(__tstate);
20730 if (PyErr_Occurred()) SWIG_fail;
20731 }
20732 {
20733 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20734 }
20735 {
20736 if (temp2)
20737 delete arg2;
20738 }
20739 {
20740 if (temp3)
20741 delete arg3;
20742 }
20743 return resultobj;
20744 fail:
20745 {
20746 if (temp2)
20747 delete arg2;
20748 }
20749 {
20750 if (temp3)
20751 delete arg3;
20752 }
20753 return NULL;
20754 }
20755
20756
20757 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20758 PyObject *resultobj = 0;
20759 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20760 wxString *arg2 = 0 ;
20761 bool arg3 = (bool) true ;
20762 bool result;
20763 void *argp1 = 0 ;
20764 int res1 = 0 ;
20765 bool temp2 = false ;
20766 bool val3 ;
20767 int ecode3 = 0 ;
20768 PyObject * obj0 = 0 ;
20769 PyObject * obj1 = 0 ;
20770 PyObject * obj2 = 0 ;
20771 char * kwnames[] = {
20772 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
20773 };
20774
20775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20776 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20777 if (!SWIG_IsOK(res1)) {
20778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20779 }
20780 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20781 {
20782 arg2 = wxString_in_helper(obj1);
20783 if (arg2 == NULL) SWIG_fail;
20784 temp2 = true;
20785 }
20786 if (obj2) {
20787 ecode3 = SWIG_AsVal_bool(obj2, &val3);
20788 if (!SWIG_IsOK(ecode3)) {
20789 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "3"" of type '" "bool""'");
20790 }
20791 arg3 = static_cast< bool >(val3);
20792 }
20793 {
20794 PyThreadState* __tstate = wxPyBeginAllowThreads();
20795 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
20796 wxPyEndAllowThreads(__tstate);
20797 if (PyErr_Occurred()) SWIG_fail;
20798 }
20799 {
20800 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20801 }
20802 {
20803 if (temp2)
20804 delete arg2;
20805 }
20806 return resultobj;
20807 fail:
20808 {
20809 if (temp2)
20810 delete arg2;
20811 }
20812 return NULL;
20813 }
20814
20815
20816 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20817 PyObject *resultobj = 0;
20818 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20819 wxString *arg2 = 0 ;
20820 bool result;
20821 void *argp1 = 0 ;
20822 int res1 = 0 ;
20823 bool temp2 = false ;
20824 PyObject * obj0 = 0 ;
20825 PyObject * obj1 = 0 ;
20826 char * kwnames[] = {
20827 (char *) "self",(char *) "key", NULL
20828 };
20829
20830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) SWIG_fail;
20831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20832 if (!SWIG_IsOK(res1)) {
20833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20834 }
20835 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20836 {
20837 arg2 = wxString_in_helper(obj1);
20838 if (arg2 == NULL) SWIG_fail;
20839 temp2 = true;
20840 }
20841 {
20842 PyThreadState* __tstate = wxPyBeginAllowThreads();
20843 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
20844 wxPyEndAllowThreads(__tstate);
20845 if (PyErr_Occurred()) SWIG_fail;
20846 }
20847 {
20848 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20849 }
20850 {
20851 if (temp2)
20852 delete arg2;
20853 }
20854 return resultobj;
20855 fail:
20856 {
20857 if (temp2)
20858 delete arg2;
20859 }
20860 return NULL;
20861 }
20862
20863
20864 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20865 PyObject *resultobj = 0;
20866 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20867 bool result;
20868 void *argp1 = 0 ;
20869 int res1 = 0 ;
20870 PyObject *swig_obj[1] ;
20871
20872 if (!args) SWIG_fail;
20873 swig_obj[0] = args;
20874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20875 if (!SWIG_IsOK(res1)) {
20876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteAll" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20877 }
20878 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20879 {
20880 PyThreadState* __tstate = wxPyBeginAllowThreads();
20881 result = (bool)(arg1)->DeleteAll();
20882 wxPyEndAllowThreads(__tstate);
20883 if (PyErr_Occurred()) SWIG_fail;
20884 }
20885 {
20886 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20887 }
20888 return resultobj;
20889 fail:
20890 return NULL;
20891 }
20892
20893
20894 SWIGINTERN PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20895 PyObject *resultobj = 0;
20896 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20897 bool arg2 = (bool) true ;
20898 void *argp1 = 0 ;
20899 int res1 = 0 ;
20900 bool val2 ;
20901 int ecode2 = 0 ;
20902 PyObject * obj0 = 0 ;
20903 PyObject * obj1 = 0 ;
20904 char * kwnames[] = {
20905 (char *) "self",(char *) "doIt", NULL
20906 };
20907
20908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
20909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20910 if (!SWIG_IsOK(res1)) {
20911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20912 }
20913 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20914 if (obj1) {
20915 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20916 if (!SWIG_IsOK(ecode2)) {
20917 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "2"" of type '" "bool""'");
20918 }
20919 arg2 = static_cast< bool >(val2);
20920 }
20921 {
20922 PyThreadState* __tstate = wxPyBeginAllowThreads();
20923 (arg1)->SetExpandEnvVars(arg2);
20924 wxPyEndAllowThreads(__tstate);
20925 if (PyErr_Occurred()) SWIG_fail;
20926 }
20927 resultobj = SWIG_Py_Void();
20928 return resultobj;
20929 fail:
20930 return NULL;
20931 }
20932
20933
20934 SWIGINTERN PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20935 PyObject *resultobj = 0;
20936 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20937 bool result;
20938 void *argp1 = 0 ;
20939 int res1 = 0 ;
20940 PyObject *swig_obj[1] ;
20941
20942 if (!args) SWIG_fail;
20943 swig_obj[0] = args;
20944 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20945 if (!SWIG_IsOK(res1)) {
20946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsExpandingEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20947 }
20948 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20949 {
20950 PyThreadState* __tstate = wxPyBeginAllowThreads();
20951 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
20952 wxPyEndAllowThreads(__tstate);
20953 if (PyErr_Occurred()) SWIG_fail;
20954 }
20955 {
20956 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20957 }
20958 return resultobj;
20959 fail:
20960 return NULL;
20961 }
20962
20963
20964 SWIGINTERN PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20965 PyObject *resultobj = 0;
20966 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20967 bool arg2 = (bool) true ;
20968 void *argp1 = 0 ;
20969 int res1 = 0 ;
20970 bool val2 ;
20971 int ecode2 = 0 ;
20972 PyObject * obj0 = 0 ;
20973 PyObject * obj1 = 0 ;
20974 char * kwnames[] = {
20975 (char *) "self",(char *) "doIt", NULL
20976 };
20977
20978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
20979 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20980 if (!SWIG_IsOK(res1)) {
20981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20982 }
20983 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20984 if (obj1) {
20985 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20986 if (!SWIG_IsOK(ecode2)) {
20987 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "2"" of type '" "bool""'");
20988 }
20989 arg2 = static_cast< bool >(val2);
20990 }
20991 {
20992 PyThreadState* __tstate = wxPyBeginAllowThreads();
20993 (arg1)->SetRecordDefaults(arg2);
20994 wxPyEndAllowThreads(__tstate);
20995 if (PyErr_Occurred()) SWIG_fail;
20996 }
20997 resultobj = SWIG_Py_Void();
20998 return resultobj;
20999 fail:
21000 return NULL;
21001 }
21002
21003
21004 SWIGINTERN PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21005 PyObject *resultobj = 0;
21006 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21007 bool result;
21008 void *argp1 = 0 ;
21009 int res1 = 0 ;
21010 PyObject *swig_obj[1] ;
21011
21012 if (!args) SWIG_fail;
21013 swig_obj[0] = args;
21014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21015 if (!SWIG_IsOK(res1)) {
21016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsRecordingDefaults" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21017 }
21018 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21019 {
21020 PyThreadState* __tstate = wxPyBeginAllowThreads();
21021 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
21022 wxPyEndAllowThreads(__tstate);
21023 if (PyErr_Occurred()) SWIG_fail;
21024 }
21025 {
21026 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21027 }
21028 return resultobj;
21029 fail:
21030 return NULL;
21031 }
21032
21033
21034 SWIGINTERN PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21035 PyObject *resultobj = 0;
21036 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21037 wxString *arg2 = 0 ;
21038 wxString result;
21039 void *argp1 = 0 ;
21040 int res1 = 0 ;
21041 bool temp2 = false ;
21042 PyObject * obj0 = 0 ;
21043 PyObject * obj1 = 0 ;
21044 char * kwnames[] = {
21045 (char *) "self",(char *) "str", NULL
21046 };
21047
21048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
21049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21050 if (!SWIG_IsOK(res1)) {
21051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21052 }
21053 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21054 {
21055 arg2 = wxString_in_helper(obj1);
21056 if (arg2 == NULL) SWIG_fail;
21057 temp2 = true;
21058 }
21059 {
21060 PyThreadState* __tstate = wxPyBeginAllowThreads();
21061 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
21062 wxPyEndAllowThreads(__tstate);
21063 if (PyErr_Occurred()) SWIG_fail;
21064 }
21065 {
21066 #if wxUSE_UNICODE
21067 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21068 #else
21069 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21070 #endif
21071 }
21072 {
21073 if (temp2)
21074 delete arg2;
21075 }
21076 return resultobj;
21077 fail:
21078 {
21079 if (temp2)
21080 delete arg2;
21081 }
21082 return NULL;
21083 }
21084
21085
21086 SWIGINTERN PyObject *_wrap_ConfigBase_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21087 PyObject *resultobj = 0;
21088 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21089 wxString result;
21090 void *argp1 = 0 ;
21091 int res1 = 0 ;
21092 PyObject *swig_obj[1] ;
21093
21094 if (!args) SWIG_fail;
21095 swig_obj[0] = args;
21096 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21097 if (!SWIG_IsOK(res1)) {
21098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetAppName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21099 }
21100 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21101 {
21102 PyThreadState* __tstate = wxPyBeginAllowThreads();
21103 result = ((wxConfigBase const *)arg1)->GetAppName();
21104 wxPyEndAllowThreads(__tstate);
21105 if (PyErr_Occurred()) SWIG_fail;
21106 }
21107 {
21108 #if wxUSE_UNICODE
21109 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21110 #else
21111 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21112 #endif
21113 }
21114 return resultobj;
21115 fail:
21116 return NULL;
21117 }
21118
21119
21120 SWIGINTERN PyObject *_wrap_ConfigBase_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21121 PyObject *resultobj = 0;
21122 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21123 wxString result;
21124 void *argp1 = 0 ;
21125 int res1 = 0 ;
21126 PyObject *swig_obj[1] ;
21127
21128 if (!args) SWIG_fail;
21129 swig_obj[0] = args;
21130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21131 if (!SWIG_IsOK(res1)) {
21132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetVendorName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21133 }
21134 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21135 {
21136 PyThreadState* __tstate = wxPyBeginAllowThreads();
21137 result = ((wxConfigBase const *)arg1)->GetVendorName();
21138 wxPyEndAllowThreads(__tstate);
21139 if (PyErr_Occurred()) SWIG_fail;
21140 }
21141 {
21142 #if wxUSE_UNICODE
21143 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21144 #else
21145 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21146 #endif
21147 }
21148 return resultobj;
21149 fail:
21150 return NULL;
21151 }
21152
21153
21154 SWIGINTERN PyObject *_wrap_ConfigBase_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21155 PyObject *resultobj = 0;
21156 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21157 wxString *arg2 = 0 ;
21158 void *argp1 = 0 ;
21159 int res1 = 0 ;
21160 bool temp2 = false ;
21161 PyObject * obj0 = 0 ;
21162 PyObject * obj1 = 0 ;
21163 char * kwnames[] = {
21164 (char *) "self",(char *) "appName", NULL
21165 };
21166
21167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
21168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21169 if (!SWIG_IsOK(res1)) {
21170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetAppName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21171 }
21172 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21173 {
21174 arg2 = wxString_in_helper(obj1);
21175 if (arg2 == NULL) SWIG_fail;
21176 temp2 = true;
21177 }
21178 {
21179 PyThreadState* __tstate = wxPyBeginAllowThreads();
21180 (arg1)->SetAppName((wxString const &)*arg2);
21181 wxPyEndAllowThreads(__tstate);
21182 if (PyErr_Occurred()) SWIG_fail;
21183 }
21184 resultobj = SWIG_Py_Void();
21185 {
21186 if (temp2)
21187 delete arg2;
21188 }
21189 return resultobj;
21190 fail:
21191 {
21192 if (temp2)
21193 delete arg2;
21194 }
21195 return NULL;
21196 }
21197
21198
21199 SWIGINTERN PyObject *_wrap_ConfigBase_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21200 PyObject *resultobj = 0;
21201 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21202 wxString *arg2 = 0 ;
21203 void *argp1 = 0 ;
21204 int res1 = 0 ;
21205 bool temp2 = false ;
21206 PyObject * obj0 = 0 ;
21207 PyObject * obj1 = 0 ;
21208 char * kwnames[] = {
21209 (char *) "self",(char *) "vendorName", NULL
21210 };
21211
21212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
21213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21214 if (!SWIG_IsOK(res1)) {
21215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetVendorName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21216 }
21217 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21218 {
21219 arg2 = wxString_in_helper(obj1);
21220 if (arg2 == NULL) SWIG_fail;
21221 temp2 = true;
21222 }
21223 {
21224 PyThreadState* __tstate = wxPyBeginAllowThreads();
21225 (arg1)->SetVendorName((wxString const &)*arg2);
21226 wxPyEndAllowThreads(__tstate);
21227 if (PyErr_Occurred()) SWIG_fail;
21228 }
21229 resultobj = SWIG_Py_Void();
21230 {
21231 if (temp2)
21232 delete arg2;
21233 }
21234 return resultobj;
21235 fail:
21236 {
21237 if (temp2)
21238 delete arg2;
21239 }
21240 return NULL;
21241 }
21242
21243
21244 SWIGINTERN PyObject *_wrap_ConfigBase_SetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21245 PyObject *resultobj = 0;
21246 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21247 long arg2 ;
21248 void *argp1 = 0 ;
21249 int res1 = 0 ;
21250 long val2 ;
21251 int ecode2 = 0 ;
21252 PyObject * obj0 = 0 ;
21253 PyObject * obj1 = 0 ;
21254 char * kwnames[] = {
21255 (char *) "self",(char *) "style", NULL
21256 };
21257
21258 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) SWIG_fail;
21259 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21260 if (!SWIG_IsOK(res1)) {
21261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetStyle" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21262 }
21263 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21264 ecode2 = SWIG_AsVal_long(obj1, &val2);
21265 if (!SWIG_IsOK(ecode2)) {
21266 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetStyle" "', expected argument " "2"" of type '" "long""'");
21267 }
21268 arg2 = static_cast< long >(val2);
21269 {
21270 PyThreadState* __tstate = wxPyBeginAllowThreads();
21271 (arg1)->SetStyle(arg2);
21272 wxPyEndAllowThreads(__tstate);
21273 if (PyErr_Occurred()) SWIG_fail;
21274 }
21275 resultobj = SWIG_Py_Void();
21276 return resultobj;
21277 fail:
21278 return NULL;
21279 }
21280
21281
21282 SWIGINTERN PyObject *_wrap_ConfigBase_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21283 PyObject *resultobj = 0;
21284 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21285 long result;
21286 void *argp1 = 0 ;
21287 int res1 = 0 ;
21288 PyObject *swig_obj[1] ;
21289
21290 if (!args) SWIG_fail;
21291 swig_obj[0] = args;
21292 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21293 if (!SWIG_IsOK(res1)) {
21294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetStyle" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21295 }
21296 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21297 {
21298 PyThreadState* __tstate = wxPyBeginAllowThreads();
21299 result = (long)((wxConfigBase const *)arg1)->GetStyle();
21300 wxPyEndAllowThreads(__tstate);
21301 if (PyErr_Occurred()) SWIG_fail;
21302 }
21303 resultobj = SWIG_From_long(static_cast< long >(result));
21304 return resultobj;
21305 fail:
21306 return NULL;
21307 }
21308
21309
21310 SWIGINTERN PyObject *ConfigBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21311 PyObject *obj;
21312 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21313 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigBase, SWIG_NewClientData(obj));
21314 return SWIG_Py_Void();
21315 }
21316
21317 SWIGINTERN PyObject *_wrap_new_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21318 PyObject *resultobj = 0;
21319 wxString const &arg1_defvalue = wxPyEmptyString ;
21320 wxString *arg1 = (wxString *) &arg1_defvalue ;
21321 wxString const &arg2_defvalue = wxPyEmptyString ;
21322 wxString *arg2 = (wxString *) &arg2_defvalue ;
21323 wxString const &arg3_defvalue = wxPyEmptyString ;
21324 wxString *arg3 = (wxString *) &arg3_defvalue ;
21325 wxString const &arg4_defvalue = wxPyEmptyString ;
21326 wxString *arg4 = (wxString *) &arg4_defvalue ;
21327 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
21328 wxConfig *result = 0 ;
21329 bool temp1 = false ;
21330 bool temp2 = false ;
21331 bool temp3 = false ;
21332 bool temp4 = false ;
21333 long val5 ;
21334 int ecode5 = 0 ;
21335 PyObject * obj0 = 0 ;
21336 PyObject * obj1 = 0 ;
21337 PyObject * obj2 = 0 ;
21338 PyObject * obj3 = 0 ;
21339 PyObject * obj4 = 0 ;
21340 char * kwnames[] = {
21341 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
21342 };
21343
21344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
21345 if (obj0) {
21346 {
21347 arg1 = wxString_in_helper(obj0);
21348 if (arg1 == NULL) SWIG_fail;
21349 temp1 = true;
21350 }
21351 }
21352 if (obj1) {
21353 {
21354 arg2 = wxString_in_helper(obj1);
21355 if (arg2 == NULL) SWIG_fail;
21356 temp2 = true;
21357 }
21358 }
21359 if (obj2) {
21360 {
21361 arg3 = wxString_in_helper(obj2);
21362 if (arg3 == NULL) SWIG_fail;
21363 temp3 = true;
21364 }
21365 }
21366 if (obj3) {
21367 {
21368 arg4 = wxString_in_helper(obj3);
21369 if (arg4 == NULL) SWIG_fail;
21370 temp4 = true;
21371 }
21372 }
21373 if (obj4) {
21374 ecode5 = SWIG_AsVal_long(obj4, &val5);
21375 if (!SWIG_IsOK(ecode5)) {
21376 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Config" "', expected argument " "5"" of type '" "long""'");
21377 }
21378 arg5 = static_cast< long >(val5);
21379 }
21380 {
21381 PyThreadState* __tstate = wxPyBeginAllowThreads();
21382 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
21383 wxPyEndAllowThreads(__tstate);
21384 if (PyErr_Occurred()) SWIG_fail;
21385 }
21386 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfig, SWIG_POINTER_NEW | 0 );
21387 {
21388 if (temp1)
21389 delete arg1;
21390 }
21391 {
21392 if (temp2)
21393 delete arg2;
21394 }
21395 {
21396 if (temp3)
21397 delete arg3;
21398 }
21399 {
21400 if (temp4)
21401 delete arg4;
21402 }
21403 return resultobj;
21404 fail:
21405 {
21406 if (temp1)
21407 delete arg1;
21408 }
21409 {
21410 if (temp2)
21411 delete arg2;
21412 }
21413 {
21414 if (temp3)
21415 delete arg3;
21416 }
21417 {
21418 if (temp4)
21419 delete arg4;
21420 }
21421 return NULL;
21422 }
21423
21424
21425 SWIGINTERN PyObject *_wrap_delete_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21426 PyObject *resultobj = 0;
21427 wxConfig *arg1 = (wxConfig *) 0 ;
21428 void *argp1 = 0 ;
21429 int res1 = 0 ;
21430 PyObject *swig_obj[1] ;
21431
21432 if (!args) SWIG_fail;
21433 swig_obj[0] = args;
21434 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfig, SWIG_POINTER_DISOWN | 0 );
21435 if (!SWIG_IsOK(res1)) {
21436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Config" "', expected argument " "1"" of type '" "wxConfig *""'");
21437 }
21438 arg1 = reinterpret_cast< wxConfig * >(argp1);
21439 {
21440 PyThreadState* __tstate = wxPyBeginAllowThreads();
21441 delete arg1;
21442
21443 wxPyEndAllowThreads(__tstate);
21444 if (PyErr_Occurred()) SWIG_fail;
21445 }
21446 resultobj = SWIG_Py_Void();
21447 return resultobj;
21448 fail:
21449 return NULL;
21450 }
21451
21452
21453 SWIGINTERN PyObject *Config_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21454 PyObject *obj;
21455 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21456 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfig, SWIG_NewClientData(obj));
21457 return SWIG_Py_Void();
21458 }
21459
21460 SWIGINTERN PyObject *Config_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21461 return SWIG_Python_InitShadowInstance(args);
21462 }
21463
21464 SWIGINTERN PyObject *_wrap_new_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21465 PyObject *resultobj = 0;
21466 wxString const &arg1_defvalue = wxPyEmptyString ;
21467 wxString *arg1 = (wxString *) &arg1_defvalue ;
21468 wxString const &arg2_defvalue = wxPyEmptyString ;
21469 wxString *arg2 = (wxString *) &arg2_defvalue ;
21470 wxString const &arg3_defvalue = wxPyEmptyString ;
21471 wxString *arg3 = (wxString *) &arg3_defvalue ;
21472 wxString const &arg4_defvalue = wxPyEmptyString ;
21473 wxString *arg4 = (wxString *) &arg4_defvalue ;
21474 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
21475 wxFileConfig *result = 0 ;
21476 bool temp1 = false ;
21477 bool temp2 = false ;
21478 bool temp3 = false ;
21479 bool temp4 = false ;
21480 long val5 ;
21481 int ecode5 = 0 ;
21482 PyObject * obj0 = 0 ;
21483 PyObject * obj1 = 0 ;
21484 PyObject * obj2 = 0 ;
21485 PyObject * obj3 = 0 ;
21486 PyObject * obj4 = 0 ;
21487 char * kwnames[] = {
21488 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
21489 };
21490
21491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
21492 if (obj0) {
21493 {
21494 arg1 = wxString_in_helper(obj0);
21495 if (arg1 == NULL) SWIG_fail;
21496 temp1 = true;
21497 }
21498 }
21499 if (obj1) {
21500 {
21501 arg2 = wxString_in_helper(obj1);
21502 if (arg2 == NULL) SWIG_fail;
21503 temp2 = true;
21504 }
21505 }
21506 if (obj2) {
21507 {
21508 arg3 = wxString_in_helper(obj2);
21509 if (arg3 == NULL) SWIG_fail;
21510 temp3 = true;
21511 }
21512 }
21513 if (obj3) {
21514 {
21515 arg4 = wxString_in_helper(obj3);
21516 if (arg4 == NULL) SWIG_fail;
21517 temp4 = true;
21518 }
21519 }
21520 if (obj4) {
21521 ecode5 = SWIG_AsVal_long(obj4, &val5);
21522 if (!SWIG_IsOK(ecode5)) {
21523 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FileConfig" "', expected argument " "5"" of type '" "long""'");
21524 }
21525 arg5 = static_cast< long >(val5);
21526 }
21527 {
21528 PyThreadState* __tstate = wxPyBeginAllowThreads();
21529 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
21530 wxPyEndAllowThreads(__tstate);
21531 if (PyErr_Occurred()) SWIG_fail;
21532 }
21533 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileConfig, SWIG_POINTER_NEW | 0 );
21534 {
21535 if (temp1)
21536 delete arg1;
21537 }
21538 {
21539 if (temp2)
21540 delete arg2;
21541 }
21542 {
21543 if (temp3)
21544 delete arg3;
21545 }
21546 {
21547 if (temp4)
21548 delete arg4;
21549 }
21550 return resultobj;
21551 fail:
21552 {
21553 if (temp1)
21554 delete arg1;
21555 }
21556 {
21557 if (temp2)
21558 delete arg2;
21559 }
21560 {
21561 if (temp3)
21562 delete arg3;
21563 }
21564 {
21565 if (temp4)
21566 delete arg4;
21567 }
21568 return NULL;
21569 }
21570
21571
21572 SWIGINTERN PyObject *_wrap_delete_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21573 PyObject *resultobj = 0;
21574 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
21575 void *argp1 = 0 ;
21576 int res1 = 0 ;
21577 PyObject *swig_obj[1] ;
21578
21579 if (!args) SWIG_fail;
21580 swig_obj[0] = args;
21581 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileConfig, SWIG_POINTER_DISOWN | 0 );
21582 if (!SWIG_IsOK(res1)) {
21583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileConfig" "', expected argument " "1"" of type '" "wxFileConfig *""'");
21584 }
21585 arg1 = reinterpret_cast< wxFileConfig * >(argp1);
21586 {
21587 PyThreadState* __tstate = wxPyBeginAllowThreads();
21588 delete arg1;
21589
21590 wxPyEndAllowThreads(__tstate);
21591 if (PyErr_Occurred()) SWIG_fail;
21592 }
21593 resultobj = SWIG_Py_Void();
21594 return resultobj;
21595 fail:
21596 return NULL;
21597 }
21598
21599
21600 SWIGINTERN PyObject *FileConfig_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21601 PyObject *obj;
21602 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21603 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileConfig, SWIG_NewClientData(obj));
21604 return SWIG_Py_Void();
21605 }
21606
21607 SWIGINTERN PyObject *FileConfig_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21608 return SWIG_Python_InitShadowInstance(args);
21609 }
21610
21611 SWIGINTERN PyObject *_wrap_new_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21612 PyObject *resultobj = 0;
21613 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21614 wxString *arg2 = 0 ;
21615 wxConfigPathChanger *result = 0 ;
21616 void *argp1 = 0 ;
21617 int res1 = 0 ;
21618 bool temp2 = false ;
21619 PyObject * obj0 = 0 ;
21620 PyObject * obj1 = 0 ;
21621 char * kwnames[] = {
21622 (char *) "config",(char *) "entry", NULL
21623 };
21624
21625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) SWIG_fail;
21626 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21627 if (!SWIG_IsOK(res1)) {
21628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21629 }
21630 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21631 {
21632 arg2 = wxString_in_helper(obj1);
21633 if (arg2 == NULL) SWIG_fail;
21634 temp2 = true;
21635 }
21636 {
21637 PyThreadState* __tstate = wxPyBeginAllowThreads();
21638 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
21639 wxPyEndAllowThreads(__tstate);
21640 if (PyErr_Occurred()) SWIG_fail;
21641 }
21642 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_NEW | 0 );
21643 {
21644 if (temp2)
21645 delete arg2;
21646 }
21647 return resultobj;
21648 fail:
21649 {
21650 if (temp2)
21651 delete arg2;
21652 }
21653 return NULL;
21654 }
21655
21656
21657 SWIGINTERN PyObject *_wrap_delete_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21658 PyObject *resultobj = 0;
21659 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
21660 void *argp1 = 0 ;
21661 int res1 = 0 ;
21662 PyObject *swig_obj[1] ;
21663
21664 if (!args) SWIG_fail;
21665 swig_obj[0] = args;
21666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_DISOWN | 0 );
21667 if (!SWIG_IsOK(res1)) {
21668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigPathChanger *""'");
21669 }
21670 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
21671 {
21672 PyThreadState* __tstate = wxPyBeginAllowThreads();
21673 delete arg1;
21674
21675 wxPyEndAllowThreads(__tstate);
21676 if (PyErr_Occurred()) SWIG_fail;
21677 }
21678 resultobj = SWIG_Py_Void();
21679 return resultobj;
21680 fail:
21681 return NULL;
21682 }
21683
21684
21685 SWIGINTERN PyObject *_wrap_ConfigPathChanger_Name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21686 PyObject *resultobj = 0;
21687 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
21688 wxString *result = 0 ;
21689 void *argp1 = 0 ;
21690 int res1 = 0 ;
21691 PyObject *swig_obj[1] ;
21692
21693 if (!args) SWIG_fail;
21694 swig_obj[0] = args;
21695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, 0 | 0 );
21696 if (!SWIG_IsOK(res1)) {
21697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigPathChanger_Name" "', expected argument " "1"" of type '" "wxConfigPathChanger const *""'");
21698 }
21699 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
21700 {
21701 PyThreadState* __tstate = wxPyBeginAllowThreads();
21702 {
21703 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
21704 result = (wxString *) &_result_ref;
21705 }
21706 wxPyEndAllowThreads(__tstate);
21707 if (PyErr_Occurred()) SWIG_fail;
21708 }
21709 {
21710 #if wxUSE_UNICODE
21711 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
21712 #else
21713 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
21714 #endif
21715 }
21716 return resultobj;
21717 fail:
21718 return NULL;
21719 }
21720
21721
21722 SWIGINTERN PyObject *ConfigPathChanger_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21723 PyObject *obj;
21724 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21725 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigPathChanger, SWIG_NewClientData(obj));
21726 return SWIG_Py_Void();
21727 }
21728
21729 SWIGINTERN PyObject *ConfigPathChanger_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21730 return SWIG_Python_InitShadowInstance(args);
21731 }
21732
21733 SWIGINTERN PyObject *_wrap_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21734 PyObject *resultobj = 0;
21735 wxString *arg1 = 0 ;
21736 wxString result;
21737 bool temp1 = false ;
21738 PyObject * obj0 = 0 ;
21739 char * kwnames[] = {
21740 (char *) "sz", NULL
21741 };
21742
21743 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) SWIG_fail;
21744 {
21745 arg1 = wxString_in_helper(obj0);
21746 if (arg1 == NULL) SWIG_fail;
21747 temp1 = true;
21748 }
21749 {
21750 PyThreadState* __tstate = wxPyBeginAllowThreads();
21751 result = wxExpandEnvVars((wxString const &)*arg1);
21752 wxPyEndAllowThreads(__tstate);
21753 if (PyErr_Occurred()) SWIG_fail;
21754 }
21755 {
21756 #if wxUSE_UNICODE
21757 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21758 #else
21759 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21760 #endif
21761 }
21762 {
21763 if (temp1)
21764 delete arg1;
21765 }
21766 return resultobj;
21767 fail:
21768 {
21769 if (temp1)
21770 delete arg1;
21771 }
21772 return NULL;
21773 }
21774
21775
21776 SWIGINTERN int DefaultDateTimeFormat_set(PyObject *) {
21777 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTimeFormat is read-only.");
21778 return 1;
21779 }
21780
21781
21782 SWIGINTERN PyObject *DefaultDateTimeFormat_get(void) {
21783 PyObject *pyobj = 0;
21784
21785 {
21786 #if wxUSE_UNICODE
21787 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
21788 #else
21789 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
21790 #endif
21791 }
21792 return pyobj;
21793 }
21794
21795
21796 SWIGINTERN int DefaultTimeSpanFormat_set(PyObject *) {
21797 SWIG_Error(SWIG_AttributeError,"Variable DefaultTimeSpanFormat is read-only.");
21798 return 1;
21799 }
21800
21801
21802 SWIGINTERN PyObject *DefaultTimeSpanFormat_get(void) {
21803 PyObject *pyobj = 0;
21804
21805 {
21806 #if wxUSE_UNICODE
21807 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
21808 #else
21809 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
21810 #endif
21811 }
21812 return pyobj;
21813 }
21814
21815
21816 SWIGINTERN PyObject *_wrap_DateTime_SetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21817 PyObject *resultobj = 0;
21818 wxDateTime::Country arg1 ;
21819 int val1 ;
21820 int ecode1 = 0 ;
21821 PyObject * obj0 = 0 ;
21822 char * kwnames[] = {
21823 (char *) "country", NULL
21824 };
21825
21826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) SWIG_fail;
21827 ecode1 = SWIG_AsVal_int(obj0, &val1);
21828 if (!SWIG_IsOK(ecode1)) {
21829 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
21830 }
21831 arg1 = static_cast< wxDateTime::Country >(val1);
21832 {
21833 PyThreadState* __tstate = wxPyBeginAllowThreads();
21834 wxDateTime::SetCountry(arg1);
21835 wxPyEndAllowThreads(__tstate);
21836 if (PyErr_Occurred()) SWIG_fail;
21837 }
21838 resultobj = SWIG_Py_Void();
21839 return resultobj;
21840 fail:
21841 return NULL;
21842 }
21843
21844
21845 SWIGINTERN PyObject *_wrap_DateTime_GetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21846 PyObject *resultobj = 0;
21847 wxDateTime::Country result;
21848
21849 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetCountry",0,0,0)) SWIG_fail;
21850 {
21851 PyThreadState* __tstate = wxPyBeginAllowThreads();
21852 result = (wxDateTime::Country)wxDateTime::GetCountry();
21853 wxPyEndAllowThreads(__tstate);
21854 if (PyErr_Occurred()) SWIG_fail;
21855 }
21856 resultobj = SWIG_From_int(static_cast< int >(result));
21857 return resultobj;
21858 fail:
21859 return NULL;
21860 }
21861
21862
21863 SWIGINTERN PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21864 PyObject *resultobj = 0;
21865 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
21866 bool result;
21867 int val1 ;
21868 int ecode1 = 0 ;
21869 PyObject * obj0 = 0 ;
21870 char * kwnames[] = {
21871 (char *) "country", NULL
21872 };
21873
21874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) SWIG_fail;
21875 if (obj0) {
21876 ecode1 = SWIG_AsVal_int(obj0, &val1);
21877 if (!SWIG_IsOK(ecode1)) {
21878 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsWestEuropeanCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
21879 }
21880 arg1 = static_cast< wxDateTime::Country >(val1);
21881 }
21882 {
21883 PyThreadState* __tstate = wxPyBeginAllowThreads();
21884 result = (bool)wxDateTime::IsWestEuropeanCountry(arg1);
21885 wxPyEndAllowThreads(__tstate);
21886 if (PyErr_Occurred()) SWIG_fail;
21887 }
21888 {
21889 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21890 }
21891 return resultobj;
21892 fail:
21893 return NULL;
21894 }
21895
21896
21897 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21898 PyObject *resultobj = 0;
21899 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
21900 int result;
21901 int val1 ;
21902 int ecode1 = 0 ;
21903 PyObject * obj0 = 0 ;
21904 char * kwnames[] = {
21905 (char *) "cal", NULL
21906 };
21907
21908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) SWIG_fail;
21909 if (obj0) {
21910 ecode1 = SWIG_AsVal_int(obj0, &val1);
21911 if (!SWIG_IsOK(ecode1)) {
21912 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentYear" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
21913 }
21914 arg1 = static_cast< wxDateTime::Calendar >(val1);
21915 }
21916 {
21917 PyThreadState* __tstate = wxPyBeginAllowThreads();
21918 result = (int)wxDateTime::GetCurrentYear(arg1);
21919 wxPyEndAllowThreads(__tstate);
21920 if (PyErr_Occurred()) SWIG_fail;
21921 }
21922 resultobj = SWIG_From_int(static_cast< int >(result));
21923 return resultobj;
21924 fail:
21925 return NULL;
21926 }
21927
21928
21929 SWIGINTERN PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21930 PyObject *resultobj = 0;
21931 int arg1 ;
21932 int result;
21933 int val1 ;
21934 int ecode1 = 0 ;
21935 PyObject * obj0 = 0 ;
21936 char * kwnames[] = {
21937 (char *) "year", NULL
21938 };
21939
21940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) SWIG_fail;
21941 ecode1 = SWIG_AsVal_int(obj0, &val1);
21942 if (!SWIG_IsOK(ecode1)) {
21943 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_ConvertYearToBC" "', expected argument " "1"" of type '" "int""'");
21944 }
21945 arg1 = static_cast< int >(val1);
21946 {
21947 PyThreadState* __tstate = wxPyBeginAllowThreads();
21948 result = (int)wxDateTime::ConvertYearToBC(arg1);
21949 wxPyEndAllowThreads(__tstate);
21950 if (PyErr_Occurred()) SWIG_fail;
21951 }
21952 resultobj = SWIG_From_int(static_cast< int >(result));
21953 return resultobj;
21954 fail:
21955 return NULL;
21956 }
21957
21958
21959 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21960 PyObject *resultobj = 0;
21961 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
21962 wxDateTime::Month result;
21963 int val1 ;
21964 int ecode1 = 0 ;
21965 PyObject * obj0 = 0 ;
21966 char * kwnames[] = {
21967 (char *) "cal", NULL
21968 };
21969
21970 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) SWIG_fail;
21971 if (obj0) {
21972 ecode1 = SWIG_AsVal_int(obj0, &val1);
21973 if (!SWIG_IsOK(ecode1)) {
21974 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentMonth" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
21975 }
21976 arg1 = static_cast< wxDateTime::Calendar >(val1);
21977 }
21978 {
21979 PyThreadState* __tstate = wxPyBeginAllowThreads();
21980 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth(arg1);
21981 wxPyEndAllowThreads(__tstate);
21982 if (PyErr_Occurred()) SWIG_fail;
21983 }
21984 resultobj = SWIG_From_int(static_cast< int >(result));
21985 return resultobj;
21986 fail:
21987 return NULL;
21988 }
21989
21990
21991 SWIGINTERN PyObject *_wrap_DateTime_IsLeapYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21992 PyObject *resultobj = 0;
21993 int arg1 = (int) wxDateTime::Inv_Year ;
21994 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
21995 bool result;
21996 int val1 ;
21997 int ecode1 = 0 ;
21998 int val2 ;
21999 int ecode2 = 0 ;
22000 PyObject * obj0 = 0 ;
22001 PyObject * obj1 = 0 ;
22002 char * kwnames[] = {
22003 (char *) "year",(char *) "cal", NULL
22004 };
22005
22006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) SWIG_fail;
22007 if (obj0) {
22008 ecode1 = SWIG_AsVal_int(obj0, &val1);
22009 if (!SWIG_IsOK(ecode1)) {
22010 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsLeapYear" "', expected argument " "1"" of type '" "int""'");
22011 }
22012 arg1 = static_cast< int >(val1);
22013 }
22014 if (obj1) {
22015 ecode2 = SWIG_AsVal_int(obj1, &val2);
22016 if (!SWIG_IsOK(ecode2)) {
22017 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsLeapYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
22018 }
22019 arg2 = static_cast< wxDateTime::Calendar >(val2);
22020 }
22021 {
22022 PyThreadState* __tstate = wxPyBeginAllowThreads();
22023 result = (bool)wxDateTime::IsLeapYear(arg1,arg2);
22024 wxPyEndAllowThreads(__tstate);
22025 if (PyErr_Occurred()) SWIG_fail;
22026 }
22027 {
22028 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22029 }
22030 return resultobj;
22031 fail:
22032 return NULL;
22033 }
22034
22035
22036 SWIGINTERN PyObject *_wrap_DateTime_GetCentury(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22037 PyObject *resultobj = 0;
22038 int arg1 = (int) wxDateTime::Inv_Year ;
22039 int result;
22040 int val1 ;
22041 int ecode1 = 0 ;
22042 PyObject * obj0 = 0 ;
22043 char * kwnames[] = {
22044 (char *) "year", NULL
22045 };
22046
22047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) SWIG_fail;
22048 if (obj0) {
22049 ecode1 = SWIG_AsVal_int(obj0, &val1);
22050 if (!SWIG_IsOK(ecode1)) {
22051 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCentury" "', expected argument " "1"" of type '" "int""'");
22052 }
22053 arg1 = static_cast< int >(val1);
22054 }
22055 {
22056 PyThreadState* __tstate = wxPyBeginAllowThreads();
22057 result = (int)wxDateTime::GetCentury(arg1);
22058 wxPyEndAllowThreads(__tstate);
22059 if (PyErr_Occurred()) SWIG_fail;
22060 }
22061 resultobj = SWIG_From_int(static_cast< int >(result));
22062 return resultobj;
22063 fail:
22064 return NULL;
22065 }
22066
22067
22068 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22069 PyObject *resultobj = 0;
22070 int arg1 ;
22071 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
22072 int result;
22073 int val1 ;
22074 int ecode1 = 0 ;
22075 int val2 ;
22076 int ecode2 = 0 ;
22077 PyObject * obj0 = 0 ;
22078 PyObject * obj1 = 0 ;
22079 char * kwnames[] = {
22080 (char *) "year",(char *) "cal", NULL
22081 };
22082
22083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) SWIG_fail;
22084 ecode1 = SWIG_AsVal_int(obj0, &val1);
22085 if (!SWIG_IsOK(ecode1)) {
22086 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "1"" of type '" "int""'");
22087 }
22088 arg1 = static_cast< int >(val1);
22089 if (obj1) {
22090 ecode2 = SWIG_AsVal_int(obj1, &val2);
22091 if (!SWIG_IsOK(ecode2)) {
22092 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
22093 }
22094 arg2 = static_cast< wxDateTime::Calendar >(val2);
22095 }
22096 {
22097 PyThreadState* __tstate = wxPyBeginAllowThreads();
22098 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2);
22099 wxPyEndAllowThreads(__tstate);
22100 if (PyErr_Occurred()) SWIG_fail;
22101 }
22102 resultobj = SWIG_From_int(static_cast< int >(result));
22103 return resultobj;
22104 fail:
22105 return NULL;
22106 }
22107
22108
22109 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22110 PyObject *resultobj = 0;
22111 wxDateTime::Month arg1 ;
22112 int arg2 = (int) wxDateTime::Inv_Year ;
22113 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
22114 int result;
22115 int val1 ;
22116 int ecode1 = 0 ;
22117 int val2 ;
22118 int ecode2 = 0 ;
22119 int val3 ;
22120 int ecode3 = 0 ;
22121 PyObject * obj0 = 0 ;
22122 PyObject * obj1 = 0 ;
22123 PyObject * obj2 = 0 ;
22124 char * kwnames[] = {
22125 (char *) "month",(char *) "year",(char *) "cal", NULL
22126 };
22127
22128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22129 ecode1 = SWIG_AsVal_int(obj0, &val1);
22130 if (!SWIG_IsOK(ecode1)) {
22131 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
22132 }
22133 arg1 = static_cast< wxDateTime::Month >(val1);
22134 if (obj1) {
22135 ecode2 = SWIG_AsVal_int(obj1, &val2);
22136 if (!SWIG_IsOK(ecode2)) {
22137 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "2"" of type '" "int""'");
22138 }
22139 arg2 = static_cast< int >(val2);
22140 }
22141 if (obj2) {
22142 ecode3 = SWIG_AsVal_int(obj2, &val3);
22143 if (!SWIG_IsOK(ecode3)) {
22144 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "3"" of type '" "wxDateTime::Calendar""'");
22145 }
22146 arg3 = static_cast< wxDateTime::Calendar >(val3);
22147 }
22148 {
22149 PyThreadState* __tstate = wxPyBeginAllowThreads();
22150 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2,arg3);
22151 wxPyEndAllowThreads(__tstate);
22152 if (PyErr_Occurred()) SWIG_fail;
22153 }
22154 resultobj = SWIG_From_int(static_cast< int >(result));
22155 return resultobj;
22156 fail:
22157 return NULL;
22158 }
22159
22160
22161 SWIGINTERN PyObject *_wrap_DateTime_GetMonthName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22162 PyObject *resultobj = 0;
22163 wxDateTime::Month arg1 ;
22164 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
22165 wxString result;
22166 int val1 ;
22167 int ecode1 = 0 ;
22168 int val2 ;
22169 int ecode2 = 0 ;
22170 PyObject * obj0 = 0 ;
22171 PyObject * obj1 = 0 ;
22172 char * kwnames[] = {
22173 (char *) "month",(char *) "flags", NULL
22174 };
22175
22176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) SWIG_fail;
22177 ecode1 = SWIG_AsVal_int(obj0, &val1);
22178 if (!SWIG_IsOK(ecode1)) {
22179 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetMonthName" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
22180 }
22181 arg1 = static_cast< wxDateTime::Month >(val1);
22182 if (obj1) {
22183 ecode2 = SWIG_AsVal_int(obj1, &val2);
22184 if (!SWIG_IsOK(ecode2)) {
22185 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetMonthName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
22186 }
22187 arg2 = static_cast< wxDateTime::NameFlags >(val2);
22188 }
22189 {
22190 PyThreadState* __tstate = wxPyBeginAllowThreads();
22191 result = wxDateTime::GetMonthName(arg1,arg2);
22192 wxPyEndAllowThreads(__tstate);
22193 if (PyErr_Occurred()) SWIG_fail;
22194 }
22195 {
22196 #if wxUSE_UNICODE
22197 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22198 #else
22199 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22200 #endif
22201 }
22202 return resultobj;
22203 fail:
22204 return NULL;
22205 }
22206
22207
22208 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22209 PyObject *resultobj = 0;
22210 wxDateTime::WeekDay arg1 ;
22211 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
22212 wxString result;
22213 int val1 ;
22214 int ecode1 = 0 ;
22215 int val2 ;
22216 int ecode2 = 0 ;
22217 PyObject * obj0 = 0 ;
22218 PyObject * obj1 = 0 ;
22219 char * kwnames[] = {
22220 (char *) "weekday",(char *) "flags", NULL
22221 };
22222
22223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) SWIG_fail;
22224 ecode1 = SWIG_AsVal_int(obj0, &val1);
22225 if (!SWIG_IsOK(ecode1)) {
22226 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetWeekDayName" "', expected argument " "1"" of type '" "wxDateTime::WeekDay""'");
22227 }
22228 arg1 = static_cast< wxDateTime::WeekDay >(val1);
22229 if (obj1) {
22230 ecode2 = SWIG_AsVal_int(obj1, &val2);
22231 if (!SWIG_IsOK(ecode2)) {
22232 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
22233 }
22234 arg2 = static_cast< wxDateTime::NameFlags >(val2);
22235 }
22236 {
22237 PyThreadState* __tstate = wxPyBeginAllowThreads();
22238 result = wxDateTime::GetWeekDayName(arg1,arg2);
22239 wxPyEndAllowThreads(__tstate);
22240 if (PyErr_Occurred()) SWIG_fail;
22241 }
22242 {
22243 #if wxUSE_UNICODE
22244 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22245 #else
22246 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22247 #endif
22248 }
22249 return resultobj;
22250 fail:
22251 return NULL;
22252 }
22253
22254
22255 SWIGINTERN PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22256 PyObject *resultobj = 0;
22257 PyObject *result = 0 ;
22258
22259 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetAmPmStrings",0,0,0)) SWIG_fail;
22260 {
22261 PyThreadState* __tstate = wxPyBeginAllowThreads();
22262 result = (PyObject *)wxDateTime_GetAmPmStrings();
22263 wxPyEndAllowThreads(__tstate);
22264 if (PyErr_Occurred()) SWIG_fail;
22265 }
22266 resultobj = result;
22267 return resultobj;
22268 fail:
22269 return NULL;
22270 }
22271
22272
22273 SWIGINTERN PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22274 PyObject *resultobj = 0;
22275 int arg1 = (int) wxDateTime::Inv_Year ;
22276 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
22277 bool result;
22278 int val1 ;
22279 int ecode1 = 0 ;
22280 int val2 ;
22281 int ecode2 = 0 ;
22282 PyObject * obj0 = 0 ;
22283 PyObject * obj1 = 0 ;
22284 char * kwnames[] = {
22285 (char *) "year",(char *) "country", NULL
22286 };
22287
22288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) SWIG_fail;
22289 if (obj0) {
22290 ecode1 = SWIG_AsVal_int(obj0, &val1);
22291 if (!SWIG_IsOK(ecode1)) {
22292 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "1"" of type '" "int""'");
22293 }
22294 arg1 = static_cast< int >(val1);
22295 }
22296 if (obj1) {
22297 ecode2 = SWIG_AsVal_int(obj1, &val2);
22298 if (!SWIG_IsOK(ecode2)) {
22299 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
22300 }
22301 arg2 = static_cast< wxDateTime::Country >(val2);
22302 }
22303 {
22304 PyThreadState* __tstate = wxPyBeginAllowThreads();
22305 result = (bool)wxDateTime::IsDSTApplicable(arg1,arg2);
22306 wxPyEndAllowThreads(__tstate);
22307 if (PyErr_Occurred()) SWIG_fail;
22308 }
22309 {
22310 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22311 }
22312 return resultobj;
22313 fail:
22314 return NULL;
22315 }
22316
22317
22318 SWIGINTERN PyObject *_wrap_DateTime_GetBeginDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22319 PyObject *resultobj = 0;
22320 int arg1 = (int) wxDateTime::Inv_Year ;
22321 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
22322 wxDateTime result;
22323 int val1 ;
22324 int ecode1 = 0 ;
22325 int val2 ;
22326 int ecode2 = 0 ;
22327 PyObject * obj0 = 0 ;
22328 PyObject * obj1 = 0 ;
22329 char * kwnames[] = {
22330 (char *) "year",(char *) "country", NULL
22331 };
22332
22333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) SWIG_fail;
22334 if (obj0) {
22335 ecode1 = SWIG_AsVal_int(obj0, &val1);
22336 if (!SWIG_IsOK(ecode1)) {
22337 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetBeginDST" "', expected argument " "1"" of type '" "int""'");
22338 }
22339 arg1 = static_cast< int >(val1);
22340 }
22341 if (obj1) {
22342 ecode2 = SWIG_AsVal_int(obj1, &val2);
22343 if (!SWIG_IsOK(ecode2)) {
22344 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetBeginDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
22345 }
22346 arg2 = static_cast< wxDateTime::Country >(val2);
22347 }
22348 {
22349 PyThreadState* __tstate = wxPyBeginAllowThreads();
22350 result = wxDateTime::GetBeginDST(arg1,arg2);
22351 wxPyEndAllowThreads(__tstate);
22352 if (PyErr_Occurred()) SWIG_fail;
22353 }
22354 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22355 return resultobj;
22356 fail:
22357 return NULL;
22358 }
22359
22360
22361 SWIGINTERN PyObject *_wrap_DateTime_GetEndDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22362 PyObject *resultobj = 0;
22363 int arg1 = (int) wxDateTime::Inv_Year ;
22364 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
22365 wxDateTime result;
22366 int val1 ;
22367 int ecode1 = 0 ;
22368 int val2 ;
22369 int ecode2 = 0 ;
22370 PyObject * obj0 = 0 ;
22371 PyObject * obj1 = 0 ;
22372 char * kwnames[] = {
22373 (char *) "year",(char *) "country", NULL
22374 };
22375
22376 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) SWIG_fail;
22377 if (obj0) {
22378 ecode1 = SWIG_AsVal_int(obj0, &val1);
22379 if (!SWIG_IsOK(ecode1)) {
22380 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetEndDST" "', expected argument " "1"" of type '" "int""'");
22381 }
22382 arg1 = static_cast< int >(val1);
22383 }
22384 if (obj1) {
22385 ecode2 = SWIG_AsVal_int(obj1, &val2);
22386 if (!SWIG_IsOK(ecode2)) {
22387 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetEndDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
22388 }
22389 arg2 = static_cast< wxDateTime::Country >(val2);
22390 }
22391 {
22392 PyThreadState* __tstate = wxPyBeginAllowThreads();
22393 result = wxDateTime::GetEndDST(arg1,arg2);
22394 wxPyEndAllowThreads(__tstate);
22395 if (PyErr_Occurred()) SWIG_fail;
22396 }
22397 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22398 return resultobj;
22399 fail:
22400 return NULL;
22401 }
22402
22403
22404 SWIGINTERN PyObject *_wrap_DateTime_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22405 PyObject *resultobj = 0;
22406 wxDateTime result;
22407
22408 if (!SWIG_Python_UnpackTuple(args,"DateTime_Now",0,0,0)) SWIG_fail;
22409 {
22410 PyThreadState* __tstate = wxPyBeginAllowThreads();
22411 result = wxDateTime::Now();
22412 wxPyEndAllowThreads(__tstate);
22413 if (PyErr_Occurred()) SWIG_fail;
22414 }
22415 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22416 return resultobj;
22417 fail:
22418 return NULL;
22419 }
22420
22421
22422 SWIGINTERN PyObject *_wrap_DateTime_UNow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22423 PyObject *resultobj = 0;
22424 wxDateTime result;
22425
22426 if (!SWIG_Python_UnpackTuple(args,"DateTime_UNow",0,0,0)) SWIG_fail;
22427 {
22428 PyThreadState* __tstate = wxPyBeginAllowThreads();
22429 result = wxDateTime::UNow();
22430 wxPyEndAllowThreads(__tstate);
22431 if (PyErr_Occurred()) SWIG_fail;
22432 }
22433 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22434 return resultobj;
22435 fail:
22436 return NULL;
22437 }
22438
22439
22440 SWIGINTERN PyObject *_wrap_DateTime_Today(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22441 PyObject *resultobj = 0;
22442 wxDateTime result;
22443
22444 if (!SWIG_Python_UnpackTuple(args,"DateTime_Today",0,0,0)) SWIG_fail;
22445 {
22446 PyThreadState* __tstate = wxPyBeginAllowThreads();
22447 result = wxDateTime::Today();
22448 wxPyEndAllowThreads(__tstate);
22449 if (PyErr_Occurred()) SWIG_fail;
22450 }
22451 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22452 return resultobj;
22453 fail:
22454 return NULL;
22455 }
22456
22457
22458 SWIGINTERN PyObject *_wrap_new_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22459 PyObject *resultobj = 0;
22460 wxDateTime *result = 0 ;
22461
22462 if (!SWIG_Python_UnpackTuple(args,"new_DateTime",0,0,0)) SWIG_fail;
22463 {
22464 PyThreadState* __tstate = wxPyBeginAllowThreads();
22465 result = (wxDateTime *)new wxDateTime();
22466 wxPyEndAllowThreads(__tstate);
22467 if (PyErr_Occurred()) SWIG_fail;
22468 }
22469 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_NEW | 0 );
22470 return resultobj;
22471 fail:
22472 return NULL;
22473 }
22474
22475
22476 SWIGINTERN PyObject *_wrap_new_DateTimeFromTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22477 PyObject *resultobj = 0;
22478 time_t arg1 ;
22479 wxDateTime *result = 0 ;
22480 unsigned int val1 ;
22481 int ecode1 = 0 ;
22482 PyObject * obj0 = 0 ;
22483 char * kwnames[] = {
22484 (char *) "timet", NULL
22485 };
22486
22487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) SWIG_fail;
22488 ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
22489 if (!SWIG_IsOK(ecode1)) {
22490 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromTimeT" "', expected argument " "1"" of type '" "time_t""'");
22491 }
22492 arg1 = static_cast< time_t >(val1);
22493 {
22494 PyThreadState* __tstate = wxPyBeginAllowThreads();
22495 result = (wxDateTime *)new wxDateTime(arg1);
22496 wxPyEndAllowThreads(__tstate);
22497 if (PyErr_Occurred()) SWIG_fail;
22498 }
22499 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22500 return resultobj;
22501 fail:
22502 return NULL;
22503 }
22504
22505
22506 SWIGINTERN PyObject *_wrap_new_DateTimeFromJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22507 PyObject *resultobj = 0;
22508 double arg1 ;
22509 wxDateTime *result = 0 ;
22510 double val1 ;
22511 int ecode1 = 0 ;
22512 PyObject * obj0 = 0 ;
22513 char * kwnames[] = {
22514 (char *) "jdn", NULL
22515 };
22516
22517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) SWIG_fail;
22518 ecode1 = SWIG_AsVal_double(obj0, &val1);
22519 if (!SWIG_IsOK(ecode1)) {
22520 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromJDN" "', expected argument " "1"" of type '" "double""'");
22521 }
22522 arg1 = static_cast< double >(val1);
22523 {
22524 PyThreadState* __tstate = wxPyBeginAllowThreads();
22525 result = (wxDateTime *)new wxDateTime(arg1);
22526 wxPyEndAllowThreads(__tstate);
22527 if (PyErr_Occurred()) SWIG_fail;
22528 }
22529 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22530 return resultobj;
22531 fail:
22532 return NULL;
22533 }
22534
22535
22536 SWIGINTERN PyObject *_wrap_new_DateTimeFromHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22537 PyObject *resultobj = 0;
22538 int arg1 ;
22539 int arg2 = (int) 0 ;
22540 int arg3 = (int) 0 ;
22541 int arg4 = (int) 0 ;
22542 wxDateTime *result = 0 ;
22543 int val1 ;
22544 int ecode1 = 0 ;
22545 int val2 ;
22546 int ecode2 = 0 ;
22547 int val3 ;
22548 int ecode3 = 0 ;
22549 int val4 ;
22550 int ecode4 = 0 ;
22551 PyObject * obj0 = 0 ;
22552 PyObject * obj1 = 0 ;
22553 PyObject * obj2 = 0 ;
22554 PyObject * obj3 = 0 ;
22555 char * kwnames[] = {
22556 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
22557 };
22558
22559 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
22560 ecode1 = SWIG_AsVal_int(obj0, &val1);
22561 if (!SWIG_IsOK(ecode1)) {
22562 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromHMS" "', expected argument " "1"" of type '" "int""'");
22563 }
22564 arg1 = static_cast< int >(val1);
22565 if (obj1) {
22566 ecode2 = SWIG_AsVal_int(obj1, &val2);
22567 if (!SWIG_IsOK(ecode2)) {
22568 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromHMS" "', expected argument " "2"" of type '" "int""'");
22569 }
22570 arg2 = static_cast< int >(val2);
22571 }
22572 if (obj2) {
22573 ecode3 = SWIG_AsVal_int(obj2, &val3);
22574 if (!SWIG_IsOK(ecode3)) {
22575 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromHMS" "', expected argument " "3"" of type '" "int""'");
22576 }
22577 arg3 = static_cast< int >(val3);
22578 }
22579 if (obj3) {
22580 ecode4 = SWIG_AsVal_int(obj3, &val4);
22581 if (!SWIG_IsOK(ecode4)) {
22582 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromHMS" "', expected argument " "4"" of type '" "int""'");
22583 }
22584 arg4 = static_cast< int >(val4);
22585 }
22586 {
22587 PyThreadState* __tstate = wxPyBeginAllowThreads();
22588 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
22589 wxPyEndAllowThreads(__tstate);
22590 if (PyErr_Occurred()) SWIG_fail;
22591 }
22592 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22593 return resultobj;
22594 fail:
22595 return NULL;
22596 }
22597
22598
22599 SWIGINTERN PyObject *_wrap_new_DateTimeFromDMY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22600 PyObject *resultobj = 0;
22601 int arg1 ;
22602 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
22603 int arg3 = (int) wxDateTime::Inv_Year ;
22604 int arg4 = (int) 0 ;
22605 int arg5 = (int) 0 ;
22606 int arg6 = (int) 0 ;
22607 int arg7 = (int) 0 ;
22608 wxDateTime *result = 0 ;
22609 int val1 ;
22610 int ecode1 = 0 ;
22611 int val2 ;
22612 int ecode2 = 0 ;
22613 int val3 ;
22614 int ecode3 = 0 ;
22615 int val4 ;
22616 int ecode4 = 0 ;
22617 int val5 ;
22618 int ecode5 = 0 ;
22619 int val6 ;
22620 int ecode6 = 0 ;
22621 int val7 ;
22622 int ecode7 = 0 ;
22623 PyObject * obj0 = 0 ;
22624 PyObject * obj1 = 0 ;
22625 PyObject * obj2 = 0 ;
22626 PyObject * obj3 = 0 ;
22627 PyObject * obj4 = 0 ;
22628 PyObject * obj5 = 0 ;
22629 PyObject * obj6 = 0 ;
22630 char * kwnames[] = {
22631 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
22632 };
22633
22634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
22635 ecode1 = SWIG_AsVal_int(obj0, &val1);
22636 if (!SWIG_IsOK(ecode1)) {
22637 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromDMY" "', expected argument " "1"" of type '" "int""'");
22638 }
22639 arg1 = static_cast< int >(val1);
22640 if (obj1) {
22641 ecode2 = SWIG_AsVal_int(obj1, &val2);
22642 if (!SWIG_IsOK(ecode2)) {
22643 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromDMY" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
22644 }
22645 arg2 = static_cast< wxDateTime::Month >(val2);
22646 }
22647 if (obj2) {
22648 ecode3 = SWIG_AsVal_int(obj2, &val3);
22649 if (!SWIG_IsOK(ecode3)) {
22650 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromDMY" "', expected argument " "3"" of type '" "int""'");
22651 }
22652 arg3 = static_cast< int >(val3);
22653 }
22654 if (obj3) {
22655 ecode4 = SWIG_AsVal_int(obj3, &val4);
22656 if (!SWIG_IsOK(ecode4)) {
22657 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromDMY" "', expected argument " "4"" of type '" "int""'");
22658 }
22659 arg4 = static_cast< int >(val4);
22660 }
22661 if (obj4) {
22662 ecode5 = SWIG_AsVal_int(obj4, &val5);
22663 if (!SWIG_IsOK(ecode5)) {
22664 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DateTimeFromDMY" "', expected argument " "5"" of type '" "int""'");
22665 }
22666 arg5 = static_cast< int >(val5);
22667 }
22668 if (obj5) {
22669 ecode6 = SWIG_AsVal_int(obj5, &val6);
22670 if (!SWIG_IsOK(ecode6)) {
22671 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DateTimeFromDMY" "', expected argument " "6"" of type '" "int""'");
22672 }
22673 arg6 = static_cast< int >(val6);
22674 }
22675 if (obj6) {
22676 ecode7 = SWIG_AsVal_int(obj6, &val7);
22677 if (!SWIG_IsOK(ecode7)) {
22678 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_DateTimeFromDMY" "', expected argument " "7"" of type '" "int""'");
22679 }
22680 arg7 = static_cast< int >(val7);
22681 }
22682 {
22683 PyThreadState* __tstate = wxPyBeginAllowThreads();
22684 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
22685 wxPyEndAllowThreads(__tstate);
22686 if (PyErr_Occurred()) SWIG_fail;
22687 }
22688 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22689 return resultobj;
22690 fail:
22691 return NULL;
22692 }
22693
22694
22695 SWIGINTERN PyObject *_wrap_new_DateTimeFromDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22696 PyObject *resultobj = 0;
22697 wxDateTime *arg1 = 0 ;
22698 wxDateTime *result = 0 ;
22699 void *argp1 = 0 ;
22700 int res1 = 0 ;
22701 PyObject * obj0 = 0 ;
22702 char * kwnames[] = {
22703 (char *) "date", NULL
22704 };
22705
22706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromDateTime",kwnames,&obj0)) SWIG_fail;
22707 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDateTime, 0 | 0);
22708 if (!SWIG_IsOK(res1)) {
22709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
22710 }
22711 if (!argp1) {
22712 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
22713 }
22714 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22715 {
22716 PyThreadState* __tstate = wxPyBeginAllowThreads();
22717 result = (wxDateTime *)new wxDateTime((wxDateTime const &)*arg1);
22718 wxPyEndAllowThreads(__tstate);
22719 if (PyErr_Occurred()) SWIG_fail;
22720 }
22721 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22722 return resultobj;
22723 fail:
22724 return NULL;
22725 }
22726
22727
22728 SWIGINTERN PyObject *_wrap_delete_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22729 PyObject *resultobj = 0;
22730 wxDateTime *arg1 = (wxDateTime *) 0 ;
22731 void *argp1 = 0 ;
22732 int res1 = 0 ;
22733 PyObject *swig_obj[1] ;
22734
22735 if (!args) SWIG_fail;
22736 swig_obj[0] = args;
22737 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
22738 if (!SWIG_IsOK(res1)) {
22739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
22740 }
22741 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22742 {
22743 PyThreadState* __tstate = wxPyBeginAllowThreads();
22744 delete arg1;
22745
22746 wxPyEndAllowThreads(__tstate);
22747 if (PyErr_Occurred()) SWIG_fail;
22748 }
22749 resultobj = SWIG_Py_Void();
22750 return resultobj;
22751 fail:
22752 return NULL;
22753 }
22754
22755
22756 SWIGINTERN PyObject *_wrap_DateTime_SetToCurrent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22757 PyObject *resultobj = 0;
22758 wxDateTime *arg1 = (wxDateTime *) 0 ;
22759 wxDateTime *result = 0 ;
22760 void *argp1 = 0 ;
22761 int res1 = 0 ;
22762 PyObject *swig_obj[1] ;
22763
22764 if (!args) SWIG_fail;
22765 swig_obj[0] = args;
22766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
22767 if (!SWIG_IsOK(res1)) {
22768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToCurrent" "', expected argument " "1"" of type '" "wxDateTime *""'");
22769 }
22770 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22771 {
22772 PyThreadState* __tstate = wxPyBeginAllowThreads();
22773 {
22774 wxDateTime &_result_ref = (arg1)->SetToCurrent();
22775 result = (wxDateTime *) &_result_ref;
22776 }
22777 wxPyEndAllowThreads(__tstate);
22778 if (PyErr_Occurred()) SWIG_fail;
22779 }
22780 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
22781 return resultobj;
22782 fail:
22783 return NULL;
22784 }
22785
22786
22787 SWIGINTERN PyObject *_wrap_DateTime_SetTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22788 PyObject *resultobj = 0;
22789 wxDateTime *arg1 = (wxDateTime *) 0 ;
22790 time_t arg2 ;
22791 wxDateTime *result = 0 ;
22792 void *argp1 = 0 ;
22793 int res1 = 0 ;
22794 unsigned int val2 ;
22795 int ecode2 = 0 ;
22796 PyObject * obj0 = 0 ;
22797 PyObject * obj1 = 0 ;
22798 char * kwnames[] = {
22799 (char *) "self",(char *) "timet", NULL
22800 };
22801
22802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) SWIG_fail;
22803 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
22804 if (!SWIG_IsOK(res1)) {
22805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetTimeT" "', expected argument " "1"" of type '" "wxDateTime *""'");
22806 }
22807 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22808 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
22809 if (!SWIG_IsOK(ecode2)) {
22810 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetTimeT" "', expected argument " "2"" of type '" "time_t""'");
22811 }
22812 arg2 = static_cast< time_t >(val2);
22813 {
22814 PyThreadState* __tstate = wxPyBeginAllowThreads();
22815 {
22816 wxDateTime &_result_ref = (arg1)->Set(arg2);
22817 result = (wxDateTime *) &_result_ref;
22818 }
22819 wxPyEndAllowThreads(__tstate);
22820 if (PyErr_Occurred()) SWIG_fail;
22821 }
22822 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
22823 return resultobj;
22824 fail:
22825 return NULL;
22826 }
22827
22828
22829 SWIGINTERN PyObject *_wrap_DateTime_SetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22830 PyObject *resultobj = 0;
22831 wxDateTime *arg1 = (wxDateTime *) 0 ;
22832 double arg2 ;
22833 wxDateTime *result = 0 ;
22834 void *argp1 = 0 ;
22835 int res1 = 0 ;
22836 double val2 ;
22837 int ecode2 = 0 ;
22838 PyObject * obj0 = 0 ;
22839 PyObject * obj1 = 0 ;
22840 char * kwnames[] = {
22841 (char *) "self",(char *) "jdn", NULL
22842 };
22843
22844 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) SWIG_fail;
22845 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
22846 if (!SWIG_IsOK(res1)) {
22847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
22848 }
22849 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22850 ecode2 = SWIG_AsVal_double(obj1, &val2);
22851 if (!SWIG_IsOK(ecode2)) {
22852 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetJDN" "', expected argument " "2"" of type '" "double""'");
22853 }
22854 arg2 = static_cast< double >(val2);
22855 {
22856 PyThreadState* __tstate = wxPyBeginAllowThreads();
22857 {
22858 wxDateTime &_result_ref = (arg1)->Set(arg2);
22859 result = (wxDateTime *) &_result_ref;
22860 }
22861 wxPyEndAllowThreads(__tstate);
22862 if (PyErr_Occurred()) SWIG_fail;
22863 }
22864 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
22865 return resultobj;
22866 fail:
22867 return NULL;
22868 }
22869
22870
22871 SWIGINTERN PyObject *_wrap_DateTime_SetHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22872 PyObject *resultobj = 0;
22873 wxDateTime *arg1 = (wxDateTime *) 0 ;
22874 int arg2 ;
22875 int arg3 = (int) 0 ;
22876 int arg4 = (int) 0 ;
22877 int arg5 = (int) 0 ;
22878 wxDateTime *result = 0 ;
22879 void *argp1 = 0 ;
22880 int res1 = 0 ;
22881 int val2 ;
22882 int ecode2 = 0 ;
22883 int val3 ;
22884 int ecode3 = 0 ;
22885 int val4 ;
22886 int ecode4 = 0 ;
22887 int val5 ;
22888 int ecode5 = 0 ;
22889 PyObject * obj0 = 0 ;
22890 PyObject * obj1 = 0 ;
22891 PyObject * obj2 = 0 ;
22892 PyObject * obj3 = 0 ;
22893 PyObject * obj4 = 0 ;
22894 char * kwnames[] = {
22895 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
22896 };
22897
22898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
22899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
22900 if (!SWIG_IsOK(res1)) {
22901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHMS" "', expected argument " "1"" of type '" "wxDateTime *""'");
22902 }
22903 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22904 ecode2 = SWIG_AsVal_int(obj1, &val2);
22905 if (!SWIG_IsOK(ecode2)) {
22906 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHMS" "', expected argument " "2"" of type '" "int""'");
22907 }
22908 arg2 = static_cast< int >(val2);
22909 if (obj2) {
22910 ecode3 = SWIG_AsVal_int(obj2, &val3);
22911 if (!SWIG_IsOK(ecode3)) {
22912 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetHMS" "', expected argument " "3"" of type '" "int""'");
22913 }
22914 arg3 = static_cast< int >(val3);
22915 }
22916 if (obj3) {
22917 ecode4 = SWIG_AsVal_int(obj3, &val4);
22918 if (!SWIG_IsOK(ecode4)) {
22919 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetHMS" "', expected argument " "4"" of type '" "int""'");
22920 }
22921 arg4 = static_cast< int >(val4);
22922 }
22923 if (obj4) {
22924 ecode5 = SWIG_AsVal_int(obj4, &val5);
22925 if (!SWIG_IsOK(ecode5)) {
22926 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetHMS" "', expected argument " "5"" of type '" "int""'");
22927 }
22928 arg5 = static_cast< int >(val5);
22929 }
22930 {
22931 PyThreadState* __tstate = wxPyBeginAllowThreads();
22932 {
22933 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
22934 result = (wxDateTime *) &_result_ref;
22935 }
22936 wxPyEndAllowThreads(__tstate);
22937 if (PyErr_Occurred()) SWIG_fail;
22938 }
22939 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
22940 return resultobj;
22941 fail:
22942 return NULL;
22943 }
22944
22945
22946 SWIGINTERN PyObject *_wrap_DateTime_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22947 PyObject *resultobj = 0;
22948 wxDateTime *arg1 = (wxDateTime *) 0 ;
22949 int arg2 ;
22950 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
22951 int arg4 = (int) wxDateTime::Inv_Year ;
22952 int arg5 = (int) 0 ;
22953 int arg6 = (int) 0 ;
22954 int arg7 = (int) 0 ;
22955 int arg8 = (int) 0 ;
22956 wxDateTime *result = 0 ;
22957 void *argp1 = 0 ;
22958 int res1 = 0 ;
22959 int val2 ;
22960 int ecode2 = 0 ;
22961 int val3 ;
22962 int ecode3 = 0 ;
22963 int val4 ;
22964 int ecode4 = 0 ;
22965 int val5 ;
22966 int ecode5 = 0 ;
22967 int val6 ;
22968 int ecode6 = 0 ;
22969 int val7 ;
22970 int ecode7 = 0 ;
22971 int val8 ;
22972 int ecode8 = 0 ;
22973 PyObject * obj0 = 0 ;
22974 PyObject * obj1 = 0 ;
22975 PyObject * obj2 = 0 ;
22976 PyObject * obj3 = 0 ;
22977 PyObject * obj4 = 0 ;
22978 PyObject * obj5 = 0 ;
22979 PyObject * obj6 = 0 ;
22980 PyObject * obj7 = 0 ;
22981 char * kwnames[] = {
22982 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
22983 };
22984
22985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
22986 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
22987 if (!SWIG_IsOK(res1)) {
22988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Set" "', expected argument " "1"" of type '" "wxDateTime *""'");
22989 }
22990 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22991 ecode2 = SWIG_AsVal_int(obj1, &val2);
22992 if (!SWIG_IsOK(ecode2)) {
22993 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_Set" "', expected argument " "2"" of type '" "int""'");
22994 }
22995 arg2 = static_cast< int >(val2);
22996 if (obj2) {
22997 ecode3 = SWIG_AsVal_int(obj2, &val3);
22998 if (!SWIG_IsOK(ecode3)) {
22999 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_Set" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
23000 }
23001 arg3 = static_cast< wxDateTime::Month >(val3);
23002 }
23003 if (obj3) {
23004 ecode4 = SWIG_AsVal_int(obj3, &val4);
23005 if (!SWIG_IsOK(ecode4)) {
23006 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_Set" "', expected argument " "4"" of type '" "int""'");
23007 }
23008 arg4 = static_cast< int >(val4);
23009 }
23010 if (obj4) {
23011 ecode5 = SWIG_AsVal_int(obj4, &val5);
23012 if (!SWIG_IsOK(ecode5)) {
23013 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_Set" "', expected argument " "5"" of type '" "int""'");
23014 }
23015 arg5 = static_cast< int >(val5);
23016 }
23017 if (obj5) {
23018 ecode6 = SWIG_AsVal_int(obj5, &val6);
23019 if (!SWIG_IsOK(ecode6)) {
23020 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DateTime_Set" "', expected argument " "6"" of type '" "int""'");
23021 }
23022 arg6 = static_cast< int >(val6);
23023 }
23024 if (obj6) {
23025 ecode7 = SWIG_AsVal_int(obj6, &val7);
23026 if (!SWIG_IsOK(ecode7)) {
23027 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "DateTime_Set" "', expected argument " "7"" of type '" "int""'");
23028 }
23029 arg7 = static_cast< int >(val7);
23030 }
23031 if (obj7) {
23032 ecode8 = SWIG_AsVal_int(obj7, &val8);
23033 if (!SWIG_IsOK(ecode8)) {
23034 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "DateTime_Set" "', expected argument " "8"" of type '" "int""'");
23035 }
23036 arg8 = static_cast< int >(val8);
23037 }
23038 {
23039 PyThreadState* __tstate = wxPyBeginAllowThreads();
23040 {
23041 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
23042 result = (wxDateTime *) &_result_ref;
23043 }
23044 wxPyEndAllowThreads(__tstate);
23045 if (PyErr_Occurred()) SWIG_fail;
23046 }
23047 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23048 return resultobj;
23049 fail:
23050 return NULL;
23051 }
23052
23053
23054 SWIGINTERN PyObject *_wrap_DateTime_ResetTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23055 PyObject *resultobj = 0;
23056 wxDateTime *arg1 = (wxDateTime *) 0 ;
23057 wxDateTime *result = 0 ;
23058 void *argp1 = 0 ;
23059 int res1 = 0 ;
23060 PyObject *swig_obj[1] ;
23061
23062 if (!args) SWIG_fail;
23063 swig_obj[0] = args;
23064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23065 if (!SWIG_IsOK(res1)) {
23066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ResetTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
23067 }
23068 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23069 {
23070 PyThreadState* __tstate = wxPyBeginAllowThreads();
23071 {
23072 wxDateTime &_result_ref = (arg1)->ResetTime();
23073 result = (wxDateTime *) &_result_ref;
23074 }
23075 wxPyEndAllowThreads(__tstate);
23076 if (PyErr_Occurred()) SWIG_fail;
23077 }
23078 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23079 return resultobj;
23080 fail:
23081 return NULL;
23082 }
23083
23084
23085 SWIGINTERN PyObject *_wrap_DateTime_SetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23086 PyObject *resultobj = 0;
23087 wxDateTime *arg1 = (wxDateTime *) 0 ;
23088 int arg2 ;
23089 wxDateTime *result = 0 ;
23090 void *argp1 = 0 ;
23091 int res1 = 0 ;
23092 int val2 ;
23093 int ecode2 = 0 ;
23094 PyObject * obj0 = 0 ;
23095 PyObject * obj1 = 0 ;
23096 char * kwnames[] = {
23097 (char *) "self",(char *) "year", NULL
23098 };
23099
23100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) SWIG_fail;
23101 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23102 if (!SWIG_IsOK(res1)) {
23103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetYear" "', expected argument " "1"" of type '" "wxDateTime *""'");
23104 }
23105 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23106 ecode2 = SWIG_AsVal_int(obj1, &val2);
23107 if (!SWIG_IsOK(ecode2)) {
23108 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetYear" "', expected argument " "2"" of type '" "int""'");
23109 }
23110 arg2 = static_cast< int >(val2);
23111 {
23112 PyThreadState* __tstate = wxPyBeginAllowThreads();
23113 {
23114 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
23115 result = (wxDateTime *) &_result_ref;
23116 }
23117 wxPyEndAllowThreads(__tstate);
23118 if (PyErr_Occurred()) SWIG_fail;
23119 }
23120 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23121 return resultobj;
23122 fail:
23123 return NULL;
23124 }
23125
23126
23127 SWIGINTERN PyObject *_wrap_DateTime_SetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23128 PyObject *resultobj = 0;
23129 wxDateTime *arg1 = (wxDateTime *) 0 ;
23130 wxDateTime::Month arg2 ;
23131 wxDateTime *result = 0 ;
23132 void *argp1 = 0 ;
23133 int res1 = 0 ;
23134 int val2 ;
23135 int ecode2 = 0 ;
23136 PyObject * obj0 = 0 ;
23137 PyObject * obj1 = 0 ;
23138 char * kwnames[] = {
23139 (char *) "self",(char *) "month", NULL
23140 };
23141
23142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
23143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23144 if (!SWIG_IsOK(res1)) {
23145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMonth" "', expected argument " "1"" of type '" "wxDateTime *""'");
23146 }
23147 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23148 ecode2 = SWIG_AsVal_int(obj1, &val2);
23149 if (!SWIG_IsOK(ecode2)) {
23150 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMonth" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
23151 }
23152 arg2 = static_cast< wxDateTime::Month >(val2);
23153 {
23154 PyThreadState* __tstate = wxPyBeginAllowThreads();
23155 {
23156 wxDateTime &_result_ref = (arg1)->SetMonth(arg2);
23157 result = (wxDateTime *) &_result_ref;
23158 }
23159 wxPyEndAllowThreads(__tstate);
23160 if (PyErr_Occurred()) SWIG_fail;
23161 }
23162 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23163 return resultobj;
23164 fail:
23165 return NULL;
23166 }
23167
23168
23169 SWIGINTERN PyObject *_wrap_DateTime_SetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23170 PyObject *resultobj = 0;
23171 wxDateTime *arg1 = (wxDateTime *) 0 ;
23172 int arg2 ;
23173 wxDateTime *result = 0 ;
23174 void *argp1 = 0 ;
23175 int res1 = 0 ;
23176 int val2 ;
23177 int ecode2 = 0 ;
23178 PyObject * obj0 = 0 ;
23179 PyObject * obj1 = 0 ;
23180 char * kwnames[] = {
23181 (char *) "self",(char *) "day", NULL
23182 };
23183
23184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) SWIG_fail;
23185 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23186 if (!SWIG_IsOK(res1)) {
23187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23188 }
23189 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23190 ecode2 = SWIG_AsVal_int(obj1, &val2);
23191 if (!SWIG_IsOK(ecode2)) {
23192 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetDay" "', expected argument " "2"" of type '" "int""'");
23193 }
23194 arg2 = static_cast< int >(val2);
23195 {
23196 PyThreadState* __tstate = wxPyBeginAllowThreads();
23197 {
23198 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
23199 result = (wxDateTime *) &_result_ref;
23200 }
23201 wxPyEndAllowThreads(__tstate);
23202 if (PyErr_Occurred()) SWIG_fail;
23203 }
23204 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23205 return resultobj;
23206 fail:
23207 return NULL;
23208 }
23209
23210
23211 SWIGINTERN PyObject *_wrap_DateTime_SetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23212 PyObject *resultobj = 0;
23213 wxDateTime *arg1 = (wxDateTime *) 0 ;
23214 int arg2 ;
23215 wxDateTime *result = 0 ;
23216 void *argp1 = 0 ;
23217 int res1 = 0 ;
23218 int val2 ;
23219 int ecode2 = 0 ;
23220 PyObject * obj0 = 0 ;
23221 PyObject * obj1 = 0 ;
23222 char * kwnames[] = {
23223 (char *) "self",(char *) "hour", NULL
23224 };
23225
23226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) SWIG_fail;
23227 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23228 if (!SWIG_IsOK(res1)) {
23229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHour" "', expected argument " "1"" of type '" "wxDateTime *""'");
23230 }
23231 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23232 ecode2 = SWIG_AsVal_int(obj1, &val2);
23233 if (!SWIG_IsOK(ecode2)) {
23234 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHour" "', expected argument " "2"" of type '" "int""'");
23235 }
23236 arg2 = static_cast< int >(val2);
23237 {
23238 PyThreadState* __tstate = wxPyBeginAllowThreads();
23239 {
23240 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
23241 result = (wxDateTime *) &_result_ref;
23242 }
23243 wxPyEndAllowThreads(__tstate);
23244 if (PyErr_Occurred()) SWIG_fail;
23245 }
23246 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23247 return resultobj;
23248 fail:
23249 return NULL;
23250 }
23251
23252
23253 SWIGINTERN PyObject *_wrap_DateTime_SetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23254 PyObject *resultobj = 0;
23255 wxDateTime *arg1 = (wxDateTime *) 0 ;
23256 int arg2 ;
23257 wxDateTime *result = 0 ;
23258 void *argp1 = 0 ;
23259 int res1 = 0 ;
23260 int val2 ;
23261 int ecode2 = 0 ;
23262 PyObject * obj0 = 0 ;
23263 PyObject * obj1 = 0 ;
23264 char * kwnames[] = {
23265 (char *) "self",(char *) "minute", NULL
23266 };
23267
23268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
23269 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23270 if (!SWIG_IsOK(res1)) {
23271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMinute" "', expected argument " "1"" of type '" "wxDateTime *""'");
23272 }
23273 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23274 ecode2 = SWIG_AsVal_int(obj1, &val2);
23275 if (!SWIG_IsOK(ecode2)) {
23276 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMinute" "', expected argument " "2"" of type '" "int""'");
23277 }
23278 arg2 = static_cast< int >(val2);
23279 {
23280 PyThreadState* __tstate = wxPyBeginAllowThreads();
23281 {
23282 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
23283 result = (wxDateTime *) &_result_ref;
23284 }
23285 wxPyEndAllowThreads(__tstate);
23286 if (PyErr_Occurred()) SWIG_fail;
23287 }
23288 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23289 return resultobj;
23290 fail:
23291 return NULL;
23292 }
23293
23294
23295 SWIGINTERN PyObject *_wrap_DateTime_SetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23296 PyObject *resultobj = 0;
23297 wxDateTime *arg1 = (wxDateTime *) 0 ;
23298 int arg2 ;
23299 wxDateTime *result = 0 ;
23300 void *argp1 = 0 ;
23301 int res1 = 0 ;
23302 int val2 ;
23303 int ecode2 = 0 ;
23304 PyObject * obj0 = 0 ;
23305 PyObject * obj1 = 0 ;
23306 char * kwnames[] = {
23307 (char *) "self",(char *) "second", NULL
23308 };
23309
23310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
23311 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23312 if (!SWIG_IsOK(res1)) {
23313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetSecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
23314 }
23315 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23316 ecode2 = SWIG_AsVal_int(obj1, &val2);
23317 if (!SWIG_IsOK(ecode2)) {
23318 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetSecond" "', expected argument " "2"" of type '" "int""'");
23319 }
23320 arg2 = static_cast< int >(val2);
23321 {
23322 PyThreadState* __tstate = wxPyBeginAllowThreads();
23323 {
23324 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
23325 result = (wxDateTime *) &_result_ref;
23326 }
23327 wxPyEndAllowThreads(__tstate);
23328 if (PyErr_Occurred()) SWIG_fail;
23329 }
23330 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23331 return resultobj;
23332 fail:
23333 return NULL;
23334 }
23335
23336
23337 SWIGINTERN PyObject *_wrap_DateTime_SetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23338 PyObject *resultobj = 0;
23339 wxDateTime *arg1 = (wxDateTime *) 0 ;
23340 int arg2 ;
23341 wxDateTime *result = 0 ;
23342 void *argp1 = 0 ;
23343 int res1 = 0 ;
23344 int val2 ;
23345 int ecode2 = 0 ;
23346 PyObject * obj0 = 0 ;
23347 PyObject * obj1 = 0 ;
23348 char * kwnames[] = {
23349 (char *) "self",(char *) "millisecond", NULL
23350 };
23351
23352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
23353 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23354 if (!SWIG_IsOK(res1)) {
23355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMillisecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
23356 }
23357 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23358 ecode2 = SWIG_AsVal_int(obj1, &val2);
23359 if (!SWIG_IsOK(ecode2)) {
23360 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMillisecond" "', expected argument " "2"" of type '" "int""'");
23361 }
23362 arg2 = static_cast< int >(val2);
23363 {
23364 PyThreadState* __tstate = wxPyBeginAllowThreads();
23365 {
23366 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
23367 result = (wxDateTime *) &_result_ref;
23368 }
23369 wxPyEndAllowThreads(__tstate);
23370 if (PyErr_Occurred()) SWIG_fail;
23371 }
23372 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23373 return resultobj;
23374 fail:
23375 return NULL;
23376 }
23377
23378
23379 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23380 PyObject *resultobj = 0;
23381 wxDateTime *arg1 = (wxDateTime *) 0 ;
23382 wxDateTime::WeekDay arg2 ;
23383 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
23384 wxDateTime *result = 0 ;
23385 void *argp1 = 0 ;
23386 int res1 = 0 ;
23387 int val2 ;
23388 int ecode2 = 0 ;
23389 int val3 ;
23390 int ecode3 = 0 ;
23391 PyObject * obj0 = 0 ;
23392 PyObject * obj1 = 0 ;
23393 PyObject * obj2 = 0 ;
23394 char * kwnames[] = {
23395 (char *) "self",(char *) "weekday",(char *) "flags", NULL
23396 };
23397
23398 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23399 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23400 if (!SWIG_IsOK(res1)) {
23401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
23402 }
23403 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23404 ecode2 = SWIG_AsVal_int(obj1, &val2);
23405 if (!SWIG_IsOK(ecode2)) {
23406 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23407 }
23408 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23409 if (obj2) {
23410 ecode3 = SWIG_AsVal_int(obj2, &val3);
23411 if (!SWIG_IsOK(ecode3)) {
23412 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
23413 }
23414 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
23415 }
23416 {
23417 PyThreadState* __tstate = wxPyBeginAllowThreads();
23418 {
23419 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek(arg2,arg3);
23420 result = (wxDateTime *) &_result_ref;
23421 }
23422 wxPyEndAllowThreads(__tstate);
23423 if (PyErr_Occurred()) SWIG_fail;
23424 }
23425 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23426 return resultobj;
23427 fail:
23428 return NULL;
23429 }
23430
23431
23432 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23433 PyObject *resultobj = 0;
23434 wxDateTime *arg1 = (wxDateTime *) 0 ;
23435 wxDateTime::WeekDay arg2 ;
23436 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
23437 wxDateTime result;
23438 void *argp1 = 0 ;
23439 int res1 = 0 ;
23440 int val2 ;
23441 int ecode2 = 0 ;
23442 int val3 ;
23443 int ecode3 = 0 ;
23444 PyObject * obj0 = 0 ;
23445 PyObject * obj1 = 0 ;
23446 PyObject * obj2 = 0 ;
23447 char * kwnames[] = {
23448 (char *) "self",(char *) "weekday",(char *) "flags", NULL
23449 };
23450
23451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23452 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23453 if (!SWIG_IsOK(res1)) {
23454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
23455 }
23456 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23457 ecode2 = SWIG_AsVal_int(obj1, &val2);
23458 if (!SWIG_IsOK(ecode2)) {
23459 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23460 }
23461 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23462 if (obj2) {
23463 ecode3 = SWIG_AsVal_int(obj2, &val3);
23464 if (!SWIG_IsOK(ecode3)) {
23465 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
23466 }
23467 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
23468 }
23469 {
23470 PyThreadState* __tstate = wxPyBeginAllowThreads();
23471 result = (arg1)->GetWeekDayInSameWeek(arg2,arg3);
23472 wxPyEndAllowThreads(__tstate);
23473 if (PyErr_Occurred()) SWIG_fail;
23474 }
23475 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23476 return resultobj;
23477 fail:
23478 return NULL;
23479 }
23480
23481
23482 SWIGINTERN PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23483 PyObject *resultobj = 0;
23484 wxDateTime *arg1 = (wxDateTime *) 0 ;
23485 wxDateTime::WeekDay arg2 ;
23486 wxDateTime *result = 0 ;
23487 void *argp1 = 0 ;
23488 int res1 = 0 ;
23489 int val2 ;
23490 int ecode2 = 0 ;
23491 PyObject * obj0 = 0 ;
23492 PyObject * obj1 = 0 ;
23493 char * kwnames[] = {
23494 (char *) "self",(char *) "weekday", NULL
23495 };
23496
23497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
23498 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23499 if (!SWIG_IsOK(res1)) {
23500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23501 }
23502 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23503 ecode2 = SWIG_AsVal_int(obj1, &val2);
23504 if (!SWIG_IsOK(ecode2)) {
23505 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23506 }
23507 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23508 {
23509 PyThreadState* __tstate = wxPyBeginAllowThreads();
23510 {
23511 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay(arg2);
23512 result = (wxDateTime *) &_result_ref;
23513 }
23514 wxPyEndAllowThreads(__tstate);
23515 if (PyErr_Occurred()) SWIG_fail;
23516 }
23517 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23518 return resultobj;
23519 fail:
23520 return NULL;
23521 }
23522
23523
23524 SWIGINTERN PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23525 PyObject *resultobj = 0;
23526 wxDateTime *arg1 = (wxDateTime *) 0 ;
23527 wxDateTime::WeekDay arg2 ;
23528 wxDateTime result;
23529 void *argp1 = 0 ;
23530 int res1 = 0 ;
23531 int val2 ;
23532 int ecode2 = 0 ;
23533 PyObject * obj0 = 0 ;
23534 PyObject * obj1 = 0 ;
23535 char * kwnames[] = {
23536 (char *) "self",(char *) "weekday", NULL
23537 };
23538
23539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
23540 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23541 if (!SWIG_IsOK(res1)) {
23542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23543 }
23544 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23545 ecode2 = SWIG_AsVal_int(obj1, &val2);
23546 if (!SWIG_IsOK(ecode2)) {
23547 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23548 }
23549 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23550 {
23551 PyThreadState* __tstate = wxPyBeginAllowThreads();
23552 result = (arg1)->GetNextWeekDay(arg2);
23553 wxPyEndAllowThreads(__tstate);
23554 if (PyErr_Occurred()) SWIG_fail;
23555 }
23556 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23557 return resultobj;
23558 fail:
23559 return NULL;
23560 }
23561
23562
23563 SWIGINTERN PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23564 PyObject *resultobj = 0;
23565 wxDateTime *arg1 = (wxDateTime *) 0 ;
23566 wxDateTime::WeekDay arg2 ;
23567 wxDateTime *result = 0 ;
23568 void *argp1 = 0 ;
23569 int res1 = 0 ;
23570 int val2 ;
23571 int ecode2 = 0 ;
23572 PyObject * obj0 = 0 ;
23573 PyObject * obj1 = 0 ;
23574 char * kwnames[] = {
23575 (char *) "self",(char *) "weekday", NULL
23576 };
23577
23578 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
23579 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23580 if (!SWIG_IsOK(res1)) {
23581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23582 }
23583 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23584 ecode2 = SWIG_AsVal_int(obj1, &val2);
23585 if (!SWIG_IsOK(ecode2)) {
23586 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23587 }
23588 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23589 {
23590 PyThreadState* __tstate = wxPyBeginAllowThreads();
23591 {
23592 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay(arg2);
23593 result = (wxDateTime *) &_result_ref;
23594 }
23595 wxPyEndAllowThreads(__tstate);
23596 if (PyErr_Occurred()) SWIG_fail;
23597 }
23598 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23599 return resultobj;
23600 fail:
23601 return NULL;
23602 }
23603
23604
23605 SWIGINTERN PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23606 PyObject *resultobj = 0;
23607 wxDateTime *arg1 = (wxDateTime *) 0 ;
23608 wxDateTime::WeekDay arg2 ;
23609 wxDateTime result;
23610 void *argp1 = 0 ;
23611 int res1 = 0 ;
23612 int val2 ;
23613 int ecode2 = 0 ;
23614 PyObject * obj0 = 0 ;
23615 PyObject * obj1 = 0 ;
23616 char * kwnames[] = {
23617 (char *) "self",(char *) "weekday", NULL
23618 };
23619
23620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
23621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23622 if (!SWIG_IsOK(res1)) {
23623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23624 }
23625 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23626 ecode2 = SWIG_AsVal_int(obj1, &val2);
23627 if (!SWIG_IsOK(ecode2)) {
23628 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23629 }
23630 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23631 {
23632 PyThreadState* __tstate = wxPyBeginAllowThreads();
23633 result = (arg1)->GetPrevWeekDay(arg2);
23634 wxPyEndAllowThreads(__tstate);
23635 if (PyErr_Occurred()) SWIG_fail;
23636 }
23637 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23638 return resultobj;
23639 fail:
23640 return NULL;
23641 }
23642
23643
23644 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23645 PyObject *resultobj = 0;
23646 wxDateTime *arg1 = (wxDateTime *) 0 ;
23647 wxDateTime::WeekDay arg2 ;
23648 int arg3 = (int) 1 ;
23649 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23650 int arg5 = (int) wxDateTime::Inv_Year ;
23651 bool result;
23652 void *argp1 = 0 ;
23653 int res1 = 0 ;
23654 int val2 ;
23655 int ecode2 = 0 ;
23656 int val3 ;
23657 int ecode3 = 0 ;
23658 int val4 ;
23659 int ecode4 = 0 ;
23660 int val5 ;
23661 int ecode5 = 0 ;
23662 PyObject * obj0 = 0 ;
23663 PyObject * obj1 = 0 ;
23664 PyObject * obj2 = 0 ;
23665 PyObject * obj3 = 0 ;
23666 PyObject * obj4 = 0 ;
23667 char * kwnames[] = {
23668 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
23669 };
23670
23671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
23672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23673 if (!SWIG_IsOK(res1)) {
23674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23675 }
23676 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23677 ecode2 = SWIG_AsVal_int(obj1, &val2);
23678 if (!SWIG_IsOK(ecode2)) {
23679 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23680 }
23681 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23682 if (obj2) {
23683 ecode3 = SWIG_AsVal_int(obj2, &val3);
23684 if (!SWIG_IsOK(ecode3)) {
23685 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDay" "', expected argument " "3"" of type '" "int""'");
23686 }
23687 arg3 = static_cast< int >(val3);
23688 }
23689 if (obj3) {
23690 ecode4 = SWIG_AsVal_int(obj3, &val4);
23691 if (!SWIG_IsOK(ecode4)) {
23692 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToWeekDay" "', expected argument " "4"" of type '" "wxDateTime::Month""'");
23693 }
23694 arg4 = static_cast< wxDateTime::Month >(val4);
23695 }
23696 if (obj4) {
23697 ecode5 = SWIG_AsVal_int(obj4, &val5);
23698 if (!SWIG_IsOK(ecode5)) {
23699 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetToWeekDay" "', expected argument " "5"" of type '" "int""'");
23700 }
23701 arg5 = static_cast< int >(val5);
23702 }
23703 {
23704 PyThreadState* __tstate = wxPyBeginAllowThreads();
23705 result = (bool)(arg1)->SetToWeekDay(arg2,arg3,arg4,arg5);
23706 wxPyEndAllowThreads(__tstate);
23707 if (PyErr_Occurred()) SWIG_fail;
23708 }
23709 {
23710 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23711 }
23712 return resultobj;
23713 fail:
23714 return NULL;
23715 }
23716
23717
23718 SWIGINTERN PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23719 PyObject *resultobj = 0;
23720 wxDateTime *arg1 = (wxDateTime *) 0 ;
23721 wxDateTime::WeekDay arg2 ;
23722 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23723 int arg4 = (int) wxDateTime::Inv_Year ;
23724 bool result;
23725 void *argp1 = 0 ;
23726 int res1 = 0 ;
23727 int val2 ;
23728 int ecode2 = 0 ;
23729 int val3 ;
23730 int ecode3 = 0 ;
23731 int val4 ;
23732 int ecode4 = 0 ;
23733 PyObject * obj0 = 0 ;
23734 PyObject * obj1 = 0 ;
23735 PyObject * obj2 = 0 ;
23736 PyObject * obj3 = 0 ;
23737 char * kwnames[] = {
23738 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
23739 };
23740
23741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23743 if (!SWIG_IsOK(res1)) {
23744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23745 }
23746 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23747 ecode2 = SWIG_AsVal_int(obj1, &val2);
23748 if (!SWIG_IsOK(ecode2)) {
23749 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23750 }
23751 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23752 if (obj2) {
23753 ecode3 = SWIG_AsVal_int(obj2, &val3);
23754 if (!SWIG_IsOK(ecode3)) {
23755 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
23756 }
23757 arg3 = static_cast< wxDateTime::Month >(val3);
23758 }
23759 if (obj3) {
23760 ecode4 = SWIG_AsVal_int(obj3, &val4);
23761 if (!SWIG_IsOK(ecode4)) {
23762 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "4"" of type '" "int""'");
23763 }
23764 arg4 = static_cast< int >(val4);
23765 }
23766 {
23767 PyThreadState* __tstate = wxPyBeginAllowThreads();
23768 result = (bool)(arg1)->SetToLastWeekDay(arg2,arg3,arg4);
23769 wxPyEndAllowThreads(__tstate);
23770 if (PyErr_Occurred()) SWIG_fail;
23771 }
23772 {
23773 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23774 }
23775 return resultobj;
23776 fail:
23777 return NULL;
23778 }
23779
23780
23781 SWIGINTERN PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23782 PyObject *resultobj = 0;
23783 wxDateTime *arg1 = (wxDateTime *) 0 ;
23784 wxDateTime::WeekDay arg2 ;
23785 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23786 int arg4 = (int) wxDateTime::Inv_Year ;
23787 wxDateTime result;
23788 void *argp1 = 0 ;
23789 int res1 = 0 ;
23790 int val2 ;
23791 int ecode2 = 0 ;
23792 int val3 ;
23793 int ecode3 = 0 ;
23794 int val4 ;
23795 int ecode4 = 0 ;
23796 PyObject * obj0 = 0 ;
23797 PyObject * obj1 = 0 ;
23798 PyObject * obj2 = 0 ;
23799 PyObject * obj3 = 0 ;
23800 char * kwnames[] = {
23801 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
23802 };
23803
23804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23806 if (!SWIG_IsOK(res1)) {
23807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23808 }
23809 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23810 ecode2 = SWIG_AsVal_int(obj1, &val2);
23811 if (!SWIG_IsOK(ecode2)) {
23812 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23813 }
23814 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23815 if (obj2) {
23816 ecode3 = SWIG_AsVal_int(obj2, &val3);
23817 if (!SWIG_IsOK(ecode3)) {
23818 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
23819 }
23820 arg3 = static_cast< wxDateTime::Month >(val3);
23821 }
23822 if (obj3) {
23823 ecode4 = SWIG_AsVal_int(obj3, &val4);
23824 if (!SWIG_IsOK(ecode4)) {
23825 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "4"" of type '" "int""'");
23826 }
23827 arg4 = static_cast< int >(val4);
23828 }
23829 {
23830 PyThreadState* __tstate = wxPyBeginAllowThreads();
23831 result = (arg1)->GetLastWeekDay(arg2,arg3,arg4);
23832 wxPyEndAllowThreads(__tstate);
23833 if (PyErr_Occurred()) SWIG_fail;
23834 }
23835 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23836 return resultobj;
23837 fail:
23838 return NULL;
23839 }
23840
23841
23842 SWIGINTERN PyObject *_wrap_DateTime_SetToTheWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23843 PyObject *resultobj = 0;
23844 wxDateTime *arg1 = (wxDateTime *) 0 ;
23845 int arg2 ;
23846 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
23847 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
23848 bool result;
23849 void *argp1 = 0 ;
23850 int res1 = 0 ;
23851 int val2 ;
23852 int ecode2 = 0 ;
23853 int val3 ;
23854 int ecode3 = 0 ;
23855 int val4 ;
23856 int ecode4 = 0 ;
23857 PyObject * obj0 = 0 ;
23858 PyObject * obj1 = 0 ;
23859 PyObject * obj2 = 0 ;
23860 PyObject * obj3 = 0 ;
23861 char * kwnames[] = {
23862 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
23863 };
23864
23865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23866 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23867 if (!SWIG_IsOK(res1)) {
23868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToTheWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
23869 }
23870 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23871 ecode2 = SWIG_AsVal_int(obj1, &val2);
23872 if (!SWIG_IsOK(ecode2)) {
23873 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToTheWeek" "', expected argument " "2"" of type '" "int""'");
23874 }
23875 arg2 = static_cast< int >(val2);
23876 if (obj2) {
23877 ecode3 = SWIG_AsVal_int(obj2, &val3);
23878 if (!SWIG_IsOK(ecode3)) {
23879 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToTheWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
23880 }
23881 arg3 = static_cast< wxDateTime::WeekDay >(val3);
23882 }
23883 if (obj3) {
23884 ecode4 = SWIG_AsVal_int(obj3, &val4);
23885 if (!SWIG_IsOK(ecode4)) {
23886 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToTheWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
23887 }
23888 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
23889 }
23890 {
23891 PyThreadState* __tstate = wxPyBeginAllowThreads();
23892 result = (bool)(arg1)->SetToTheWeek(arg2,arg3,arg4);
23893 wxPyEndAllowThreads(__tstate);
23894 if (PyErr_Occurred()) SWIG_fail;
23895 }
23896 {
23897 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23898 }
23899 return resultobj;
23900 fail:
23901 return NULL;
23902 }
23903
23904
23905 SWIGINTERN PyObject *_wrap_DateTime_GetWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23906 PyObject *resultobj = 0;
23907 wxDateTime *arg1 = (wxDateTime *) 0 ;
23908 int arg2 ;
23909 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
23910 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
23911 wxDateTime result;
23912 void *argp1 = 0 ;
23913 int res1 = 0 ;
23914 int val2 ;
23915 int ecode2 = 0 ;
23916 int val3 ;
23917 int ecode3 = 0 ;
23918 int val4 ;
23919 int ecode4 = 0 ;
23920 PyObject * obj0 = 0 ;
23921 PyObject * obj1 = 0 ;
23922 PyObject * obj2 = 0 ;
23923 PyObject * obj3 = 0 ;
23924 char * kwnames[] = {
23925 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
23926 };
23927
23928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23930 if (!SWIG_IsOK(res1)) {
23931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
23932 }
23933 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23934 ecode2 = SWIG_AsVal_int(obj1, &val2);
23935 if (!SWIG_IsOK(ecode2)) {
23936 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeek" "', expected argument " "2"" of type '" "int""'");
23937 }
23938 arg2 = static_cast< int >(val2);
23939 if (obj2) {
23940 ecode3 = SWIG_AsVal_int(obj2, &val3);
23941 if (!SWIG_IsOK(ecode3)) {
23942 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
23943 }
23944 arg3 = static_cast< wxDateTime::WeekDay >(val3);
23945 }
23946 if (obj3) {
23947 ecode4 = SWIG_AsVal_int(obj3, &val4);
23948 if (!SWIG_IsOK(ecode4)) {
23949 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
23950 }
23951 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
23952 }
23953 {
23954 PyThreadState* __tstate = wxPyBeginAllowThreads();
23955 result = (arg1)->GetWeek(arg2,arg3,arg4);
23956 wxPyEndAllowThreads(__tstate);
23957 if (PyErr_Occurred()) SWIG_fail;
23958 }
23959 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23960 return resultobj;
23961 fail:
23962 return NULL;
23963 }
23964
23965
23966 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23967 PyObject *resultobj = 0;
23968 int arg1 ;
23969 int arg2 ;
23970 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
23971 wxDateTime result;
23972 int val1 ;
23973 int ecode1 = 0 ;
23974 int val2 ;
23975 int ecode2 = 0 ;
23976 int val3 ;
23977 int ecode3 = 0 ;
23978 PyObject * obj0 = 0 ;
23979 PyObject * obj1 = 0 ;
23980 PyObject * obj2 = 0 ;
23981 char * kwnames[] = {
23982 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
23983 };
23984
23985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23986 ecode1 = SWIG_AsVal_int(obj0, &val1);
23987 if (!SWIG_IsOK(ecode1)) {
23988 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "1"" of type '" "int""'");
23989 }
23990 arg1 = static_cast< int >(val1);
23991 ecode2 = SWIG_AsVal_int(obj1, &val2);
23992 if (!SWIG_IsOK(ecode2)) {
23993 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "2"" of type '" "int""'");
23994 }
23995 arg2 = static_cast< int >(val2);
23996 if (obj2) {
23997 ecode3 = SWIG_AsVal_int(obj2, &val3);
23998 if (!SWIG_IsOK(ecode3)) {
23999 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
24000 }
24001 arg3 = static_cast< wxDateTime::WeekDay >(val3);
24002 }
24003 {
24004 PyThreadState* __tstate = wxPyBeginAllowThreads();
24005 result = wxDateTime::SetToWeekOfYear(arg1,arg2,arg3);
24006 wxPyEndAllowThreads(__tstate);
24007 if (PyErr_Occurred()) SWIG_fail;
24008 }
24009 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24010 return resultobj;
24011 fail:
24012 return NULL;
24013 }
24014
24015
24016 SWIGINTERN PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24017 PyObject *resultobj = 0;
24018 wxDateTime *arg1 = (wxDateTime *) 0 ;
24019 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24020 int arg3 = (int) wxDateTime::Inv_Year ;
24021 wxDateTime *result = 0 ;
24022 void *argp1 = 0 ;
24023 int res1 = 0 ;
24024 int val2 ;
24025 int ecode2 = 0 ;
24026 int val3 ;
24027 int ecode3 = 0 ;
24028 PyObject * obj0 = 0 ;
24029 PyObject * obj1 = 0 ;
24030 PyObject * obj2 = 0 ;
24031 char * kwnames[] = {
24032 (char *) "self",(char *) "month",(char *) "year", NULL
24033 };
24034
24035 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24036 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24037 if (!SWIG_IsOK(res1)) {
24038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24039 }
24040 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24041 if (obj1) {
24042 ecode2 = SWIG_AsVal_int(obj1, &val2);
24043 if (!SWIG_IsOK(ecode2)) {
24044 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24045 }
24046 arg2 = static_cast< wxDateTime::Month >(val2);
24047 }
24048 if (obj2) {
24049 ecode3 = SWIG_AsVal_int(obj2, &val3);
24050 if (!SWIG_IsOK(ecode3)) {
24051 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "3"" of type '" "int""'");
24052 }
24053 arg3 = static_cast< int >(val3);
24054 }
24055 {
24056 PyThreadState* __tstate = wxPyBeginAllowThreads();
24057 {
24058 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay(arg2,arg3);
24059 result = (wxDateTime *) &_result_ref;
24060 }
24061 wxPyEndAllowThreads(__tstate);
24062 if (PyErr_Occurred()) SWIG_fail;
24063 }
24064 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24065 return resultobj;
24066 fail:
24067 return NULL;
24068 }
24069
24070
24071 SWIGINTERN PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24072 PyObject *resultobj = 0;
24073 wxDateTime *arg1 = (wxDateTime *) 0 ;
24074 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24075 int arg3 = (int) wxDateTime::Inv_Year ;
24076 wxDateTime result;
24077 void *argp1 = 0 ;
24078 int res1 = 0 ;
24079 int val2 ;
24080 int ecode2 = 0 ;
24081 int val3 ;
24082 int ecode3 = 0 ;
24083 PyObject * obj0 = 0 ;
24084 PyObject * obj1 = 0 ;
24085 PyObject * obj2 = 0 ;
24086 char * kwnames[] = {
24087 (char *) "self",(char *) "month",(char *) "year", NULL
24088 };
24089
24090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24091 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24092 if (!SWIG_IsOK(res1)) {
24093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24094 }
24095 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24096 if (obj1) {
24097 ecode2 = SWIG_AsVal_int(obj1, &val2);
24098 if (!SWIG_IsOK(ecode2)) {
24099 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24100 }
24101 arg2 = static_cast< wxDateTime::Month >(val2);
24102 }
24103 if (obj2) {
24104 ecode3 = SWIG_AsVal_int(obj2, &val3);
24105 if (!SWIG_IsOK(ecode3)) {
24106 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "3"" of type '" "int""'");
24107 }
24108 arg3 = static_cast< int >(val3);
24109 }
24110 {
24111 PyThreadState* __tstate = wxPyBeginAllowThreads();
24112 result = (arg1)->GetLastMonthDay(arg2,arg3);
24113 wxPyEndAllowThreads(__tstate);
24114 if (PyErr_Occurred()) SWIG_fail;
24115 }
24116 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24117 return resultobj;
24118 fail:
24119 return NULL;
24120 }
24121
24122
24123 SWIGINTERN PyObject *_wrap_DateTime_SetToYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24124 PyObject *resultobj = 0;
24125 wxDateTime *arg1 = (wxDateTime *) 0 ;
24126 int arg2 ;
24127 wxDateTime *result = 0 ;
24128 void *argp1 = 0 ;
24129 int res1 = 0 ;
24130 int val2 ;
24131 int ecode2 = 0 ;
24132 PyObject * obj0 = 0 ;
24133 PyObject * obj1 = 0 ;
24134 char * kwnames[] = {
24135 (char *) "self",(char *) "yday", NULL
24136 };
24137
24138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
24139 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24140 if (!SWIG_IsOK(res1)) {
24141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24142 }
24143 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24144 ecode2 = SWIG_AsVal_int(obj1, &val2);
24145 if (!SWIG_IsOK(ecode2)) {
24146 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToYearDay" "', expected argument " "2"" of type '" "int""'");
24147 }
24148 arg2 = static_cast< int >(val2);
24149 {
24150 PyThreadState* __tstate = wxPyBeginAllowThreads();
24151 {
24152 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
24153 result = (wxDateTime *) &_result_ref;
24154 }
24155 wxPyEndAllowThreads(__tstate);
24156 if (PyErr_Occurred()) SWIG_fail;
24157 }
24158 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24159 return resultobj;
24160 fail:
24161 return NULL;
24162 }
24163
24164
24165 SWIGINTERN PyObject *_wrap_DateTime_GetYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24166 PyObject *resultobj = 0;
24167 wxDateTime *arg1 = (wxDateTime *) 0 ;
24168 int arg2 ;
24169 wxDateTime result;
24170 void *argp1 = 0 ;
24171 int res1 = 0 ;
24172 int val2 ;
24173 int ecode2 = 0 ;
24174 PyObject * obj0 = 0 ;
24175 PyObject * obj1 = 0 ;
24176 char * kwnames[] = {
24177 (char *) "self",(char *) "yday", NULL
24178 };
24179
24180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
24181 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24182 if (!SWIG_IsOK(res1)) {
24183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24184 }
24185 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24186 ecode2 = SWIG_AsVal_int(obj1, &val2);
24187 if (!SWIG_IsOK(ecode2)) {
24188 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetYearDay" "', expected argument " "2"" of type '" "int""'");
24189 }
24190 arg2 = static_cast< int >(val2);
24191 {
24192 PyThreadState* __tstate = wxPyBeginAllowThreads();
24193 result = (arg1)->GetYearDay(arg2);
24194 wxPyEndAllowThreads(__tstate);
24195 if (PyErr_Occurred()) SWIG_fail;
24196 }
24197 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24198 return resultobj;
24199 fail:
24200 return NULL;
24201 }
24202
24203
24204 SWIGINTERN PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24205 PyObject *resultobj = 0;
24206 wxDateTime *arg1 = (wxDateTime *) 0 ;
24207 double result;
24208 void *argp1 = 0 ;
24209 int res1 = 0 ;
24210 PyObject *swig_obj[1] ;
24211
24212 if (!args) SWIG_fail;
24213 swig_obj[0] = args;
24214 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24215 if (!SWIG_IsOK(res1)) {
24216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime *""'");
24217 }
24218 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24219 {
24220 PyThreadState* __tstate = wxPyBeginAllowThreads();
24221 result = (double)(arg1)->GetJulianDayNumber();
24222 wxPyEndAllowThreads(__tstate);
24223 if (PyErr_Occurred()) SWIG_fail;
24224 }
24225 resultobj = SWIG_From_double(static_cast< double >(result));
24226 return resultobj;
24227 fail:
24228 return NULL;
24229 }
24230
24231
24232 SWIGINTERN PyObject *_wrap_DateTime_GetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24233 PyObject *resultobj = 0;
24234 wxDateTime *arg1 = (wxDateTime *) 0 ;
24235 double result;
24236 void *argp1 = 0 ;
24237 int res1 = 0 ;
24238 PyObject *swig_obj[1] ;
24239
24240 if (!args) SWIG_fail;
24241 swig_obj[0] = args;
24242 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24243 if (!SWIG_IsOK(res1)) {
24244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
24245 }
24246 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24247 {
24248 PyThreadState* __tstate = wxPyBeginAllowThreads();
24249 result = (double)(arg1)->GetJDN();
24250 wxPyEndAllowThreads(__tstate);
24251 if (PyErr_Occurred()) SWIG_fail;
24252 }
24253 resultobj = SWIG_From_double(static_cast< double >(result));
24254 return resultobj;
24255 fail:
24256 return NULL;
24257 }
24258
24259
24260 SWIGINTERN PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24261 PyObject *resultobj = 0;
24262 wxDateTime *arg1 = (wxDateTime *) 0 ;
24263 double result;
24264 void *argp1 = 0 ;
24265 int res1 = 0 ;
24266 PyObject *swig_obj[1] ;
24267
24268 if (!args) SWIG_fail;
24269 swig_obj[0] = args;
24270 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24271 if (!SWIG_IsOK(res1)) {
24272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetModifiedJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24273 }
24274 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24275 {
24276 PyThreadState* __tstate = wxPyBeginAllowThreads();
24277 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
24278 wxPyEndAllowThreads(__tstate);
24279 if (PyErr_Occurred()) SWIG_fail;
24280 }
24281 resultobj = SWIG_From_double(static_cast< double >(result));
24282 return resultobj;
24283 fail:
24284 return NULL;
24285 }
24286
24287
24288 SWIGINTERN PyObject *_wrap_DateTime_GetMJD(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24289 PyObject *resultobj = 0;
24290 wxDateTime *arg1 = (wxDateTime *) 0 ;
24291 double result;
24292 void *argp1 = 0 ;
24293 int res1 = 0 ;
24294 PyObject *swig_obj[1] ;
24295
24296 if (!args) SWIG_fail;
24297 swig_obj[0] = args;
24298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24299 if (!SWIG_IsOK(res1)) {
24300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMJD" "', expected argument " "1"" of type '" "wxDateTime *""'");
24301 }
24302 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24303 {
24304 PyThreadState* __tstate = wxPyBeginAllowThreads();
24305 result = (double)(arg1)->GetMJD();
24306 wxPyEndAllowThreads(__tstate);
24307 if (PyErr_Occurred()) SWIG_fail;
24308 }
24309 resultobj = SWIG_From_double(static_cast< double >(result));
24310 return resultobj;
24311 fail:
24312 return NULL;
24313 }
24314
24315
24316 SWIGINTERN PyObject *_wrap_DateTime_GetRataDie(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24317 PyObject *resultobj = 0;
24318 wxDateTime *arg1 = (wxDateTime *) 0 ;
24319 double result;
24320 void *argp1 = 0 ;
24321 int res1 = 0 ;
24322 PyObject *swig_obj[1] ;
24323
24324 if (!args) SWIG_fail;
24325 swig_obj[0] = args;
24326 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24327 if (!SWIG_IsOK(res1)) {
24328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetRataDie" "', expected argument " "1"" of type '" "wxDateTime *""'");
24329 }
24330 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24331 {
24332 PyThreadState* __tstate = wxPyBeginAllowThreads();
24333 result = (double)(arg1)->GetRataDie();
24334 wxPyEndAllowThreads(__tstate);
24335 if (PyErr_Occurred()) SWIG_fail;
24336 }
24337 resultobj = SWIG_From_double(static_cast< double >(result));
24338 return resultobj;
24339 fail:
24340 return NULL;
24341 }
24342
24343
24344 SWIGINTERN PyObject *_wrap_DateTime_ToTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24345 PyObject *resultobj = 0;
24346 wxDateTime *arg1 = (wxDateTime *) 0 ;
24347 wxDateTime::TimeZone *arg2 = 0 ;
24348 bool arg3 = (bool) false ;
24349 wxDateTime result;
24350 void *argp1 = 0 ;
24351 int res1 = 0 ;
24352 bool temp2 = false ;
24353 bool val3 ;
24354 int ecode3 = 0 ;
24355 PyObject * obj0 = 0 ;
24356 PyObject * obj1 = 0 ;
24357 PyObject * obj2 = 0 ;
24358 char * kwnames[] = {
24359 (char *) "self",(char *) "tz",(char *) "noDST", NULL
24360 };
24361
24362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24363 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24364 if (!SWIG_IsOK(res1)) {
24365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
24366 }
24367 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24368 {
24369 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24370 temp2 = true;
24371 }
24372 if (obj2) {
24373 ecode3 = SWIG_AsVal_bool(obj2, &val3);
24374 if (!SWIG_IsOK(ecode3)) {
24375 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_ToTimezone" "', expected argument " "3"" of type '" "bool""'");
24376 }
24377 arg3 = static_cast< bool >(val3);
24378 }
24379 {
24380 PyThreadState* __tstate = wxPyBeginAllowThreads();
24381 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
24382 wxPyEndAllowThreads(__tstate);
24383 if (PyErr_Occurred()) SWIG_fail;
24384 }
24385 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24386 {
24387 if (temp2) delete arg2;
24388 }
24389 return resultobj;
24390 fail:
24391 {
24392 if (temp2) delete arg2;
24393 }
24394 return NULL;
24395 }
24396
24397
24398 SWIGINTERN PyObject *_wrap_DateTime_MakeTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24399 PyObject *resultobj = 0;
24400 wxDateTime *arg1 = (wxDateTime *) 0 ;
24401 wxDateTime::TimeZone *arg2 = 0 ;
24402 bool arg3 = (bool) false ;
24403 wxDateTime *result = 0 ;
24404 void *argp1 = 0 ;
24405 int res1 = 0 ;
24406 bool temp2 = false ;
24407 bool val3 ;
24408 int ecode3 = 0 ;
24409 PyObject * obj0 = 0 ;
24410 PyObject * obj1 = 0 ;
24411 PyObject * obj2 = 0 ;
24412 char * kwnames[] = {
24413 (char *) "self",(char *) "tz",(char *) "noDST", NULL
24414 };
24415
24416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24417 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24418 if (!SWIG_IsOK(res1)) {
24419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
24420 }
24421 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24422 {
24423 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24424 temp2 = true;
24425 }
24426 if (obj2) {
24427 ecode3 = SWIG_AsVal_bool(obj2, &val3);
24428 if (!SWIG_IsOK(ecode3)) {
24429 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeTimezone" "', expected argument " "3"" of type '" "bool""'");
24430 }
24431 arg3 = static_cast< bool >(val3);
24432 }
24433 {
24434 PyThreadState* __tstate = wxPyBeginAllowThreads();
24435 {
24436 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
24437 result = (wxDateTime *) &_result_ref;
24438 }
24439 wxPyEndAllowThreads(__tstate);
24440 if (PyErr_Occurred()) SWIG_fail;
24441 }
24442 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24443 {
24444 if (temp2) delete arg2;
24445 }
24446 return resultobj;
24447 fail:
24448 {
24449 if (temp2) delete arg2;
24450 }
24451 return NULL;
24452 }
24453
24454
24455 SWIGINTERN PyObject *_wrap_DateTime_FromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24456 PyObject *resultobj = 0;
24457 wxDateTime *arg1 = (wxDateTime *) 0 ;
24458 wxDateTime::TimeZone *arg2 = 0 ;
24459 bool arg3 = (bool) false ;
24460 wxDateTime result;
24461 void *argp1 = 0 ;
24462 int res1 = 0 ;
24463 bool temp2 = false ;
24464 bool val3 ;
24465 int ecode3 = 0 ;
24466 PyObject * obj0 = 0 ;
24467 PyObject * obj1 = 0 ;
24468 PyObject * obj2 = 0 ;
24469 char * kwnames[] = {
24470 (char *) "self",(char *) "tz",(char *) "noDST", NULL
24471 };
24472
24473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_FromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24474 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24475 if (!SWIG_IsOK(res1)) {
24476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromTimezone" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24477 }
24478 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24479 {
24480 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24481 temp2 = true;
24482 }
24483 if (obj2) {
24484 ecode3 = SWIG_AsVal_bool(obj2, &val3);
24485 if (!SWIG_IsOK(ecode3)) {
24486 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_FromTimezone" "', expected argument " "3"" of type '" "bool""'");
24487 }
24488 arg3 = static_cast< bool >(val3);
24489 }
24490 {
24491 PyThreadState* __tstate = wxPyBeginAllowThreads();
24492 result = ((wxDateTime const *)arg1)->FromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
24493 wxPyEndAllowThreads(__tstate);
24494 if (PyErr_Occurred()) SWIG_fail;
24495 }
24496 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24497 {
24498 if (temp2) delete arg2;
24499 }
24500 return resultobj;
24501 fail:
24502 {
24503 if (temp2) delete arg2;
24504 }
24505 return NULL;
24506 }
24507
24508
24509 SWIGINTERN PyObject *_wrap_DateTime_MakeFromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24510 PyObject *resultobj = 0;
24511 wxDateTime *arg1 = (wxDateTime *) 0 ;
24512 wxDateTime::TimeZone *arg2 = 0 ;
24513 bool arg3 = (bool) false ;
24514 wxDateTime *result = 0 ;
24515 void *argp1 = 0 ;
24516 int res1 = 0 ;
24517 bool temp2 = false ;
24518 bool val3 ;
24519 int ecode3 = 0 ;
24520 PyObject * obj0 = 0 ;
24521 PyObject * obj1 = 0 ;
24522 PyObject * obj2 = 0 ;
24523 char * kwnames[] = {
24524 (char *) "self",(char *) "tz",(char *) "noDST", NULL
24525 };
24526
24527 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeFromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24528 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24529 if (!SWIG_IsOK(res1)) {
24530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
24531 }
24532 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24533 {
24534 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24535 temp2 = true;
24536 }
24537 if (obj2) {
24538 ecode3 = SWIG_AsVal_bool(obj2, &val3);
24539 if (!SWIG_IsOK(ecode3)) {
24540 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "3"" of type '" "bool""'");
24541 }
24542 arg3 = static_cast< bool >(val3);
24543 }
24544 {
24545 PyThreadState* __tstate = wxPyBeginAllowThreads();
24546 {
24547 wxDateTime &_result_ref = (arg1)->MakeFromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
24548 result = (wxDateTime *) &_result_ref;
24549 }
24550 wxPyEndAllowThreads(__tstate);
24551 if (PyErr_Occurred()) SWIG_fail;
24552 }
24553 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24554 {
24555 if (temp2) delete arg2;
24556 }
24557 return resultobj;
24558 fail:
24559 {
24560 if (temp2) delete arg2;
24561 }
24562 return NULL;
24563 }
24564
24565
24566 SWIGINTERN PyObject *_wrap_DateTime_ToUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24567 PyObject *resultobj = 0;
24568 wxDateTime *arg1 = (wxDateTime *) 0 ;
24569 bool arg2 = (bool) false ;
24570 wxDateTime result;
24571 void *argp1 = 0 ;
24572 int res1 = 0 ;
24573 bool val2 ;
24574 int ecode2 = 0 ;
24575 PyObject * obj0 = 0 ;
24576 PyObject * obj1 = 0 ;
24577 char * kwnames[] = {
24578 (char *) "self",(char *) "noDST", NULL
24579 };
24580
24581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToUTC",kwnames,&obj0,&obj1)) SWIG_fail;
24582 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24583 if (!SWIG_IsOK(res1)) {
24584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24585 }
24586 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24587 if (obj1) {
24588 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24589 if (!SWIG_IsOK(ecode2)) {
24590 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToUTC" "', expected argument " "2"" of type '" "bool""'");
24591 }
24592 arg2 = static_cast< bool >(val2);
24593 }
24594 {
24595 PyThreadState* __tstate = wxPyBeginAllowThreads();
24596 result = ((wxDateTime const *)arg1)->ToUTC(arg2);
24597 wxPyEndAllowThreads(__tstate);
24598 if (PyErr_Occurred()) SWIG_fail;
24599 }
24600 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24601 return resultobj;
24602 fail:
24603 return NULL;
24604 }
24605
24606
24607 SWIGINTERN PyObject *_wrap_DateTime_MakeUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24608 PyObject *resultobj = 0;
24609 wxDateTime *arg1 = (wxDateTime *) 0 ;
24610 bool arg2 = (bool) false ;
24611 wxDateTime *result = 0 ;
24612 void *argp1 = 0 ;
24613 int res1 = 0 ;
24614 bool val2 ;
24615 int ecode2 = 0 ;
24616 PyObject * obj0 = 0 ;
24617 PyObject * obj1 = 0 ;
24618 char * kwnames[] = {
24619 (char *) "self",(char *) "noDST", NULL
24620 };
24621
24622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeUTC",kwnames,&obj0,&obj1)) SWIG_fail;
24623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24624 if (!SWIG_IsOK(res1)) {
24625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
24626 }
24627 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24628 if (obj1) {
24629 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24630 if (!SWIG_IsOK(ecode2)) {
24631 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeUTC" "', expected argument " "2"" of type '" "bool""'");
24632 }
24633 arg2 = static_cast< bool >(val2);
24634 }
24635 {
24636 PyThreadState* __tstate = wxPyBeginAllowThreads();
24637 {
24638 wxDateTime &_result_ref = (arg1)->MakeUTC(arg2);
24639 result = (wxDateTime *) &_result_ref;
24640 }
24641 wxPyEndAllowThreads(__tstate);
24642 if (PyErr_Occurred()) SWIG_fail;
24643 }
24644 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24645 return resultobj;
24646 fail:
24647 return NULL;
24648 }
24649
24650
24651 SWIGINTERN PyObject *_wrap_DateTime_ToGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24652 PyObject *resultobj = 0;
24653 wxDateTime *arg1 = (wxDateTime *) 0 ;
24654 bool arg2 = (bool) false ;
24655 wxDateTime result;
24656 void *argp1 = 0 ;
24657 int res1 = 0 ;
24658 bool val2 ;
24659 int ecode2 = 0 ;
24660 PyObject * obj0 = 0 ;
24661 PyObject * obj1 = 0 ;
24662 char * kwnames[] = {
24663 (char *) "self",(char *) "noDST", NULL
24664 };
24665
24666 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) SWIG_fail;
24667 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24668 if (!SWIG_IsOK(res1)) {
24669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToGMT" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24670 }
24671 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24672 if (obj1) {
24673 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24674 if (!SWIG_IsOK(ecode2)) {
24675 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToGMT" "', expected argument " "2"" of type '" "bool""'");
24676 }
24677 arg2 = static_cast< bool >(val2);
24678 }
24679 {
24680 PyThreadState* __tstate = wxPyBeginAllowThreads();
24681 result = ((wxDateTime const *)arg1)->ToGMT(arg2);
24682 wxPyEndAllowThreads(__tstate);
24683 if (PyErr_Occurred()) SWIG_fail;
24684 }
24685 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24686 return resultobj;
24687 fail:
24688 return NULL;
24689 }
24690
24691
24692 SWIGINTERN PyObject *_wrap_DateTime_MakeGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24693 PyObject *resultobj = 0;
24694 wxDateTime *arg1 = (wxDateTime *) 0 ;
24695 bool arg2 = (bool) false ;
24696 wxDateTime *result = 0 ;
24697 void *argp1 = 0 ;
24698 int res1 = 0 ;
24699 bool val2 ;
24700 int ecode2 = 0 ;
24701 PyObject * obj0 = 0 ;
24702 PyObject * obj1 = 0 ;
24703 char * kwnames[] = {
24704 (char *) "self",(char *) "noDST", NULL
24705 };
24706
24707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) SWIG_fail;
24708 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24709 if (!SWIG_IsOK(res1)) {
24710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeGMT" "', expected argument " "1"" of type '" "wxDateTime *""'");
24711 }
24712 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24713 if (obj1) {
24714 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24715 if (!SWIG_IsOK(ecode2)) {
24716 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeGMT" "', expected argument " "2"" of type '" "bool""'");
24717 }
24718 arg2 = static_cast< bool >(val2);
24719 }
24720 {
24721 PyThreadState* __tstate = wxPyBeginAllowThreads();
24722 {
24723 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
24724 result = (wxDateTime *) &_result_ref;
24725 }
24726 wxPyEndAllowThreads(__tstate);
24727 if (PyErr_Occurred()) SWIG_fail;
24728 }
24729 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24730 return resultobj;
24731 fail:
24732 return NULL;
24733 }
24734
24735
24736 SWIGINTERN PyObject *_wrap_DateTime_FromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24737 PyObject *resultobj = 0;
24738 wxDateTime *arg1 = (wxDateTime *) 0 ;
24739 bool arg2 = (bool) false ;
24740 wxDateTime result;
24741 void *argp1 = 0 ;
24742 int res1 = 0 ;
24743 bool val2 ;
24744 int ecode2 = 0 ;
24745 PyObject * obj0 = 0 ;
24746 PyObject * obj1 = 0 ;
24747 char * kwnames[] = {
24748 (char *) "self",(char *) "noDST", NULL
24749 };
24750
24751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_FromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
24752 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24753 if (!SWIG_IsOK(res1)) {
24754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24755 }
24756 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24757 if (obj1) {
24758 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24759 if (!SWIG_IsOK(ecode2)) {
24760 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_FromUTC" "', expected argument " "2"" of type '" "bool""'");
24761 }
24762 arg2 = static_cast< bool >(val2);
24763 }
24764 {
24765 PyThreadState* __tstate = wxPyBeginAllowThreads();
24766 result = ((wxDateTime const *)arg1)->FromUTC(arg2);
24767 wxPyEndAllowThreads(__tstate);
24768 if (PyErr_Occurred()) SWIG_fail;
24769 }
24770 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24771 return resultobj;
24772 fail:
24773 return NULL;
24774 }
24775
24776
24777 SWIGINTERN PyObject *_wrap_DateTime_MakeFromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24778 PyObject *resultobj = 0;
24779 wxDateTime *arg1 = (wxDateTime *) 0 ;
24780 bool arg2 = (bool) false ;
24781 wxDateTime *result = 0 ;
24782 void *argp1 = 0 ;
24783 int res1 = 0 ;
24784 bool val2 ;
24785 int ecode2 = 0 ;
24786 PyObject * obj0 = 0 ;
24787 PyObject * obj1 = 0 ;
24788 char * kwnames[] = {
24789 (char *) "self",(char *) "noDST", NULL
24790 };
24791
24792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeFromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
24793 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24794 if (!SWIG_IsOK(res1)) {
24795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
24796 }
24797 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24798 if (obj1) {
24799 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24800 if (!SWIG_IsOK(ecode2)) {
24801 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeFromUTC" "', expected argument " "2"" of type '" "bool""'");
24802 }
24803 arg2 = static_cast< bool >(val2);
24804 }
24805 {
24806 PyThreadState* __tstate = wxPyBeginAllowThreads();
24807 {
24808 wxDateTime &_result_ref = (arg1)->MakeFromUTC(arg2);
24809 result = (wxDateTime *) &_result_ref;
24810 }
24811 wxPyEndAllowThreads(__tstate);
24812 if (PyErr_Occurred()) SWIG_fail;
24813 }
24814 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24815 return resultobj;
24816 fail:
24817 return NULL;
24818 }
24819
24820
24821 SWIGINTERN PyObject *_wrap_DateTime_IsDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24822 PyObject *resultobj = 0;
24823 wxDateTime *arg1 = (wxDateTime *) 0 ;
24824 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
24825 int result;
24826 void *argp1 = 0 ;
24827 int res1 = 0 ;
24828 int val2 ;
24829 int ecode2 = 0 ;
24830 PyObject * obj0 = 0 ;
24831 PyObject * obj1 = 0 ;
24832 char * kwnames[] = {
24833 (char *) "self",(char *) "country", NULL
24834 };
24835
24836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) SWIG_fail;
24837 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24838 if (!SWIG_IsOK(res1)) {
24839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsDST" "', expected argument " "1"" of type '" "wxDateTime *""'");
24840 }
24841 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24842 if (obj1) {
24843 ecode2 = SWIG_AsVal_int(obj1, &val2);
24844 if (!SWIG_IsOK(ecode2)) {
24845 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
24846 }
24847 arg2 = static_cast< wxDateTime::Country >(val2);
24848 }
24849 {
24850 PyThreadState* __tstate = wxPyBeginAllowThreads();
24851 result = (int)(arg1)->IsDST(arg2);
24852 wxPyEndAllowThreads(__tstate);
24853 if (PyErr_Occurred()) SWIG_fail;
24854 }
24855 resultobj = SWIG_From_int(static_cast< int >(result));
24856 return resultobj;
24857 fail:
24858 return NULL;
24859 }
24860
24861
24862 SWIGINTERN PyObject *_wrap_DateTime_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24863 PyObject *resultobj = 0;
24864 wxDateTime *arg1 = (wxDateTime *) 0 ;
24865 bool result;
24866 void *argp1 = 0 ;
24867 int res1 = 0 ;
24868 PyObject *swig_obj[1] ;
24869
24870 if (!args) SWIG_fail;
24871 swig_obj[0] = args;
24872 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24873 if (!SWIG_IsOK(res1)) {
24874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsValid" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24875 }
24876 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24877 {
24878 PyThreadState* __tstate = wxPyBeginAllowThreads();
24879 result = (bool)((wxDateTime const *)arg1)->IsValid();
24880 wxPyEndAllowThreads(__tstate);
24881 if (PyErr_Occurred()) SWIG_fail;
24882 }
24883 {
24884 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24885 }
24886 return resultobj;
24887 fail:
24888 return NULL;
24889 }
24890
24891
24892 SWIGINTERN PyObject *_wrap_DateTime_GetTicks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24893 PyObject *resultobj = 0;
24894 wxDateTime *arg1 = (wxDateTime *) 0 ;
24895 time_t result;
24896 void *argp1 = 0 ;
24897 int res1 = 0 ;
24898 PyObject *swig_obj[1] ;
24899
24900 if (!args) SWIG_fail;
24901 swig_obj[0] = args;
24902 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24903 if (!SWIG_IsOK(res1)) {
24904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetTicks" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24905 }
24906 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24907 {
24908 PyThreadState* __tstate = wxPyBeginAllowThreads();
24909 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
24910 wxPyEndAllowThreads(__tstate);
24911 if (PyErr_Occurred()) SWIG_fail;
24912 }
24913 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
24914 return resultobj;
24915 fail:
24916 return NULL;
24917 }
24918
24919
24920 SWIGINTERN PyObject *_wrap_DateTime_GetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24921 PyObject *resultobj = 0;
24922 wxDateTime *arg1 = (wxDateTime *) 0 ;
24923 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
24924 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
24925 int result;
24926 void *argp1 = 0 ;
24927 int res1 = 0 ;
24928 bool temp2 = false ;
24929 PyObject * obj0 = 0 ;
24930 PyObject * obj1 = 0 ;
24931 char * kwnames[] = {
24932 (char *) "self",(char *) "tz", NULL
24933 };
24934
24935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) SWIG_fail;
24936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24937 if (!SWIG_IsOK(res1)) {
24938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24939 }
24940 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24941 if (obj1) {
24942 {
24943 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24944 temp2 = true;
24945 }
24946 }
24947 {
24948 PyThreadState* __tstate = wxPyBeginAllowThreads();
24949 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
24950 wxPyEndAllowThreads(__tstate);
24951 if (PyErr_Occurred()) SWIG_fail;
24952 }
24953 resultobj = SWIG_From_int(static_cast< int >(result));
24954 {
24955 if (temp2) delete arg2;
24956 }
24957 return resultobj;
24958 fail:
24959 {
24960 if (temp2) delete arg2;
24961 }
24962 return NULL;
24963 }
24964
24965
24966 SWIGINTERN PyObject *_wrap_DateTime_GetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24967 PyObject *resultobj = 0;
24968 wxDateTime *arg1 = (wxDateTime *) 0 ;
24969 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
24970 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
24971 wxDateTime::Month result;
24972 void *argp1 = 0 ;
24973 int res1 = 0 ;
24974 bool temp2 = false ;
24975 PyObject * obj0 = 0 ;
24976 PyObject * obj1 = 0 ;
24977 char * kwnames[] = {
24978 (char *) "self",(char *) "tz", NULL
24979 };
24980
24981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
24982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24983 if (!SWIG_IsOK(res1)) {
24984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24985 }
24986 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24987 if (obj1) {
24988 {
24989 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24990 temp2 = true;
24991 }
24992 }
24993 {
24994 PyThreadState* __tstate = wxPyBeginAllowThreads();
24995 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
24996 wxPyEndAllowThreads(__tstate);
24997 if (PyErr_Occurred()) SWIG_fail;
24998 }
24999 resultobj = SWIG_From_int(static_cast< int >(result));
25000 {
25001 if (temp2) delete arg2;
25002 }
25003 return resultobj;
25004 fail:
25005 {
25006 if (temp2) delete arg2;
25007 }
25008 return NULL;
25009 }
25010
25011
25012 SWIGINTERN PyObject *_wrap_DateTime_GetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25013 PyObject *resultobj = 0;
25014 wxDateTime *arg1 = (wxDateTime *) 0 ;
25015 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25016 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25017 int result;
25018 void *argp1 = 0 ;
25019 int res1 = 0 ;
25020 bool temp2 = false ;
25021 PyObject * obj0 = 0 ;
25022 PyObject * obj1 = 0 ;
25023 char * kwnames[] = {
25024 (char *) "self",(char *) "tz", NULL
25025 };
25026
25027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) SWIG_fail;
25028 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25029 if (!SWIG_IsOK(res1)) {
25030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25031 }
25032 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25033 if (obj1) {
25034 {
25035 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25036 temp2 = true;
25037 }
25038 }
25039 {
25040 PyThreadState* __tstate = wxPyBeginAllowThreads();
25041 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
25042 wxPyEndAllowThreads(__tstate);
25043 if (PyErr_Occurred()) SWIG_fail;
25044 }
25045 resultobj = SWIG_From_int(static_cast< int >(result));
25046 {
25047 if (temp2) delete arg2;
25048 }
25049 return resultobj;
25050 fail:
25051 {
25052 if (temp2) delete arg2;
25053 }
25054 return NULL;
25055 }
25056
25057
25058 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25059 PyObject *resultobj = 0;
25060 wxDateTime *arg1 = (wxDateTime *) 0 ;
25061 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25062 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25063 wxDateTime::WeekDay result;
25064 void *argp1 = 0 ;
25065 int res1 = 0 ;
25066 bool temp2 = false ;
25067 PyObject * obj0 = 0 ;
25068 PyObject * obj1 = 0 ;
25069 char * kwnames[] = {
25070 (char *) "self",(char *) "tz", NULL
25071 };
25072
25073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
25074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25075 if (!SWIG_IsOK(res1)) {
25076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25077 }
25078 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25079 if (obj1) {
25080 {
25081 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25082 temp2 = true;
25083 }
25084 }
25085 {
25086 PyThreadState* __tstate = wxPyBeginAllowThreads();
25087 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
25088 wxPyEndAllowThreads(__tstate);
25089 if (PyErr_Occurred()) SWIG_fail;
25090 }
25091 resultobj = SWIG_From_int(static_cast< int >(result));
25092 {
25093 if (temp2) delete arg2;
25094 }
25095 return resultobj;
25096 fail:
25097 {
25098 if (temp2) delete arg2;
25099 }
25100 return NULL;
25101 }
25102
25103
25104 SWIGINTERN PyObject *_wrap_DateTime_GetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25105 PyObject *resultobj = 0;
25106 wxDateTime *arg1 = (wxDateTime *) 0 ;
25107 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25108 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25109 int result;
25110 void *argp1 = 0 ;
25111 int res1 = 0 ;
25112 bool temp2 = false ;
25113 PyObject * obj0 = 0 ;
25114 PyObject * obj1 = 0 ;
25115 char * kwnames[] = {
25116 (char *) "self",(char *) "tz", NULL
25117 };
25118
25119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) SWIG_fail;
25120 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25121 if (!SWIG_IsOK(res1)) {
25122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetHour" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25123 }
25124 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25125 if (obj1) {
25126 {
25127 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25128 temp2 = true;
25129 }
25130 }
25131 {
25132 PyThreadState* __tstate = wxPyBeginAllowThreads();
25133 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
25134 wxPyEndAllowThreads(__tstate);
25135 if (PyErr_Occurred()) SWIG_fail;
25136 }
25137 resultobj = SWIG_From_int(static_cast< int >(result));
25138 {
25139 if (temp2) delete arg2;
25140 }
25141 return resultobj;
25142 fail:
25143 {
25144 if (temp2) delete arg2;
25145 }
25146 return NULL;
25147 }
25148
25149
25150 SWIGINTERN PyObject *_wrap_DateTime_GetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25151 PyObject *resultobj = 0;
25152 wxDateTime *arg1 = (wxDateTime *) 0 ;
25153 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25154 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25155 int result;
25156 void *argp1 = 0 ;
25157 int res1 = 0 ;
25158 bool temp2 = false ;
25159 PyObject * obj0 = 0 ;
25160 PyObject * obj1 = 0 ;
25161 char * kwnames[] = {
25162 (char *) "self",(char *) "tz", NULL
25163 };
25164
25165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
25166 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25167 if (!SWIG_IsOK(res1)) {
25168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMinute" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25169 }
25170 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25171 if (obj1) {
25172 {
25173 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25174 temp2 = true;
25175 }
25176 }
25177 {
25178 PyThreadState* __tstate = wxPyBeginAllowThreads();
25179 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
25180 wxPyEndAllowThreads(__tstate);
25181 if (PyErr_Occurred()) SWIG_fail;
25182 }
25183 resultobj = SWIG_From_int(static_cast< int >(result));
25184 {
25185 if (temp2) delete arg2;
25186 }
25187 return resultobj;
25188 fail:
25189 {
25190 if (temp2) delete arg2;
25191 }
25192 return NULL;
25193 }
25194
25195
25196 SWIGINTERN PyObject *_wrap_DateTime_GetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25197 PyObject *resultobj = 0;
25198 wxDateTime *arg1 = (wxDateTime *) 0 ;
25199 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25200 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25201 int result;
25202 void *argp1 = 0 ;
25203 int res1 = 0 ;
25204 bool temp2 = false ;
25205 PyObject * obj0 = 0 ;
25206 PyObject * obj1 = 0 ;
25207 char * kwnames[] = {
25208 (char *) "self",(char *) "tz", NULL
25209 };
25210
25211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
25212 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25213 if (!SWIG_IsOK(res1)) {
25214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetSecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25215 }
25216 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25217 if (obj1) {
25218 {
25219 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25220 temp2 = true;
25221 }
25222 }
25223 {
25224 PyThreadState* __tstate = wxPyBeginAllowThreads();
25225 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
25226 wxPyEndAllowThreads(__tstate);
25227 if (PyErr_Occurred()) SWIG_fail;
25228 }
25229 resultobj = SWIG_From_int(static_cast< int >(result));
25230 {
25231 if (temp2) delete arg2;
25232 }
25233 return resultobj;
25234 fail:
25235 {
25236 if (temp2) delete arg2;
25237 }
25238 return NULL;
25239 }
25240
25241
25242 SWIGINTERN PyObject *_wrap_DateTime_GetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25243 PyObject *resultobj = 0;
25244 wxDateTime *arg1 = (wxDateTime *) 0 ;
25245 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25246 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25247 int result;
25248 void *argp1 = 0 ;
25249 int res1 = 0 ;
25250 bool temp2 = false ;
25251 PyObject * obj0 = 0 ;
25252 PyObject * obj1 = 0 ;
25253 char * kwnames[] = {
25254 (char *) "self",(char *) "tz", NULL
25255 };
25256
25257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
25258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25259 if (!SWIG_IsOK(res1)) {
25260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMillisecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25261 }
25262 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25263 if (obj1) {
25264 {
25265 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25266 temp2 = true;
25267 }
25268 }
25269 {
25270 PyThreadState* __tstate = wxPyBeginAllowThreads();
25271 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
25272 wxPyEndAllowThreads(__tstate);
25273 if (PyErr_Occurred()) SWIG_fail;
25274 }
25275 resultobj = SWIG_From_int(static_cast< int >(result));
25276 {
25277 if (temp2) delete arg2;
25278 }
25279 return resultobj;
25280 fail:
25281 {
25282 if (temp2) delete arg2;
25283 }
25284 return NULL;
25285 }
25286
25287
25288 SWIGINTERN PyObject *_wrap_DateTime_GetDayOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25289 PyObject *resultobj = 0;
25290 wxDateTime *arg1 = (wxDateTime *) 0 ;
25291 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25292 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25293 int result;
25294 void *argp1 = 0 ;
25295 int res1 = 0 ;
25296 bool temp2 = false ;
25297 PyObject * obj0 = 0 ;
25298 PyObject * obj1 = 0 ;
25299 char * kwnames[] = {
25300 (char *) "self",(char *) "tz", NULL
25301 };
25302
25303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) SWIG_fail;
25304 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25305 if (!SWIG_IsOK(res1)) {
25306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDayOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25307 }
25308 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25309 if (obj1) {
25310 {
25311 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25312 temp2 = true;
25313 }
25314 }
25315 {
25316 PyThreadState* __tstate = wxPyBeginAllowThreads();
25317 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
25318 wxPyEndAllowThreads(__tstate);
25319 if (PyErr_Occurred()) SWIG_fail;
25320 }
25321 resultobj = SWIG_From_int(static_cast< int >(result));
25322 {
25323 if (temp2) delete arg2;
25324 }
25325 return resultobj;
25326 fail:
25327 {
25328 if (temp2) delete arg2;
25329 }
25330 return NULL;
25331 }
25332
25333
25334 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25335 PyObject *resultobj = 0;
25336 wxDateTime *arg1 = (wxDateTime *) 0 ;
25337 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25338 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
25339 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
25340 int result;
25341 void *argp1 = 0 ;
25342 int res1 = 0 ;
25343 int val2 ;
25344 int ecode2 = 0 ;
25345 bool temp3 = false ;
25346 PyObject * obj0 = 0 ;
25347 PyObject * obj1 = 0 ;
25348 PyObject * obj2 = 0 ;
25349 char * kwnames[] = {
25350 (char *) "self",(char *) "flags",(char *) "tz", NULL
25351 };
25352
25353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25354 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25355 if (!SWIG_IsOK(res1)) {
25356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25357 }
25358 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25359 if (obj1) {
25360 ecode2 = SWIG_AsVal_int(obj1, &val2);
25361 if (!SWIG_IsOK(ecode2)) {
25362 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
25363 }
25364 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
25365 }
25366 if (obj2) {
25367 {
25368 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
25369 temp3 = true;
25370 }
25371 }
25372 {
25373 PyThreadState* __tstate = wxPyBeginAllowThreads();
25374 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear(arg2,(wxDateTime::TimeZone const &)*arg3);
25375 wxPyEndAllowThreads(__tstate);
25376 if (PyErr_Occurred()) SWIG_fail;
25377 }
25378 resultobj = SWIG_From_int(static_cast< int >(result));
25379 {
25380 if (temp3) delete arg3;
25381 }
25382 return resultobj;
25383 fail:
25384 {
25385 if (temp3) delete arg3;
25386 }
25387 return NULL;
25388 }
25389
25390
25391 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25392 PyObject *resultobj = 0;
25393 wxDateTime *arg1 = (wxDateTime *) 0 ;
25394 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25395 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
25396 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
25397 int result;
25398 void *argp1 = 0 ;
25399 int res1 = 0 ;
25400 int val2 ;
25401 int ecode2 = 0 ;
25402 bool temp3 = false ;
25403 PyObject * obj0 = 0 ;
25404 PyObject * obj1 = 0 ;
25405 PyObject * obj2 = 0 ;
25406 char * kwnames[] = {
25407 (char *) "self",(char *) "flags",(char *) "tz", NULL
25408 };
25409
25410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25411 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25412 if (!SWIG_IsOK(res1)) {
25413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25414 }
25415 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25416 if (obj1) {
25417 ecode2 = SWIG_AsVal_int(obj1, &val2);
25418 if (!SWIG_IsOK(ecode2)) {
25419 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
25420 }
25421 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
25422 }
25423 if (obj2) {
25424 {
25425 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
25426 temp3 = true;
25427 }
25428 }
25429 {
25430 PyThreadState* __tstate = wxPyBeginAllowThreads();
25431 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth(arg2,(wxDateTime::TimeZone const &)*arg3);
25432 wxPyEndAllowThreads(__tstate);
25433 if (PyErr_Occurred()) SWIG_fail;
25434 }
25435 resultobj = SWIG_From_int(static_cast< int >(result));
25436 {
25437 if (temp3) delete arg3;
25438 }
25439 return resultobj;
25440 fail:
25441 {
25442 if (temp3) delete arg3;
25443 }
25444 return NULL;
25445 }
25446
25447
25448 SWIGINTERN PyObject *_wrap_DateTime_IsWorkDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25449 PyObject *resultobj = 0;
25450 wxDateTime *arg1 = (wxDateTime *) 0 ;
25451 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
25452 bool result;
25453 void *argp1 = 0 ;
25454 int res1 = 0 ;
25455 int val2 ;
25456 int ecode2 = 0 ;
25457 PyObject * obj0 = 0 ;
25458 PyObject * obj1 = 0 ;
25459 char * kwnames[] = {
25460 (char *) "self",(char *) "country", NULL
25461 };
25462
25463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) SWIG_fail;
25464 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25465 if (!SWIG_IsOK(res1)) {
25466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsWorkDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25467 }
25468 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25469 if (obj1) {
25470 ecode2 = SWIG_AsVal_int(obj1, &val2);
25471 if (!SWIG_IsOK(ecode2)) {
25472 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsWorkDay" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
25473 }
25474 arg2 = static_cast< wxDateTime::Country >(val2);
25475 }
25476 {
25477 PyThreadState* __tstate = wxPyBeginAllowThreads();
25478 result = (bool)((wxDateTime const *)arg1)->IsWorkDay(arg2);
25479 wxPyEndAllowThreads(__tstate);
25480 if (PyErr_Occurred()) SWIG_fail;
25481 }
25482 {
25483 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25484 }
25485 return resultobj;
25486 fail:
25487 return NULL;
25488 }
25489
25490
25491 SWIGINTERN PyObject *_wrap_DateTime_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25492 PyObject *resultobj = 0;
25493 wxDateTime *arg1 = (wxDateTime *) 0 ;
25494 wxDateTime *arg2 = 0 ;
25495 bool result;
25496 void *argp1 = 0 ;
25497 int res1 = 0 ;
25498 void *argp2 = 0 ;
25499 int res2 = 0 ;
25500 PyObject * obj0 = 0 ;
25501 PyObject * obj1 = 0 ;
25502 char * kwnames[] = {
25503 (char *) "self",(char *) "datetime", NULL
25504 };
25505
25506 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
25507 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25508 if (!SWIG_IsOK(res1)) {
25509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25510 }
25511 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25512 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25513 if (!SWIG_IsOK(res2)) {
25514 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25515 }
25516 if (!argp2) {
25517 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25518 }
25519 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25520 {
25521 PyThreadState* __tstate = wxPyBeginAllowThreads();
25522 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
25523 wxPyEndAllowThreads(__tstate);
25524 if (PyErr_Occurred()) SWIG_fail;
25525 }
25526 {
25527 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25528 }
25529 return resultobj;
25530 fail:
25531 return NULL;
25532 }
25533
25534
25535 SWIGINTERN PyObject *_wrap_DateTime_IsEarlierThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25536 PyObject *resultobj = 0;
25537 wxDateTime *arg1 = (wxDateTime *) 0 ;
25538 wxDateTime *arg2 = 0 ;
25539 bool result;
25540 void *argp1 = 0 ;
25541 int res1 = 0 ;
25542 void *argp2 = 0 ;
25543 int res2 = 0 ;
25544 PyObject * obj0 = 0 ;
25545 PyObject * obj1 = 0 ;
25546 char * kwnames[] = {
25547 (char *) "self",(char *) "datetime", NULL
25548 };
25549
25550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) SWIG_fail;
25551 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25552 if (!SWIG_IsOK(res1)) {
25553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEarlierThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25554 }
25555 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25556 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25557 if (!SWIG_IsOK(res2)) {
25558 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25559 }
25560 if (!argp2) {
25561 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25562 }
25563 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25564 {
25565 PyThreadState* __tstate = wxPyBeginAllowThreads();
25566 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
25567 wxPyEndAllowThreads(__tstate);
25568 if (PyErr_Occurred()) SWIG_fail;
25569 }
25570 {
25571 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25572 }
25573 return resultobj;
25574 fail:
25575 return NULL;
25576 }
25577
25578
25579 SWIGINTERN PyObject *_wrap_DateTime_IsLaterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25580 PyObject *resultobj = 0;
25581 wxDateTime *arg1 = (wxDateTime *) 0 ;
25582 wxDateTime *arg2 = 0 ;
25583 bool result;
25584 void *argp1 = 0 ;
25585 int res1 = 0 ;
25586 void *argp2 = 0 ;
25587 int res2 = 0 ;
25588 PyObject * obj0 = 0 ;
25589 PyObject * obj1 = 0 ;
25590 char * kwnames[] = {
25591 (char *) "self",(char *) "datetime", NULL
25592 };
25593
25594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) SWIG_fail;
25595 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25596 if (!SWIG_IsOK(res1)) {
25597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsLaterThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25598 }
25599 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25600 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25601 if (!SWIG_IsOK(res2)) {
25602 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25603 }
25604 if (!argp2) {
25605 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25606 }
25607 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25608 {
25609 PyThreadState* __tstate = wxPyBeginAllowThreads();
25610 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
25611 wxPyEndAllowThreads(__tstate);
25612 if (PyErr_Occurred()) SWIG_fail;
25613 }
25614 {
25615 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25616 }
25617 return resultobj;
25618 fail:
25619 return NULL;
25620 }
25621
25622
25623 SWIGINTERN PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25624 PyObject *resultobj = 0;
25625 wxDateTime *arg1 = (wxDateTime *) 0 ;
25626 wxDateTime *arg2 = 0 ;
25627 wxDateTime *arg3 = 0 ;
25628 bool result;
25629 void *argp1 = 0 ;
25630 int res1 = 0 ;
25631 void *argp2 = 0 ;
25632 int res2 = 0 ;
25633 void *argp3 = 0 ;
25634 int res3 = 0 ;
25635 PyObject * obj0 = 0 ;
25636 PyObject * obj1 = 0 ;
25637 PyObject * obj2 = 0 ;
25638 char * kwnames[] = {
25639 (char *) "self",(char *) "t1",(char *) "t2", NULL
25640 };
25641
25642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25643 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25644 if (!SWIG_IsOK(res1)) {
25645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25646 }
25647 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25648 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25649 if (!SWIG_IsOK(res2)) {
25650 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25651 }
25652 if (!argp2) {
25653 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25654 }
25655 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25656 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
25657 if (!SWIG_IsOK(res3)) {
25658 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
25659 }
25660 if (!argp3) {
25661 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
25662 }
25663 arg3 = reinterpret_cast< wxDateTime * >(argp3);
25664 {
25665 PyThreadState* __tstate = wxPyBeginAllowThreads();
25666 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
25667 wxPyEndAllowThreads(__tstate);
25668 if (PyErr_Occurred()) SWIG_fail;
25669 }
25670 {
25671 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25672 }
25673 return resultobj;
25674 fail:
25675 return NULL;
25676 }
25677
25678
25679 SWIGINTERN PyObject *_wrap_DateTime_IsBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25680 PyObject *resultobj = 0;
25681 wxDateTime *arg1 = (wxDateTime *) 0 ;
25682 wxDateTime *arg2 = 0 ;
25683 wxDateTime *arg3 = 0 ;
25684 bool result;
25685 void *argp1 = 0 ;
25686 int res1 = 0 ;
25687 void *argp2 = 0 ;
25688 int res2 = 0 ;
25689 void *argp3 = 0 ;
25690 int res3 = 0 ;
25691 PyObject * obj0 = 0 ;
25692 PyObject * obj1 = 0 ;
25693 PyObject * obj2 = 0 ;
25694 char * kwnames[] = {
25695 (char *) "self",(char *) "t1",(char *) "t2", NULL
25696 };
25697
25698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25699 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25700 if (!SWIG_IsOK(res1)) {
25701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25702 }
25703 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25704 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25705 if (!SWIG_IsOK(res2)) {
25706 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25707 }
25708 if (!argp2) {
25709 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25710 }
25711 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25712 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
25713 if (!SWIG_IsOK(res3)) {
25714 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
25715 }
25716 if (!argp3) {
25717 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
25718 }
25719 arg3 = reinterpret_cast< wxDateTime * >(argp3);
25720 {
25721 PyThreadState* __tstate = wxPyBeginAllowThreads();
25722 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
25723 wxPyEndAllowThreads(__tstate);
25724 if (PyErr_Occurred()) SWIG_fail;
25725 }
25726 {
25727 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25728 }
25729 return resultobj;
25730 fail:
25731 return NULL;
25732 }
25733
25734
25735 SWIGINTERN PyObject *_wrap_DateTime_IsSameDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25736 PyObject *resultobj = 0;
25737 wxDateTime *arg1 = (wxDateTime *) 0 ;
25738 wxDateTime *arg2 = 0 ;
25739 bool result;
25740 void *argp1 = 0 ;
25741 int res1 = 0 ;
25742 void *argp2 = 0 ;
25743 int res2 = 0 ;
25744 PyObject * obj0 = 0 ;
25745 PyObject * obj1 = 0 ;
25746 char * kwnames[] = {
25747 (char *) "self",(char *) "dt", NULL
25748 };
25749
25750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) SWIG_fail;
25751 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25752 if (!SWIG_IsOK(res1)) {
25753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25754 }
25755 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25756 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25757 if (!SWIG_IsOK(res2)) {
25758 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25759 }
25760 if (!argp2) {
25761 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25762 }
25763 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25764 {
25765 PyThreadState* __tstate = wxPyBeginAllowThreads();
25766 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
25767 wxPyEndAllowThreads(__tstate);
25768 if (PyErr_Occurred()) SWIG_fail;
25769 }
25770 {
25771 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25772 }
25773 return resultobj;
25774 fail:
25775 return NULL;
25776 }
25777
25778
25779 SWIGINTERN PyObject *_wrap_DateTime_IsSameTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25780 PyObject *resultobj = 0;
25781 wxDateTime *arg1 = (wxDateTime *) 0 ;
25782 wxDateTime *arg2 = 0 ;
25783 bool result;
25784 void *argp1 = 0 ;
25785 int res1 = 0 ;
25786 void *argp2 = 0 ;
25787 int res2 = 0 ;
25788 PyObject * obj0 = 0 ;
25789 PyObject * obj1 = 0 ;
25790 char * kwnames[] = {
25791 (char *) "self",(char *) "dt", NULL
25792 };
25793
25794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) SWIG_fail;
25795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25796 if (!SWIG_IsOK(res1)) {
25797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25798 }
25799 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25800 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25801 if (!SWIG_IsOK(res2)) {
25802 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25803 }
25804 if (!argp2) {
25805 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25806 }
25807 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25808 {
25809 PyThreadState* __tstate = wxPyBeginAllowThreads();
25810 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
25811 wxPyEndAllowThreads(__tstate);
25812 if (PyErr_Occurred()) SWIG_fail;
25813 }
25814 {
25815 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25816 }
25817 return resultobj;
25818 fail:
25819 return NULL;
25820 }
25821
25822
25823 SWIGINTERN PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25824 PyObject *resultobj = 0;
25825 wxDateTime *arg1 = (wxDateTime *) 0 ;
25826 wxDateTime *arg2 = 0 ;
25827 wxTimeSpan *arg3 = 0 ;
25828 bool result;
25829 void *argp1 = 0 ;
25830 int res1 = 0 ;
25831 void *argp2 = 0 ;
25832 int res2 = 0 ;
25833 void *argp3 = 0 ;
25834 int res3 = 0 ;
25835 PyObject * obj0 = 0 ;
25836 PyObject * obj1 = 0 ;
25837 PyObject * obj2 = 0 ;
25838 char * kwnames[] = {
25839 (char *) "self",(char *) "dt",(char *) "ts", NULL
25840 };
25841
25842 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25843 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25844 if (!SWIG_IsOK(res1)) {
25845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25846 }
25847 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25848 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25849 if (!SWIG_IsOK(res2)) {
25850 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25851 }
25852 if (!argp2) {
25853 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25854 }
25855 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25856 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxTimeSpan, 0 | 0);
25857 if (!SWIG_IsOK(res3)) {
25858 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
25859 }
25860 if (!argp3) {
25861 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
25862 }
25863 arg3 = reinterpret_cast< wxTimeSpan * >(argp3);
25864 {
25865 PyThreadState* __tstate = wxPyBeginAllowThreads();
25866 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
25867 wxPyEndAllowThreads(__tstate);
25868 if (PyErr_Occurred()) SWIG_fail;
25869 }
25870 {
25871 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25872 }
25873 return resultobj;
25874 fail:
25875 return NULL;
25876 }
25877
25878
25879 SWIGINTERN PyObject *_wrap_DateTime_AddTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25880 PyObject *resultobj = 0;
25881 wxDateTime *arg1 = (wxDateTime *) 0 ;
25882 wxTimeSpan *arg2 = 0 ;
25883 wxDateTime *result = 0 ;
25884 void *argp1 = 0 ;
25885 int res1 = 0 ;
25886 void *argp2 = 0 ;
25887 int res2 = 0 ;
25888 PyObject * obj0 = 0 ;
25889 PyObject * obj1 = 0 ;
25890 char * kwnames[] = {
25891 (char *) "self",(char *) "diff", NULL
25892 };
25893
25894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) SWIG_fail;
25895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25896 if (!SWIG_IsOK(res1)) {
25897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
25898 }
25899 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25900 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
25901 if (!SWIG_IsOK(res2)) {
25902 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
25903 }
25904 if (!argp2) {
25905 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
25906 }
25907 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
25908 {
25909 PyThreadState* __tstate = wxPyBeginAllowThreads();
25910 {
25911 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
25912 result = (wxDateTime *) &_result_ref;
25913 }
25914 wxPyEndAllowThreads(__tstate);
25915 if (PyErr_Occurred()) SWIG_fail;
25916 }
25917 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25918 return resultobj;
25919 fail:
25920 return NULL;
25921 }
25922
25923
25924 SWIGINTERN PyObject *_wrap_DateTime_AddDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25925 PyObject *resultobj = 0;
25926 wxDateTime *arg1 = (wxDateTime *) 0 ;
25927 wxDateSpan *arg2 = 0 ;
25928 wxDateTime *result = 0 ;
25929 void *argp1 = 0 ;
25930 int res1 = 0 ;
25931 void *argp2 = 0 ;
25932 int res2 = 0 ;
25933 PyObject * obj0 = 0 ;
25934 PyObject * obj1 = 0 ;
25935 char * kwnames[] = {
25936 (char *) "self",(char *) "diff", NULL
25937 };
25938
25939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) SWIG_fail;
25940 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25941 if (!SWIG_IsOK(res1)) {
25942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
25943 }
25944 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25945 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
25946 if (!SWIG_IsOK(res2)) {
25947 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
25948 }
25949 if (!argp2) {
25950 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
25951 }
25952 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
25953 {
25954 PyThreadState* __tstate = wxPyBeginAllowThreads();
25955 {
25956 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
25957 result = (wxDateTime *) &_result_ref;
25958 }
25959 wxPyEndAllowThreads(__tstate);
25960 if (PyErr_Occurred()) SWIG_fail;
25961 }
25962 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25963 return resultobj;
25964 fail:
25965 return NULL;
25966 }
25967
25968
25969 SWIGINTERN PyObject *_wrap_DateTime_SubtractTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25970 PyObject *resultobj = 0;
25971 wxDateTime *arg1 = (wxDateTime *) 0 ;
25972 wxTimeSpan *arg2 = 0 ;
25973 wxDateTime *result = 0 ;
25974 void *argp1 = 0 ;
25975 int res1 = 0 ;
25976 void *argp2 = 0 ;
25977 int res2 = 0 ;
25978 PyObject * obj0 = 0 ;
25979 PyObject * obj1 = 0 ;
25980 char * kwnames[] = {
25981 (char *) "self",(char *) "diff", NULL
25982 };
25983
25984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) SWIG_fail;
25985 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25986 if (!SWIG_IsOK(res1)) {
25987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
25988 }
25989 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25990 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
25991 if (!SWIG_IsOK(res2)) {
25992 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
25993 }
25994 if (!argp2) {
25995 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
25996 }
25997 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
25998 {
25999 PyThreadState* __tstate = wxPyBeginAllowThreads();
26000 {
26001 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
26002 result = (wxDateTime *) &_result_ref;
26003 }
26004 wxPyEndAllowThreads(__tstate);
26005 if (PyErr_Occurred()) SWIG_fail;
26006 }
26007 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26008 return resultobj;
26009 fail:
26010 return NULL;
26011 }
26012
26013
26014 SWIGINTERN PyObject *_wrap_DateTime_SubtractDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26015 PyObject *resultobj = 0;
26016 wxDateTime *arg1 = (wxDateTime *) 0 ;
26017 wxDateSpan *arg2 = 0 ;
26018 wxDateTime *result = 0 ;
26019 void *argp1 = 0 ;
26020 int res1 = 0 ;
26021 void *argp2 = 0 ;
26022 int res2 = 0 ;
26023 PyObject * obj0 = 0 ;
26024 PyObject * obj1 = 0 ;
26025 char * kwnames[] = {
26026 (char *) "self",(char *) "diff", NULL
26027 };
26028
26029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) SWIG_fail;
26030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26031 if (!SWIG_IsOK(res1)) {
26032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
26033 }
26034 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26035 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26036 if (!SWIG_IsOK(res2)) {
26037 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26038 }
26039 if (!argp2) {
26040 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26041 }
26042 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26043 {
26044 PyThreadState* __tstate = wxPyBeginAllowThreads();
26045 {
26046 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
26047 result = (wxDateTime *) &_result_ref;
26048 }
26049 wxPyEndAllowThreads(__tstate);
26050 if (PyErr_Occurred()) SWIG_fail;
26051 }
26052 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26053 return resultobj;
26054 fail:
26055 return NULL;
26056 }
26057
26058
26059 SWIGINTERN PyObject *_wrap_DateTime_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26060 PyObject *resultobj = 0;
26061 wxDateTime *arg1 = (wxDateTime *) 0 ;
26062 wxDateTime *arg2 = 0 ;
26063 wxTimeSpan result;
26064 void *argp1 = 0 ;
26065 int res1 = 0 ;
26066 void *argp2 = 0 ;
26067 int res2 = 0 ;
26068 PyObject * obj0 = 0 ;
26069 PyObject * obj1 = 0 ;
26070 char * kwnames[] = {
26071 (char *) "self",(char *) "dt", NULL
26072 };
26073
26074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
26075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26076 if (!SWIG_IsOK(res1)) {
26077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Subtract" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26078 }
26079 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26080 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26081 if (!SWIG_IsOK(res2)) {
26082 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26083 }
26084 if (!argp2) {
26085 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26086 }
26087 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26088 {
26089 PyThreadState* __tstate = wxPyBeginAllowThreads();
26090 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
26091 wxPyEndAllowThreads(__tstate);
26092 if (PyErr_Occurred()) SWIG_fail;
26093 }
26094 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
26095 return resultobj;
26096 fail:
26097 return NULL;
26098 }
26099
26100
26101 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26102 PyObject *resultobj = 0;
26103 wxDateTime *arg1 = (wxDateTime *) 0 ;
26104 wxTimeSpan *arg2 = 0 ;
26105 wxDateTime *result = 0 ;
26106 void *argp1 = 0 ;
26107 int res1 = 0 ;
26108 void *argp2 = 0 ;
26109 int res2 = 0 ;
26110
26111 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26112 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
26113 if (!SWIG_IsOK(res1)) {
26114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26115 }
26116 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26117 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26118 if (!SWIG_IsOK(res2)) {
26119 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26120 }
26121 if (!argp2) {
26122 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26123 }
26124 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26125 {
26126 PyThreadState* __tstate = wxPyBeginAllowThreads();
26127 {
26128 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
26129 result = (wxDateTime *) &_result_ref;
26130 }
26131 wxPyEndAllowThreads(__tstate);
26132 if (PyErr_Occurred()) SWIG_fail;
26133 }
26134 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26135 return resultobj;
26136 fail:
26137 return NULL;
26138 }
26139
26140
26141 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26142 PyObject *resultobj = 0;
26143 wxDateTime *arg1 = (wxDateTime *) 0 ;
26144 wxDateSpan *arg2 = 0 ;
26145 wxDateTime *result = 0 ;
26146 void *argp1 = 0 ;
26147 int res1 = 0 ;
26148 void *argp2 = 0 ;
26149 int res2 = 0 ;
26150
26151 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26152 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
26153 if (!SWIG_IsOK(res1)) {
26154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26155 }
26156 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26157 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26158 if (!SWIG_IsOK(res2)) {
26159 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26160 }
26161 if (!argp2) {
26162 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26163 }
26164 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26165 {
26166 PyThreadState* __tstate = wxPyBeginAllowThreads();
26167 {
26168 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
26169 result = (wxDateTime *) &_result_ref;
26170 }
26171 wxPyEndAllowThreads(__tstate);
26172 if (PyErr_Occurred()) SWIG_fail;
26173 }
26174 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26175 return resultobj;
26176 fail:
26177 return NULL;
26178 }
26179
26180
26181 SWIGINTERN PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
26182 int argc;
26183 PyObject *argv[3];
26184
26185 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___iadd__",0,2,argv))) SWIG_fail;
26186 --argc;
26187 if (argc == 2) {
26188 int _v = 0;
26189 {
26190 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
26191 _v = SWIG_CheckState(res);
26192 }
26193 if (!_v) goto check_1;
26194 return _wrap_DateTime___iadd____SWIG_0(self, argc, argv);
26195 }
26196 check_1:
26197
26198 if (argc == 2) {
26199 return _wrap_DateTime___iadd____SWIG_1(self, argc, argv);
26200 }
26201
26202 fail:
26203 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
26204 return NULL;
26205 }
26206
26207
26208 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26209 PyObject *resultobj = 0;
26210 wxDateTime *arg1 = (wxDateTime *) 0 ;
26211 wxTimeSpan *arg2 = 0 ;
26212 wxDateTime *result = 0 ;
26213 void *argp1 = 0 ;
26214 int res1 = 0 ;
26215 void *argp2 = 0 ;
26216 int res2 = 0 ;
26217
26218 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26219 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
26220 if (!SWIG_IsOK(res1)) {
26221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26222 }
26223 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26224 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26225 if (!SWIG_IsOK(res2)) {
26226 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26227 }
26228 if (!argp2) {
26229 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26230 }
26231 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26232 {
26233 PyThreadState* __tstate = wxPyBeginAllowThreads();
26234 {
26235 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
26236 result = (wxDateTime *) &_result_ref;
26237 }
26238 wxPyEndAllowThreads(__tstate);
26239 if (PyErr_Occurred()) SWIG_fail;
26240 }
26241 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26242 return resultobj;
26243 fail:
26244 return NULL;
26245 }
26246
26247
26248 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26249 PyObject *resultobj = 0;
26250 wxDateTime *arg1 = (wxDateTime *) 0 ;
26251 wxDateSpan *arg2 = 0 ;
26252 wxDateTime *result = 0 ;
26253 void *argp1 = 0 ;
26254 int res1 = 0 ;
26255 void *argp2 = 0 ;
26256 int res2 = 0 ;
26257
26258 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
26260 if (!SWIG_IsOK(res1)) {
26261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26262 }
26263 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26264 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26265 if (!SWIG_IsOK(res2)) {
26266 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26267 }
26268 if (!argp2) {
26269 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26270 }
26271 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26272 {
26273 PyThreadState* __tstate = wxPyBeginAllowThreads();
26274 {
26275 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
26276 result = (wxDateTime *) &_result_ref;
26277 }
26278 wxPyEndAllowThreads(__tstate);
26279 if (PyErr_Occurred()) SWIG_fail;
26280 }
26281 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26282 return resultobj;
26283 fail:
26284 return NULL;
26285 }
26286
26287
26288 SWIGINTERN PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
26289 int argc;
26290 PyObject *argv[3];
26291
26292 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___isub__",0,2,argv))) SWIG_fail;
26293 --argc;
26294 if (argc == 2) {
26295 int _v = 0;
26296 {
26297 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
26298 _v = SWIG_CheckState(res);
26299 }
26300 if (!_v) goto check_1;
26301 return _wrap_DateTime___isub____SWIG_0(self, argc, argv);
26302 }
26303 check_1:
26304
26305 if (argc == 2) {
26306 return _wrap_DateTime___isub____SWIG_1(self, argc, argv);
26307 }
26308
26309 fail:
26310 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
26311 return NULL;
26312 }
26313
26314
26315 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26316 PyObject *resultobj = 0;
26317 wxDateTime *arg1 = (wxDateTime *) 0 ;
26318 wxTimeSpan *arg2 = 0 ;
26319 wxDateTime result;
26320 void *argp1 = 0 ;
26321 int res1 = 0 ;
26322 void *argp2 = 0 ;
26323 int res2 = 0 ;
26324
26325 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26326 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26327 if (!SWIG_IsOK(res1)) {
26328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26329 }
26330 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26331 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26332 if (!SWIG_IsOK(res2)) {
26333 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26334 }
26335 if (!argp2) {
26336 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26337 }
26338 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26339 {
26340 PyThreadState* __tstate = wxPyBeginAllowThreads();
26341 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
26342 wxPyEndAllowThreads(__tstate);
26343 if (PyErr_Occurred()) SWIG_fail;
26344 }
26345 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26346 return resultobj;
26347 fail:
26348 return NULL;
26349 }
26350
26351
26352 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26353 PyObject *resultobj = 0;
26354 wxDateTime *arg1 = (wxDateTime *) 0 ;
26355 wxDateSpan *arg2 = 0 ;
26356 wxDateTime result;
26357 void *argp1 = 0 ;
26358 int res1 = 0 ;
26359 void *argp2 = 0 ;
26360 int res2 = 0 ;
26361
26362 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26363 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26364 if (!SWIG_IsOK(res1)) {
26365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26366 }
26367 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26368 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26369 if (!SWIG_IsOK(res2)) {
26370 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26371 }
26372 if (!argp2) {
26373 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26374 }
26375 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26376 {
26377 PyThreadState* __tstate = wxPyBeginAllowThreads();
26378 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
26379 wxPyEndAllowThreads(__tstate);
26380 if (PyErr_Occurred()) SWIG_fail;
26381 }
26382 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26383 return resultobj;
26384 fail:
26385 return NULL;
26386 }
26387
26388
26389 SWIGINTERN PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
26390 int argc;
26391 PyObject *argv[3];
26392
26393 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___add__",0,2,argv))) SWIG_fail;
26394 --argc;
26395 if (argc == 2) {
26396 int _v = 0;
26397 {
26398 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
26399 _v = SWIG_CheckState(res);
26400 }
26401 if (!_v) goto check_1;
26402 return _wrap_DateTime___add____SWIG_0(self, argc, argv);
26403 }
26404 check_1:
26405
26406 if (argc == 2) {
26407 return _wrap_DateTime___add____SWIG_1(self, argc, argv);
26408 }
26409
26410 fail:
26411 Py_INCREF(Py_NotImplemented);
26412 return Py_NotImplemented;
26413 }
26414
26415
26416 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26417 PyObject *resultobj = 0;
26418 wxDateTime *arg1 = (wxDateTime *) 0 ;
26419 wxDateTime *arg2 = 0 ;
26420 wxTimeSpan result;
26421 void *argp1 = 0 ;
26422 int res1 = 0 ;
26423 void *argp2 = 0 ;
26424 int res2 = 0 ;
26425
26426 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26427 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26428 if (!SWIG_IsOK(res1)) {
26429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26430 }
26431 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26432 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26433 if (!SWIG_IsOK(res2)) {
26434 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26435 }
26436 if (!argp2) {
26437 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26438 }
26439 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26440 {
26441 PyThreadState* __tstate = wxPyBeginAllowThreads();
26442 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
26443 wxPyEndAllowThreads(__tstate);
26444 if (PyErr_Occurred()) SWIG_fail;
26445 }
26446 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
26447 return resultobj;
26448 fail:
26449 return NULL;
26450 }
26451
26452
26453 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26454 PyObject *resultobj = 0;
26455 wxDateTime *arg1 = (wxDateTime *) 0 ;
26456 wxTimeSpan *arg2 = 0 ;
26457 wxDateTime result;
26458 void *argp1 = 0 ;
26459 int res1 = 0 ;
26460 void *argp2 = 0 ;
26461 int res2 = 0 ;
26462
26463 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26464 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26465 if (!SWIG_IsOK(res1)) {
26466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26467 }
26468 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26469 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26470 if (!SWIG_IsOK(res2)) {
26471 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26472 }
26473 if (!argp2) {
26474 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26475 }
26476 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26477 {
26478 PyThreadState* __tstate = wxPyBeginAllowThreads();
26479 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
26480 wxPyEndAllowThreads(__tstate);
26481 if (PyErr_Occurred()) SWIG_fail;
26482 }
26483 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26484 return resultobj;
26485 fail:
26486 return NULL;
26487 }
26488
26489
26490 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26491 PyObject *resultobj = 0;
26492 wxDateTime *arg1 = (wxDateTime *) 0 ;
26493 wxDateSpan *arg2 = 0 ;
26494 wxDateTime result;
26495 void *argp1 = 0 ;
26496 int res1 = 0 ;
26497 void *argp2 = 0 ;
26498 int res2 = 0 ;
26499
26500 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26501 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26502 if (!SWIG_IsOK(res1)) {
26503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26504 }
26505 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26506 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26507 if (!SWIG_IsOK(res2)) {
26508 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26509 }
26510 if (!argp2) {
26511 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26512 }
26513 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26514 {
26515 PyThreadState* __tstate = wxPyBeginAllowThreads();
26516 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
26517 wxPyEndAllowThreads(__tstate);
26518 if (PyErr_Occurred()) SWIG_fail;
26519 }
26520 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26521 return resultobj;
26522 fail:
26523 return NULL;
26524 }
26525
26526
26527 SWIGINTERN PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
26528 int argc;
26529 PyObject *argv[3];
26530
26531 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___sub__",0,2,argv))) SWIG_fail;
26532 --argc;
26533 if (argc == 2) {
26534 int _v = 0;
26535 {
26536 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDateTime, 0);
26537 _v = SWIG_CheckState(res);
26538 }
26539 if (!_v) goto check_1;
26540 return _wrap_DateTime___sub____SWIG_0(self, argc, argv);
26541 }
26542 check_1:
26543
26544 if (argc == 2) {
26545 int _v = 0;
26546 {
26547 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
26548 _v = SWIG_CheckState(res);
26549 }
26550 if (!_v) goto check_2;
26551 return _wrap_DateTime___sub____SWIG_1(self, argc, argv);
26552 }
26553 check_2:
26554
26555 if (argc == 2) {
26556 return _wrap_DateTime___sub____SWIG_2(self, argc, argv);
26557 }
26558
26559 fail:
26560 Py_INCREF(Py_NotImplemented);
26561 return Py_NotImplemented;
26562 }
26563
26564
26565 SWIGINTERN PyObject *_wrap_DateTime___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26566 PyObject *resultobj = 0;
26567 wxDateTime *arg1 = (wxDateTime *) 0 ;
26568 wxDateTime *arg2 = (wxDateTime *) 0 ;
26569 bool result;
26570 void *argp1 = 0 ;
26571 int res1 = 0 ;
26572 void *argp2 = 0 ;
26573 int res2 = 0 ;
26574 PyObject * obj0 = 0 ;
26575 PyObject * obj1 = 0 ;
26576 char * kwnames[] = {
26577 (char *) "self",(char *) "other", NULL
26578 };
26579
26580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
26581 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26582 if (!SWIG_IsOK(res1)) {
26583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___lt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26584 }
26585 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26586 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26587 if (!SWIG_IsOK(res2)) {
26588 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___lt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26589 }
26590 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26591 {
26592 PyThreadState* __tstate = wxPyBeginAllowThreads();
26593 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
26594 wxPyEndAllowThreads(__tstate);
26595 if (PyErr_Occurred()) SWIG_fail;
26596 }
26597 {
26598 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26599 }
26600 return resultobj;
26601 fail:
26602 return NULL;
26603 }
26604
26605
26606 SWIGINTERN PyObject *_wrap_DateTime___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26607 PyObject *resultobj = 0;
26608 wxDateTime *arg1 = (wxDateTime *) 0 ;
26609 wxDateTime *arg2 = (wxDateTime *) 0 ;
26610 bool result;
26611 void *argp1 = 0 ;
26612 int res1 = 0 ;
26613 void *argp2 = 0 ;
26614 int res2 = 0 ;
26615 PyObject * obj0 = 0 ;
26616 PyObject * obj1 = 0 ;
26617 char * kwnames[] = {
26618 (char *) "self",(char *) "other", NULL
26619 };
26620
26621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) SWIG_fail;
26622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26623 if (!SWIG_IsOK(res1)) {
26624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___le__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26625 }
26626 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26627 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26628 if (!SWIG_IsOK(res2)) {
26629 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___le__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26630 }
26631 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26632 {
26633 PyThreadState* __tstate = wxPyBeginAllowThreads();
26634 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
26635 wxPyEndAllowThreads(__tstate);
26636 if (PyErr_Occurred()) SWIG_fail;
26637 }
26638 {
26639 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26640 }
26641 return resultobj;
26642 fail:
26643 return NULL;
26644 }
26645
26646
26647 SWIGINTERN PyObject *_wrap_DateTime___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26648 PyObject *resultobj = 0;
26649 wxDateTime *arg1 = (wxDateTime *) 0 ;
26650 wxDateTime *arg2 = (wxDateTime *) 0 ;
26651 bool result;
26652 void *argp1 = 0 ;
26653 int res1 = 0 ;
26654 void *argp2 = 0 ;
26655 int res2 = 0 ;
26656 PyObject * obj0 = 0 ;
26657 PyObject * obj1 = 0 ;
26658 char * kwnames[] = {
26659 (char *) "self",(char *) "other", NULL
26660 };
26661
26662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
26663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26664 if (!SWIG_IsOK(res1)) {
26665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___gt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26666 }
26667 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26668 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26669 if (!SWIG_IsOK(res2)) {
26670 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___gt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26671 }
26672 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26673 {
26674 PyThreadState* __tstate = wxPyBeginAllowThreads();
26675 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
26676 wxPyEndAllowThreads(__tstate);
26677 if (PyErr_Occurred()) SWIG_fail;
26678 }
26679 {
26680 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26681 }
26682 return resultobj;
26683 fail:
26684 return NULL;
26685 }
26686
26687
26688 SWIGINTERN PyObject *_wrap_DateTime___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26689 PyObject *resultobj = 0;
26690 wxDateTime *arg1 = (wxDateTime *) 0 ;
26691 wxDateTime *arg2 = (wxDateTime *) 0 ;
26692 bool result;
26693 void *argp1 = 0 ;
26694 int res1 = 0 ;
26695 void *argp2 = 0 ;
26696 int res2 = 0 ;
26697 PyObject * obj0 = 0 ;
26698 PyObject * obj1 = 0 ;
26699 char * kwnames[] = {
26700 (char *) "self",(char *) "other", NULL
26701 };
26702
26703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
26704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26705 if (!SWIG_IsOK(res1)) {
26706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ge__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26707 }
26708 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26709 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26710 if (!SWIG_IsOK(res2)) {
26711 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ge__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26712 }
26713 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26714 {
26715 PyThreadState* __tstate = wxPyBeginAllowThreads();
26716 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
26717 wxPyEndAllowThreads(__tstate);
26718 if (PyErr_Occurred()) SWIG_fail;
26719 }
26720 {
26721 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26722 }
26723 return resultobj;
26724 fail:
26725 return NULL;
26726 }
26727
26728
26729 SWIGINTERN PyObject *_wrap_DateTime___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26730 PyObject *resultobj = 0;
26731 wxDateTime *arg1 = (wxDateTime *) 0 ;
26732 wxDateTime *arg2 = (wxDateTime *) 0 ;
26733 bool result;
26734 void *argp1 = 0 ;
26735 int res1 = 0 ;
26736 void *argp2 = 0 ;
26737 int res2 = 0 ;
26738 PyObject * obj0 = 0 ;
26739 PyObject * obj1 = 0 ;
26740 char * kwnames[] = {
26741 (char *) "self",(char *) "other", NULL
26742 };
26743
26744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
26745 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26746 if (!SWIG_IsOK(res1)) {
26747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___eq__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26748 }
26749 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26750 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26751 if (!SWIG_IsOK(res2)) {
26752 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___eq__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26753 }
26754 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26755 {
26756 PyThreadState* __tstate = wxPyBeginAllowThreads();
26757 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
26758 wxPyEndAllowThreads(__tstate);
26759 if (PyErr_Occurred()) SWIG_fail;
26760 }
26761 {
26762 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26763 }
26764 return resultobj;
26765 fail:
26766 return NULL;
26767 }
26768
26769
26770 SWIGINTERN PyObject *_wrap_DateTime___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26771 PyObject *resultobj = 0;
26772 wxDateTime *arg1 = (wxDateTime *) 0 ;
26773 wxDateTime *arg2 = (wxDateTime *) 0 ;
26774 bool result;
26775 void *argp1 = 0 ;
26776 int res1 = 0 ;
26777 void *argp2 = 0 ;
26778 int res2 = 0 ;
26779 PyObject * obj0 = 0 ;
26780 PyObject * obj1 = 0 ;
26781 char * kwnames[] = {
26782 (char *) "self",(char *) "other", NULL
26783 };
26784
26785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
26786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26787 if (!SWIG_IsOK(res1)) {
26788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ne__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26789 }
26790 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26791 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26792 if (!SWIG_IsOK(res2)) {
26793 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ne__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26794 }
26795 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26796 {
26797 PyThreadState* __tstate = wxPyBeginAllowThreads();
26798 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
26799 wxPyEndAllowThreads(__tstate);
26800 if (PyErr_Occurred()) SWIG_fail;
26801 }
26802 {
26803 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26804 }
26805 return resultobj;
26806 fail:
26807 return NULL;
26808 }
26809
26810
26811 SWIGINTERN PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26812 PyObject *resultobj = 0;
26813 wxDateTime *arg1 = (wxDateTime *) 0 ;
26814 wxString *arg2 = 0 ;
26815 int result;
26816 void *argp1 = 0 ;
26817 int res1 = 0 ;
26818 bool temp2 = false ;
26819 PyObject * obj0 = 0 ;
26820 PyObject * obj1 = 0 ;
26821 char * kwnames[] = {
26822 (char *) "self",(char *) "date", NULL
26823 };
26824
26825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) SWIG_fail;
26826 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26827 if (!SWIG_IsOK(res1)) {
26828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseRfc822Date" "', expected argument " "1"" of type '" "wxDateTime *""'");
26829 }
26830 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26831 {
26832 arg2 = wxString_in_helper(obj1);
26833 if (arg2 == NULL) SWIG_fail;
26834 temp2 = true;
26835 }
26836 {
26837 PyThreadState* __tstate = wxPyBeginAllowThreads();
26838 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
26839 wxPyEndAllowThreads(__tstate);
26840 if (PyErr_Occurred()) SWIG_fail;
26841 }
26842 resultobj = SWIG_From_int(static_cast< int >(result));
26843 {
26844 if (temp2)
26845 delete arg2;
26846 }
26847 return resultobj;
26848 fail:
26849 {
26850 if (temp2)
26851 delete arg2;
26852 }
26853 return NULL;
26854 }
26855
26856
26857 SWIGINTERN PyObject *_wrap_DateTime_ParseFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26858 PyObject *resultobj = 0;
26859 wxDateTime *arg1 = (wxDateTime *) 0 ;
26860 wxString *arg2 = 0 ;
26861 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
26862 wxString *arg3 = (wxString *) &arg3_defvalue ;
26863 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
26864 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
26865 int result;
26866 void *argp1 = 0 ;
26867 int res1 = 0 ;
26868 bool temp2 = false ;
26869 bool temp3 = false ;
26870 void *argp4 = 0 ;
26871 int res4 = 0 ;
26872 PyObject * obj0 = 0 ;
26873 PyObject * obj1 = 0 ;
26874 PyObject * obj2 = 0 ;
26875 PyObject * obj3 = 0 ;
26876 char * kwnames[] = {
26877 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
26878 };
26879
26880 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
26881 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26882 if (!SWIG_IsOK(res1)) {
26883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseFormat" "', expected argument " "1"" of type '" "wxDateTime *""'");
26884 }
26885 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26886 {
26887 arg2 = wxString_in_helper(obj1);
26888 if (arg2 == NULL) SWIG_fail;
26889 temp2 = true;
26890 }
26891 if (obj2) {
26892 {
26893 arg3 = wxString_in_helper(obj2);
26894 if (arg3 == NULL) SWIG_fail;
26895 temp3 = true;
26896 }
26897 }
26898 if (obj3) {
26899 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDateTime, 0 | 0);
26900 if (!SWIG_IsOK(res4)) {
26901 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
26902 }
26903 if (!argp4) {
26904 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
26905 }
26906 arg4 = reinterpret_cast< wxDateTime * >(argp4);
26907 }
26908 {
26909 PyThreadState* __tstate = wxPyBeginAllowThreads();
26910 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
26911 wxPyEndAllowThreads(__tstate);
26912 if (PyErr_Occurred()) SWIG_fail;
26913 }
26914 resultobj = SWIG_From_int(static_cast< int >(result));
26915 {
26916 if (temp2)
26917 delete arg2;
26918 }
26919 {
26920 if (temp3)
26921 delete arg3;
26922 }
26923 return resultobj;
26924 fail:
26925 {
26926 if (temp2)
26927 delete arg2;
26928 }
26929 {
26930 if (temp3)
26931 delete arg3;
26932 }
26933 return NULL;
26934 }
26935
26936
26937 SWIGINTERN PyObject *_wrap_DateTime_ParseDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26938 PyObject *resultobj = 0;
26939 wxDateTime *arg1 = (wxDateTime *) 0 ;
26940 wxString *arg2 = 0 ;
26941 int result;
26942 void *argp1 = 0 ;
26943 int res1 = 0 ;
26944 bool temp2 = false ;
26945 PyObject * obj0 = 0 ;
26946 PyObject * obj1 = 0 ;
26947 char * kwnames[] = {
26948 (char *) "self",(char *) "datetime", NULL
26949 };
26950
26951 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) SWIG_fail;
26952 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26953 if (!SWIG_IsOK(res1)) {
26954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
26955 }
26956 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26957 {
26958 arg2 = wxString_in_helper(obj1);
26959 if (arg2 == NULL) SWIG_fail;
26960 temp2 = true;
26961 }
26962 {
26963 PyThreadState* __tstate = wxPyBeginAllowThreads();
26964 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
26965 wxPyEndAllowThreads(__tstate);
26966 if (PyErr_Occurred()) SWIG_fail;
26967 }
26968 resultobj = SWIG_From_int(static_cast< int >(result));
26969 {
26970 if (temp2)
26971 delete arg2;
26972 }
26973 return resultobj;
26974 fail:
26975 {
26976 if (temp2)
26977 delete arg2;
26978 }
26979 return NULL;
26980 }
26981
26982
26983 SWIGINTERN PyObject *_wrap_DateTime_ParseDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26984 PyObject *resultobj = 0;
26985 wxDateTime *arg1 = (wxDateTime *) 0 ;
26986 wxString *arg2 = 0 ;
26987 int result;
26988 void *argp1 = 0 ;
26989 int res1 = 0 ;
26990 bool temp2 = false ;
26991 PyObject * obj0 = 0 ;
26992 PyObject * obj1 = 0 ;
26993 char * kwnames[] = {
26994 (char *) "self",(char *) "date", NULL
26995 };
26996
26997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) SWIG_fail;
26998 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26999 if (!SWIG_IsOK(res1)) {
27000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDate" "', expected argument " "1"" of type '" "wxDateTime *""'");
27001 }
27002 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27003 {
27004 arg2 = wxString_in_helper(obj1);
27005 if (arg2 == NULL) SWIG_fail;
27006 temp2 = true;
27007 }
27008 {
27009 PyThreadState* __tstate = wxPyBeginAllowThreads();
27010 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
27011 wxPyEndAllowThreads(__tstate);
27012 if (PyErr_Occurred()) SWIG_fail;
27013 }
27014 resultobj = SWIG_From_int(static_cast< int >(result));
27015 {
27016 if (temp2)
27017 delete arg2;
27018 }
27019 return resultobj;
27020 fail:
27021 {
27022 if (temp2)
27023 delete arg2;
27024 }
27025 return NULL;
27026 }
27027
27028
27029 SWIGINTERN PyObject *_wrap_DateTime_ParseTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27030 PyObject *resultobj = 0;
27031 wxDateTime *arg1 = (wxDateTime *) 0 ;
27032 wxString *arg2 = 0 ;
27033 int result;
27034 void *argp1 = 0 ;
27035 int res1 = 0 ;
27036 bool temp2 = false ;
27037 PyObject * obj0 = 0 ;
27038 PyObject * obj1 = 0 ;
27039 char * kwnames[] = {
27040 (char *) "self",(char *) "time", NULL
27041 };
27042
27043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) SWIG_fail;
27044 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27045 if (!SWIG_IsOK(res1)) {
27046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
27047 }
27048 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27049 {
27050 arg2 = wxString_in_helper(obj1);
27051 if (arg2 == NULL) SWIG_fail;
27052 temp2 = true;
27053 }
27054 {
27055 PyThreadState* __tstate = wxPyBeginAllowThreads();
27056 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
27057 wxPyEndAllowThreads(__tstate);
27058 if (PyErr_Occurred()) SWIG_fail;
27059 }
27060 resultobj = SWIG_From_int(static_cast< int >(result));
27061 {
27062 if (temp2)
27063 delete arg2;
27064 }
27065 return resultobj;
27066 fail:
27067 {
27068 if (temp2)
27069 delete arg2;
27070 }
27071 return NULL;
27072 }
27073
27074
27075 SWIGINTERN PyObject *_wrap_DateTime_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27076 PyObject *resultobj = 0;
27077 wxDateTime *arg1 = (wxDateTime *) 0 ;
27078 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
27079 wxString *arg2 = (wxString *) &arg2_defvalue ;
27080 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
27081 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
27082 wxString result;
27083 void *argp1 = 0 ;
27084 int res1 = 0 ;
27085 bool temp2 = false ;
27086 bool temp3 = false ;
27087 PyObject * obj0 = 0 ;
27088 PyObject * obj1 = 0 ;
27089 PyObject * obj2 = 0 ;
27090 char * kwnames[] = {
27091 (char *) "self",(char *) "format",(char *) "tz", NULL
27092 };
27093
27094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27095 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27096 if (!SWIG_IsOK(res1)) {
27097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Format" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27098 }
27099 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27100 if (obj1) {
27101 {
27102 arg2 = wxString_in_helper(obj1);
27103 if (arg2 == NULL) SWIG_fail;
27104 temp2 = true;
27105 }
27106 }
27107 if (obj2) {
27108 {
27109 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
27110 temp3 = true;
27111 }
27112 }
27113 {
27114 PyThreadState* __tstate = wxPyBeginAllowThreads();
27115 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
27116 wxPyEndAllowThreads(__tstate);
27117 if (PyErr_Occurred()) SWIG_fail;
27118 }
27119 {
27120 #if wxUSE_UNICODE
27121 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27122 #else
27123 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27124 #endif
27125 }
27126 {
27127 if (temp2)
27128 delete arg2;
27129 }
27130 {
27131 if (temp3) delete arg3;
27132 }
27133 return resultobj;
27134 fail:
27135 {
27136 if (temp2)
27137 delete arg2;
27138 }
27139 {
27140 if (temp3) delete arg3;
27141 }
27142 return NULL;
27143 }
27144
27145
27146 SWIGINTERN PyObject *_wrap_DateTime_FormatDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27147 PyObject *resultobj = 0;
27148 wxDateTime *arg1 = (wxDateTime *) 0 ;
27149 wxString result;
27150 void *argp1 = 0 ;
27151 int res1 = 0 ;
27152 PyObject *swig_obj[1] ;
27153
27154 if (!args) SWIG_fail;
27155 swig_obj[0] = args;
27156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27157 if (!SWIG_IsOK(res1)) {
27158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27159 }
27160 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27161 {
27162 PyThreadState* __tstate = wxPyBeginAllowThreads();
27163 result = ((wxDateTime const *)arg1)->FormatDate();
27164 wxPyEndAllowThreads(__tstate);
27165 if (PyErr_Occurred()) SWIG_fail;
27166 }
27167 {
27168 #if wxUSE_UNICODE
27169 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27170 #else
27171 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27172 #endif
27173 }
27174 return resultobj;
27175 fail:
27176 return NULL;
27177 }
27178
27179
27180 SWIGINTERN PyObject *_wrap_DateTime_FormatTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27181 PyObject *resultobj = 0;
27182 wxDateTime *arg1 = (wxDateTime *) 0 ;
27183 wxString result;
27184 void *argp1 = 0 ;
27185 int res1 = 0 ;
27186 PyObject *swig_obj[1] ;
27187
27188 if (!args) SWIG_fail;
27189 swig_obj[0] = args;
27190 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27191 if (!SWIG_IsOK(res1)) {
27192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27193 }
27194 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27195 {
27196 PyThreadState* __tstate = wxPyBeginAllowThreads();
27197 result = ((wxDateTime const *)arg1)->FormatTime();
27198 wxPyEndAllowThreads(__tstate);
27199 if (PyErr_Occurred()) SWIG_fail;
27200 }
27201 {
27202 #if wxUSE_UNICODE
27203 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27204 #else
27205 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27206 #endif
27207 }
27208 return resultobj;
27209 fail:
27210 return NULL;
27211 }
27212
27213
27214 SWIGINTERN PyObject *_wrap_DateTime_FormatISODate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27215 PyObject *resultobj = 0;
27216 wxDateTime *arg1 = (wxDateTime *) 0 ;
27217 wxString result;
27218 void *argp1 = 0 ;
27219 int res1 = 0 ;
27220 PyObject *swig_obj[1] ;
27221
27222 if (!args) SWIG_fail;
27223 swig_obj[0] = args;
27224 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27225 if (!SWIG_IsOK(res1)) {
27226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISODate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27227 }
27228 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27229 {
27230 PyThreadState* __tstate = wxPyBeginAllowThreads();
27231 result = ((wxDateTime const *)arg1)->FormatISODate();
27232 wxPyEndAllowThreads(__tstate);
27233 if (PyErr_Occurred()) SWIG_fail;
27234 }
27235 {
27236 #if wxUSE_UNICODE
27237 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27238 #else
27239 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27240 #endif
27241 }
27242 return resultobj;
27243 fail:
27244 return NULL;
27245 }
27246
27247
27248 SWIGINTERN PyObject *_wrap_DateTime_FormatISOTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27249 PyObject *resultobj = 0;
27250 wxDateTime *arg1 = (wxDateTime *) 0 ;
27251 wxString result;
27252 void *argp1 = 0 ;
27253 int res1 = 0 ;
27254 PyObject *swig_obj[1] ;
27255
27256 if (!args) SWIG_fail;
27257 swig_obj[0] = args;
27258 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27259 if (!SWIG_IsOK(res1)) {
27260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISOTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27261 }
27262 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27263 {
27264 PyThreadState* __tstate = wxPyBeginAllowThreads();
27265 result = ((wxDateTime const *)arg1)->FormatISOTime();
27266 wxPyEndAllowThreads(__tstate);
27267 if (PyErr_Occurred()) SWIG_fail;
27268 }
27269 {
27270 #if wxUSE_UNICODE
27271 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27272 #else
27273 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27274 #endif
27275 }
27276 return resultobj;
27277 fail:
27278 return NULL;
27279 }
27280
27281
27282 SWIGINTERN PyObject *DateTime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27283 PyObject *obj;
27284 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27285 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateTime, SWIG_NewClientData(obj));
27286 return SWIG_Py_Void();
27287 }
27288
27289 SWIGINTERN PyObject *DateTime_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27290 return SWIG_Python_InitShadowInstance(args);
27291 }
27292
27293 SWIGINTERN PyObject *_wrap_TimeSpan_Seconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27294 PyObject *resultobj = 0;
27295 long arg1 ;
27296 wxTimeSpan result;
27297 long val1 ;
27298 int ecode1 = 0 ;
27299 PyObject * obj0 = 0 ;
27300 char * kwnames[] = {
27301 (char *) "sec", NULL
27302 };
27303
27304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) SWIG_fail;
27305 ecode1 = SWIG_AsVal_long(obj0, &val1);
27306 if (!SWIG_IsOK(ecode1)) {
27307 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Seconds" "', expected argument " "1"" of type '" "long""'");
27308 }
27309 arg1 = static_cast< long >(val1);
27310 {
27311 PyThreadState* __tstate = wxPyBeginAllowThreads();
27312 result = wxTimeSpan::Seconds(arg1);
27313 wxPyEndAllowThreads(__tstate);
27314 if (PyErr_Occurred()) SWIG_fail;
27315 }
27316 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27317 return resultobj;
27318 fail:
27319 return NULL;
27320 }
27321
27322
27323 SWIGINTERN PyObject *_wrap_TimeSpan_Second(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27324 PyObject *resultobj = 0;
27325 wxTimeSpan result;
27326
27327 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Second",0,0,0)) SWIG_fail;
27328 {
27329 PyThreadState* __tstate = wxPyBeginAllowThreads();
27330 result = wxTimeSpan::Second();
27331 wxPyEndAllowThreads(__tstate);
27332 if (PyErr_Occurred()) SWIG_fail;
27333 }
27334 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27335 return resultobj;
27336 fail:
27337 return NULL;
27338 }
27339
27340
27341 SWIGINTERN PyObject *_wrap_TimeSpan_Minutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27342 PyObject *resultobj = 0;
27343 long arg1 ;
27344 wxTimeSpan result;
27345 long val1 ;
27346 int ecode1 = 0 ;
27347 PyObject * obj0 = 0 ;
27348 char * kwnames[] = {
27349 (char *) "min", NULL
27350 };
27351
27352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) SWIG_fail;
27353 ecode1 = SWIG_AsVal_long(obj0, &val1);
27354 if (!SWIG_IsOK(ecode1)) {
27355 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Minutes" "', expected argument " "1"" of type '" "long""'");
27356 }
27357 arg1 = static_cast< long >(val1);
27358 {
27359 PyThreadState* __tstate = wxPyBeginAllowThreads();
27360 result = wxTimeSpan::Minutes(arg1);
27361 wxPyEndAllowThreads(__tstate);
27362 if (PyErr_Occurred()) SWIG_fail;
27363 }
27364 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27365 return resultobj;
27366 fail:
27367 return NULL;
27368 }
27369
27370
27371 SWIGINTERN PyObject *_wrap_TimeSpan_Minute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27372 PyObject *resultobj = 0;
27373 wxTimeSpan result;
27374
27375 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Minute",0,0,0)) SWIG_fail;
27376 {
27377 PyThreadState* __tstate = wxPyBeginAllowThreads();
27378 result = wxTimeSpan::Minute();
27379 wxPyEndAllowThreads(__tstate);
27380 if (PyErr_Occurred()) SWIG_fail;
27381 }
27382 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27383 return resultobj;
27384 fail:
27385 return NULL;
27386 }
27387
27388
27389 SWIGINTERN PyObject *_wrap_TimeSpan_Hours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27390 PyObject *resultobj = 0;
27391 long arg1 ;
27392 wxTimeSpan result;
27393 long val1 ;
27394 int ecode1 = 0 ;
27395 PyObject * obj0 = 0 ;
27396 char * kwnames[] = {
27397 (char *) "hours", NULL
27398 };
27399
27400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) SWIG_fail;
27401 ecode1 = SWIG_AsVal_long(obj0, &val1);
27402 if (!SWIG_IsOK(ecode1)) {
27403 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Hours" "', expected argument " "1"" of type '" "long""'");
27404 }
27405 arg1 = static_cast< long >(val1);
27406 {
27407 PyThreadState* __tstate = wxPyBeginAllowThreads();
27408 result = wxTimeSpan::Hours(arg1);
27409 wxPyEndAllowThreads(__tstate);
27410 if (PyErr_Occurred()) SWIG_fail;
27411 }
27412 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27413 return resultobj;
27414 fail:
27415 return NULL;
27416 }
27417
27418
27419 SWIGINTERN PyObject *_wrap_TimeSpan_Hour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27420 PyObject *resultobj = 0;
27421 wxTimeSpan result;
27422
27423 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Hour",0,0,0)) SWIG_fail;
27424 {
27425 PyThreadState* __tstate = wxPyBeginAllowThreads();
27426 result = wxTimeSpan::Hour();
27427 wxPyEndAllowThreads(__tstate);
27428 if (PyErr_Occurred()) SWIG_fail;
27429 }
27430 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27431 return resultobj;
27432 fail:
27433 return NULL;
27434 }
27435
27436
27437 SWIGINTERN PyObject *_wrap_TimeSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27438 PyObject *resultobj = 0;
27439 long arg1 ;
27440 wxTimeSpan result;
27441 long val1 ;
27442 int ecode1 = 0 ;
27443 PyObject * obj0 = 0 ;
27444 char * kwnames[] = {
27445 (char *) "days", NULL
27446 };
27447
27448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) SWIG_fail;
27449 ecode1 = SWIG_AsVal_long(obj0, &val1);
27450 if (!SWIG_IsOK(ecode1)) {
27451 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Days" "', expected argument " "1"" of type '" "long""'");
27452 }
27453 arg1 = static_cast< long >(val1);
27454 {
27455 PyThreadState* __tstate = wxPyBeginAllowThreads();
27456 result = wxTimeSpan::Days(arg1);
27457 wxPyEndAllowThreads(__tstate);
27458 if (PyErr_Occurred()) SWIG_fail;
27459 }
27460 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27461 return resultobj;
27462 fail:
27463 return NULL;
27464 }
27465
27466
27467 SWIGINTERN PyObject *_wrap_TimeSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27468 PyObject *resultobj = 0;
27469 wxTimeSpan result;
27470
27471 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Day",0,0,0)) SWIG_fail;
27472 {
27473 PyThreadState* __tstate = wxPyBeginAllowThreads();
27474 result = wxTimeSpan::Day();
27475 wxPyEndAllowThreads(__tstate);
27476 if (PyErr_Occurred()) SWIG_fail;
27477 }
27478 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27479 return resultobj;
27480 fail:
27481 return NULL;
27482 }
27483
27484
27485 SWIGINTERN PyObject *_wrap_TimeSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27486 PyObject *resultobj = 0;
27487 long arg1 ;
27488 wxTimeSpan result;
27489 long val1 ;
27490 int ecode1 = 0 ;
27491 PyObject * obj0 = 0 ;
27492 char * kwnames[] = {
27493 (char *) "days", NULL
27494 };
27495
27496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) SWIG_fail;
27497 ecode1 = SWIG_AsVal_long(obj0, &val1);
27498 if (!SWIG_IsOK(ecode1)) {
27499 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Weeks" "', expected argument " "1"" of type '" "long""'");
27500 }
27501 arg1 = static_cast< long >(val1);
27502 {
27503 PyThreadState* __tstate = wxPyBeginAllowThreads();
27504 result = wxTimeSpan::Weeks(arg1);
27505 wxPyEndAllowThreads(__tstate);
27506 if (PyErr_Occurred()) SWIG_fail;
27507 }
27508 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27509 return resultobj;
27510 fail:
27511 return NULL;
27512 }
27513
27514
27515 SWIGINTERN PyObject *_wrap_TimeSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27516 PyObject *resultobj = 0;
27517 wxTimeSpan result;
27518
27519 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Week",0,0,0)) SWIG_fail;
27520 {
27521 PyThreadState* __tstate = wxPyBeginAllowThreads();
27522 result = wxTimeSpan::Week();
27523 wxPyEndAllowThreads(__tstate);
27524 if (PyErr_Occurred()) SWIG_fail;
27525 }
27526 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27527 return resultobj;
27528 fail:
27529 return NULL;
27530 }
27531
27532
27533 SWIGINTERN PyObject *_wrap_new_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27534 PyObject *resultobj = 0;
27535 long arg1 = (long) 0 ;
27536 long arg2 = (long) 0 ;
27537 long arg3 = (long) 0 ;
27538 long arg4 = (long) 0 ;
27539 wxTimeSpan *result = 0 ;
27540 long val1 ;
27541 int ecode1 = 0 ;
27542 long val2 ;
27543 int ecode2 = 0 ;
27544 long val3 ;
27545 int ecode3 = 0 ;
27546 long val4 ;
27547 int ecode4 = 0 ;
27548 PyObject * obj0 = 0 ;
27549 PyObject * obj1 = 0 ;
27550 PyObject * obj2 = 0 ;
27551 PyObject * obj3 = 0 ;
27552 char * kwnames[] = {
27553 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
27554 };
27555
27556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27557 if (obj0) {
27558 ecode1 = SWIG_AsVal_long(obj0, &val1);
27559 if (!SWIG_IsOK(ecode1)) {
27560 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimeSpan" "', expected argument " "1"" of type '" "long""'");
27561 }
27562 arg1 = static_cast< long >(val1);
27563 }
27564 if (obj1) {
27565 ecode2 = SWIG_AsVal_long(obj1, &val2);
27566 if (!SWIG_IsOK(ecode2)) {
27567 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimeSpan" "', expected argument " "2"" of type '" "long""'");
27568 }
27569 arg2 = static_cast< long >(val2);
27570 }
27571 if (obj2) {
27572 ecode3 = SWIG_AsVal_long(obj2, &val3);
27573 if (!SWIG_IsOK(ecode3)) {
27574 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimeSpan" "', expected argument " "3"" of type '" "long""'");
27575 }
27576 arg3 = static_cast< long >(val3);
27577 }
27578 if (obj3) {
27579 ecode4 = SWIG_AsVal_long(obj3, &val4);
27580 if (!SWIG_IsOK(ecode4)) {
27581 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TimeSpan" "', expected argument " "4"" of type '" "long""'");
27582 }
27583 arg4 = static_cast< long >(val4);
27584 }
27585 {
27586 PyThreadState* __tstate = wxPyBeginAllowThreads();
27587 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
27588 wxPyEndAllowThreads(__tstate);
27589 if (PyErr_Occurred()) SWIG_fail;
27590 }
27591 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_NEW | 0 );
27592 return resultobj;
27593 fail:
27594 return NULL;
27595 }
27596
27597
27598 SWIGINTERN PyObject *_wrap_delete_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27599 PyObject *resultobj = 0;
27600 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27601 void *argp1 = 0 ;
27602 int res1 = 0 ;
27603 PyObject *swig_obj[1] ;
27604
27605 if (!args) SWIG_fail;
27606 swig_obj[0] = args;
27607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
27608 if (!SWIG_IsOK(res1)) {
27609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimeSpan" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27610 }
27611 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27612 {
27613 PyThreadState* __tstate = wxPyBeginAllowThreads();
27614 delete arg1;
27615
27616 wxPyEndAllowThreads(__tstate);
27617 if (PyErr_Occurred()) SWIG_fail;
27618 }
27619 resultobj = SWIG_Py_Void();
27620 return resultobj;
27621 fail:
27622 return NULL;
27623 }
27624
27625
27626 SWIGINTERN PyObject *_wrap_TimeSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27627 PyObject *resultobj = 0;
27628 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27629 wxTimeSpan *arg2 = 0 ;
27630 wxTimeSpan *result = 0 ;
27631 void *argp1 = 0 ;
27632 int res1 = 0 ;
27633 void *argp2 = 0 ;
27634 int res2 = 0 ;
27635 PyObject * obj0 = 0 ;
27636 PyObject * obj1 = 0 ;
27637 char * kwnames[] = {
27638 (char *) "self",(char *) "diff", NULL
27639 };
27640
27641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
27642 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27643 if (!SWIG_IsOK(res1)) {
27644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Add" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27645 }
27646 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27647 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27648 if (!SWIG_IsOK(res2)) {
27649 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27650 }
27651 if (!argp2) {
27652 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27653 }
27654 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27655 {
27656 PyThreadState* __tstate = wxPyBeginAllowThreads();
27657 {
27658 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
27659 result = (wxTimeSpan *) &_result_ref;
27660 }
27661 wxPyEndAllowThreads(__tstate);
27662 if (PyErr_Occurred()) SWIG_fail;
27663 }
27664 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27665 return resultobj;
27666 fail:
27667 return NULL;
27668 }
27669
27670
27671 SWIGINTERN PyObject *_wrap_TimeSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27672 PyObject *resultobj = 0;
27673 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27674 wxTimeSpan *arg2 = 0 ;
27675 wxTimeSpan *result = 0 ;
27676 void *argp1 = 0 ;
27677 int res1 = 0 ;
27678 void *argp2 = 0 ;
27679 int res2 = 0 ;
27680 PyObject * obj0 = 0 ;
27681 PyObject * obj1 = 0 ;
27682 char * kwnames[] = {
27683 (char *) "self",(char *) "diff", NULL
27684 };
27685
27686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
27687 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27688 if (!SWIG_IsOK(res1)) {
27689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Subtract" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27690 }
27691 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27692 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27693 if (!SWIG_IsOK(res2)) {
27694 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27695 }
27696 if (!argp2) {
27697 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27698 }
27699 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27700 {
27701 PyThreadState* __tstate = wxPyBeginAllowThreads();
27702 {
27703 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
27704 result = (wxTimeSpan *) &_result_ref;
27705 }
27706 wxPyEndAllowThreads(__tstate);
27707 if (PyErr_Occurred()) SWIG_fail;
27708 }
27709 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27710 return resultobj;
27711 fail:
27712 return NULL;
27713 }
27714
27715
27716 SWIGINTERN PyObject *_wrap_TimeSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27717 PyObject *resultobj = 0;
27718 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27719 int arg2 ;
27720 wxTimeSpan *result = 0 ;
27721 void *argp1 = 0 ;
27722 int res1 = 0 ;
27723 int val2 ;
27724 int ecode2 = 0 ;
27725 PyObject * obj0 = 0 ;
27726 PyObject * obj1 = 0 ;
27727 char * kwnames[] = {
27728 (char *) "self",(char *) "n", NULL
27729 };
27730
27731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
27732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27733 if (!SWIG_IsOK(res1)) {
27734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Multiply" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27735 }
27736 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27737 ecode2 = SWIG_AsVal_int(obj1, &val2);
27738 if (!SWIG_IsOK(ecode2)) {
27739 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
27740 }
27741 arg2 = static_cast< int >(val2);
27742 {
27743 PyThreadState* __tstate = wxPyBeginAllowThreads();
27744 {
27745 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
27746 result = (wxTimeSpan *) &_result_ref;
27747 }
27748 wxPyEndAllowThreads(__tstate);
27749 if (PyErr_Occurred()) SWIG_fail;
27750 }
27751 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27752 return resultobj;
27753 fail:
27754 return NULL;
27755 }
27756
27757
27758 SWIGINTERN PyObject *_wrap_TimeSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27759 PyObject *resultobj = 0;
27760 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27761 wxTimeSpan *result = 0 ;
27762 void *argp1 = 0 ;
27763 int res1 = 0 ;
27764 PyObject *swig_obj[1] ;
27765
27766 if (!args) SWIG_fail;
27767 swig_obj[0] = args;
27768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27769 if (!SWIG_IsOK(res1)) {
27770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Neg" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27771 }
27772 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27773 {
27774 PyThreadState* __tstate = wxPyBeginAllowThreads();
27775 {
27776 wxTimeSpan &_result_ref = (arg1)->Neg();
27777 result = (wxTimeSpan *) &_result_ref;
27778 }
27779 wxPyEndAllowThreads(__tstate);
27780 if (PyErr_Occurred()) SWIG_fail;
27781 }
27782 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27783 return resultobj;
27784 fail:
27785 return NULL;
27786 }
27787
27788
27789 SWIGINTERN PyObject *_wrap_TimeSpan_Abs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27790 PyObject *resultobj = 0;
27791 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27792 wxTimeSpan result;
27793 void *argp1 = 0 ;
27794 int res1 = 0 ;
27795 PyObject *swig_obj[1] ;
27796
27797 if (!args) SWIG_fail;
27798 swig_obj[0] = args;
27799 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27800 if (!SWIG_IsOK(res1)) {
27801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Abs" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
27802 }
27803 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27804 {
27805 PyThreadState* __tstate = wxPyBeginAllowThreads();
27806 result = ((wxTimeSpan const *)arg1)->Abs();
27807 wxPyEndAllowThreads(__tstate);
27808 if (PyErr_Occurred()) SWIG_fail;
27809 }
27810 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27811 return resultobj;
27812 fail:
27813 return NULL;
27814 }
27815
27816
27817 SWIGINTERN PyObject *_wrap_TimeSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27818 PyObject *resultobj = 0;
27819 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27820 wxTimeSpan *arg2 = 0 ;
27821 wxTimeSpan *result = 0 ;
27822 void *argp1 = 0 ;
27823 int res1 = 0 ;
27824 void *argp2 = 0 ;
27825 int res2 = 0 ;
27826 PyObject * obj0 = 0 ;
27827 PyObject * obj1 = 0 ;
27828 char * kwnames[] = {
27829 (char *) "self",(char *) "diff", NULL
27830 };
27831
27832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
27833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
27834 if (!SWIG_IsOK(res1)) {
27835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___iadd__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27836 }
27837 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27838 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27839 if (!SWIG_IsOK(res2)) {
27840 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27841 }
27842 if (!argp2) {
27843 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27844 }
27845 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27846 {
27847 PyThreadState* __tstate = wxPyBeginAllowThreads();
27848 {
27849 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
27850 result = (wxTimeSpan *) &_result_ref;
27851 }
27852 wxPyEndAllowThreads(__tstate);
27853 if (PyErr_Occurred()) SWIG_fail;
27854 }
27855 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27856 return resultobj;
27857 fail:
27858 return NULL;
27859 }
27860
27861
27862 SWIGINTERN PyObject *_wrap_TimeSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27863 PyObject *resultobj = 0;
27864 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27865 wxTimeSpan *arg2 = 0 ;
27866 wxTimeSpan *result = 0 ;
27867 void *argp1 = 0 ;
27868 int res1 = 0 ;
27869 void *argp2 = 0 ;
27870 int res2 = 0 ;
27871 PyObject * obj0 = 0 ;
27872 PyObject * obj1 = 0 ;
27873 char * kwnames[] = {
27874 (char *) "self",(char *) "diff", NULL
27875 };
27876
27877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
27878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
27879 if (!SWIG_IsOK(res1)) {
27880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___isub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27881 }
27882 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27883 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27884 if (!SWIG_IsOK(res2)) {
27885 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27886 }
27887 if (!argp2) {
27888 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27889 }
27890 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27891 {
27892 PyThreadState* __tstate = wxPyBeginAllowThreads();
27893 {
27894 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
27895 result = (wxTimeSpan *) &_result_ref;
27896 }
27897 wxPyEndAllowThreads(__tstate);
27898 if (PyErr_Occurred()) SWIG_fail;
27899 }
27900 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27901 return resultobj;
27902 fail:
27903 return NULL;
27904 }
27905
27906
27907 SWIGINTERN PyObject *_wrap_TimeSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27908 PyObject *resultobj = 0;
27909 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27910 int arg2 ;
27911 wxTimeSpan *result = 0 ;
27912 void *argp1 = 0 ;
27913 int res1 = 0 ;
27914 int val2 ;
27915 int ecode2 = 0 ;
27916 PyObject * obj0 = 0 ;
27917 PyObject * obj1 = 0 ;
27918 char * kwnames[] = {
27919 (char *) "self",(char *) "n", NULL
27920 };
27921
27922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
27923 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
27924 if (!SWIG_IsOK(res1)) {
27925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___imul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27926 }
27927 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27928 ecode2 = SWIG_AsVal_int(obj1, &val2);
27929 if (!SWIG_IsOK(ecode2)) {
27930 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___imul__" "', expected argument " "2"" of type '" "int""'");
27931 }
27932 arg2 = static_cast< int >(val2);
27933 {
27934 PyThreadState* __tstate = wxPyBeginAllowThreads();
27935 {
27936 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
27937 result = (wxTimeSpan *) &_result_ref;
27938 }
27939 wxPyEndAllowThreads(__tstate);
27940 if (PyErr_Occurred()) SWIG_fail;
27941 }
27942 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27943 return resultobj;
27944 fail:
27945 return NULL;
27946 }
27947
27948
27949 SWIGINTERN PyObject *_wrap_TimeSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27950 PyObject *resultobj = 0;
27951 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27952 wxTimeSpan *result = 0 ;
27953 void *argp1 = 0 ;
27954 int res1 = 0 ;
27955 PyObject *swig_obj[1] ;
27956
27957 if (!args) SWIG_fail;
27958 swig_obj[0] = args;
27959 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27960 if (!SWIG_IsOK(res1)) {
27961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___neg__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27962 }
27963 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27964 {
27965 PyThreadState* __tstate = wxPyBeginAllowThreads();
27966 {
27967 wxTimeSpan &_result_ref = (arg1)->operator -();
27968 result = (wxTimeSpan *) &_result_ref;
27969 }
27970 wxPyEndAllowThreads(__tstate);
27971 if (PyErr_Occurred()) SWIG_fail;
27972 }
27973 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27974 return resultobj;
27975 fail:
27976 return NULL;
27977 }
27978
27979
27980 SWIGINTERN PyObject *_wrap_TimeSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27981 PyObject *resultobj = 0;
27982 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27983 wxTimeSpan *arg2 = 0 ;
27984 wxTimeSpan result;
27985 void *argp1 = 0 ;
27986 int res1 = 0 ;
27987 void *argp2 = 0 ;
27988 int res2 = 0 ;
27989 PyObject * obj0 = 0 ;
27990 PyObject * obj1 = 0 ;
27991 char * kwnames[] = {
27992 (char *) "self",(char *) "other", NULL
27993 };
27994
27995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
27996 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27997 if (!SWIG_IsOK(res1)) {
27998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___add__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27999 }
28000 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28001 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28002 if (!SWIG_IsOK(res2)) {
28003 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28004 }
28005 if (!argp2) {
28006 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28007 }
28008 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28009 {
28010 PyThreadState* __tstate = wxPyBeginAllowThreads();
28011 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
28012 wxPyEndAllowThreads(__tstate);
28013 if (PyErr_Occurred()) SWIG_fail;
28014 }
28015 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28016 return resultobj;
28017 fail:
28018 return NULL;
28019 }
28020
28021
28022 SWIGINTERN PyObject *_wrap_TimeSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28023 PyObject *resultobj = 0;
28024 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28025 wxTimeSpan *arg2 = 0 ;
28026 wxTimeSpan result;
28027 void *argp1 = 0 ;
28028 int res1 = 0 ;
28029 void *argp2 = 0 ;
28030 int res2 = 0 ;
28031 PyObject * obj0 = 0 ;
28032 PyObject * obj1 = 0 ;
28033 char * kwnames[] = {
28034 (char *) "self",(char *) "other", NULL
28035 };
28036
28037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
28038 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28039 if (!SWIG_IsOK(res1)) {
28040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___sub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28041 }
28042 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28043 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28044 if (!SWIG_IsOK(res2)) {
28045 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28046 }
28047 if (!argp2) {
28048 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28049 }
28050 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28051 {
28052 PyThreadState* __tstate = wxPyBeginAllowThreads();
28053 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
28054 wxPyEndAllowThreads(__tstate);
28055 if (PyErr_Occurred()) SWIG_fail;
28056 }
28057 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28058 return resultobj;
28059 fail:
28060 return NULL;
28061 }
28062
28063
28064 SWIGINTERN PyObject *_wrap_TimeSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28065 PyObject *resultobj = 0;
28066 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28067 int arg2 ;
28068 wxTimeSpan result;
28069 void *argp1 = 0 ;
28070 int res1 = 0 ;
28071 int val2 ;
28072 int ecode2 = 0 ;
28073 PyObject * obj0 = 0 ;
28074 PyObject * obj1 = 0 ;
28075 char * kwnames[] = {
28076 (char *) "self",(char *) "n", NULL
28077 };
28078
28079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
28080 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28081 if (!SWIG_IsOK(res1)) {
28082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___mul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28083 }
28084 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28085 ecode2 = SWIG_AsVal_int(obj1, &val2);
28086 if (!SWIG_IsOK(ecode2)) {
28087 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___mul__" "', expected argument " "2"" of type '" "int""'");
28088 }
28089 arg2 = static_cast< int >(val2);
28090 {
28091 PyThreadState* __tstate = wxPyBeginAllowThreads();
28092 result = wxTimeSpan___mul__(arg1,arg2);
28093 wxPyEndAllowThreads(__tstate);
28094 if (PyErr_Occurred()) SWIG_fail;
28095 }
28096 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28097 return resultobj;
28098 fail:
28099 return NULL;
28100 }
28101
28102
28103 SWIGINTERN PyObject *_wrap_TimeSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28104 PyObject *resultobj = 0;
28105 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28106 int arg2 ;
28107 wxTimeSpan result;
28108 void *argp1 = 0 ;
28109 int res1 = 0 ;
28110 int val2 ;
28111 int ecode2 = 0 ;
28112 PyObject * obj0 = 0 ;
28113 PyObject * obj1 = 0 ;
28114 char * kwnames[] = {
28115 (char *) "self",(char *) "n", NULL
28116 };
28117
28118 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
28119 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28120 if (!SWIG_IsOK(res1)) {
28121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___rmul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28122 }
28123 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28124 ecode2 = SWIG_AsVal_int(obj1, &val2);
28125 if (!SWIG_IsOK(ecode2)) {
28126 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
28127 }
28128 arg2 = static_cast< int >(val2);
28129 {
28130 PyThreadState* __tstate = wxPyBeginAllowThreads();
28131 result = wxTimeSpan___rmul__(arg1,arg2);
28132 wxPyEndAllowThreads(__tstate);
28133 if (PyErr_Occurred()) SWIG_fail;
28134 }
28135 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28136 return resultobj;
28137 fail:
28138 return NULL;
28139 }
28140
28141
28142 SWIGINTERN PyObject *_wrap_TimeSpan___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28143 PyObject *resultobj = 0;
28144 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28145 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28146 bool result;
28147 void *argp1 = 0 ;
28148 int res1 = 0 ;
28149 void *argp2 = 0 ;
28150 int res2 = 0 ;
28151 PyObject * obj0 = 0 ;
28152 PyObject * obj1 = 0 ;
28153 char * kwnames[] = {
28154 (char *) "self",(char *) "other", NULL
28155 };
28156
28157 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
28158 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28159 if (!SWIG_IsOK(res1)) {
28160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___lt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28161 }
28162 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28163 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28164 if (!SWIG_IsOK(res2)) {
28165 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___lt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28166 }
28167 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28168 {
28169 PyThreadState* __tstate = wxPyBeginAllowThreads();
28170 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
28171 wxPyEndAllowThreads(__tstate);
28172 if (PyErr_Occurred()) SWIG_fail;
28173 }
28174 {
28175 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28176 }
28177 return resultobj;
28178 fail:
28179 return NULL;
28180 }
28181
28182
28183 SWIGINTERN PyObject *_wrap_TimeSpan___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28184 PyObject *resultobj = 0;
28185 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28186 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28187 bool result;
28188 void *argp1 = 0 ;
28189 int res1 = 0 ;
28190 void *argp2 = 0 ;
28191 int res2 = 0 ;
28192 PyObject * obj0 = 0 ;
28193 PyObject * obj1 = 0 ;
28194 char * kwnames[] = {
28195 (char *) "self",(char *) "other", NULL
28196 };
28197
28198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) SWIG_fail;
28199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28200 if (!SWIG_IsOK(res1)) {
28201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___le__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28202 }
28203 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28204 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28205 if (!SWIG_IsOK(res2)) {
28206 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___le__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28207 }
28208 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28209 {
28210 PyThreadState* __tstate = wxPyBeginAllowThreads();
28211 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
28212 wxPyEndAllowThreads(__tstate);
28213 if (PyErr_Occurred()) SWIG_fail;
28214 }
28215 {
28216 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28217 }
28218 return resultobj;
28219 fail:
28220 return NULL;
28221 }
28222
28223
28224 SWIGINTERN PyObject *_wrap_TimeSpan___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28225 PyObject *resultobj = 0;
28226 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28227 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28228 bool result;
28229 void *argp1 = 0 ;
28230 int res1 = 0 ;
28231 void *argp2 = 0 ;
28232 int res2 = 0 ;
28233 PyObject * obj0 = 0 ;
28234 PyObject * obj1 = 0 ;
28235 char * kwnames[] = {
28236 (char *) "self",(char *) "other", NULL
28237 };
28238
28239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
28240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28241 if (!SWIG_IsOK(res1)) {
28242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___gt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28243 }
28244 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28245 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28246 if (!SWIG_IsOK(res2)) {
28247 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___gt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28248 }
28249 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28250 {
28251 PyThreadState* __tstate = wxPyBeginAllowThreads();
28252 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
28253 wxPyEndAllowThreads(__tstate);
28254 if (PyErr_Occurred()) SWIG_fail;
28255 }
28256 {
28257 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28258 }
28259 return resultobj;
28260 fail:
28261 return NULL;
28262 }
28263
28264
28265 SWIGINTERN PyObject *_wrap_TimeSpan___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28266 PyObject *resultobj = 0;
28267 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28268 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28269 bool result;
28270 void *argp1 = 0 ;
28271 int res1 = 0 ;
28272 void *argp2 = 0 ;
28273 int res2 = 0 ;
28274 PyObject * obj0 = 0 ;
28275 PyObject * obj1 = 0 ;
28276 char * kwnames[] = {
28277 (char *) "self",(char *) "other", NULL
28278 };
28279
28280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
28281 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28282 if (!SWIG_IsOK(res1)) {
28283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ge__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28284 }
28285 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28286 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28287 if (!SWIG_IsOK(res2)) {
28288 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ge__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28289 }
28290 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28291 {
28292 PyThreadState* __tstate = wxPyBeginAllowThreads();
28293 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
28294 wxPyEndAllowThreads(__tstate);
28295 if (PyErr_Occurred()) SWIG_fail;
28296 }
28297 {
28298 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28299 }
28300 return resultobj;
28301 fail:
28302 return NULL;
28303 }
28304
28305
28306 SWIGINTERN PyObject *_wrap_TimeSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28307 PyObject *resultobj = 0;
28308 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28309 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28310 bool result;
28311 void *argp1 = 0 ;
28312 int res1 = 0 ;
28313 void *argp2 = 0 ;
28314 int res2 = 0 ;
28315 PyObject * obj0 = 0 ;
28316 PyObject * obj1 = 0 ;
28317 char * kwnames[] = {
28318 (char *) "self",(char *) "other", NULL
28319 };
28320
28321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
28322 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28323 if (!SWIG_IsOK(res1)) {
28324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___eq__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28325 }
28326 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28327 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28328 if (!SWIG_IsOK(res2)) {
28329 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___eq__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28330 }
28331 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28332 {
28333 PyThreadState* __tstate = wxPyBeginAllowThreads();
28334 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
28335 wxPyEndAllowThreads(__tstate);
28336 if (PyErr_Occurred()) SWIG_fail;
28337 }
28338 {
28339 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28340 }
28341 return resultobj;
28342 fail:
28343 return NULL;
28344 }
28345
28346
28347 SWIGINTERN PyObject *_wrap_TimeSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28348 PyObject *resultobj = 0;
28349 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28350 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28351 bool result;
28352 void *argp1 = 0 ;
28353 int res1 = 0 ;
28354 void *argp2 = 0 ;
28355 int res2 = 0 ;
28356 PyObject * obj0 = 0 ;
28357 PyObject * obj1 = 0 ;
28358 char * kwnames[] = {
28359 (char *) "self",(char *) "other", NULL
28360 };
28361
28362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
28363 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28364 if (!SWIG_IsOK(res1)) {
28365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ne__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28366 }
28367 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28368 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28369 if (!SWIG_IsOK(res2)) {
28370 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ne__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28371 }
28372 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28373 {
28374 PyThreadState* __tstate = wxPyBeginAllowThreads();
28375 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
28376 wxPyEndAllowThreads(__tstate);
28377 if (PyErr_Occurred()) SWIG_fail;
28378 }
28379 {
28380 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28381 }
28382 return resultobj;
28383 fail:
28384 return NULL;
28385 }
28386
28387
28388 SWIGINTERN PyObject *_wrap_TimeSpan_IsNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28389 PyObject *resultobj = 0;
28390 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28391 bool result;
28392 void *argp1 = 0 ;
28393 int res1 = 0 ;
28394 PyObject *swig_obj[1] ;
28395
28396 if (!args) SWIG_fail;
28397 swig_obj[0] = args;
28398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28399 if (!SWIG_IsOK(res1)) {
28400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNull" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28401 }
28402 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28403 {
28404 PyThreadState* __tstate = wxPyBeginAllowThreads();
28405 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
28406 wxPyEndAllowThreads(__tstate);
28407 if (PyErr_Occurred()) SWIG_fail;
28408 }
28409 {
28410 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28411 }
28412 return resultobj;
28413 fail:
28414 return NULL;
28415 }
28416
28417
28418 SWIGINTERN PyObject *_wrap_TimeSpan_IsPositive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28419 PyObject *resultobj = 0;
28420 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28421 bool result;
28422 void *argp1 = 0 ;
28423 int res1 = 0 ;
28424 PyObject *swig_obj[1] ;
28425
28426 if (!args) SWIG_fail;
28427 swig_obj[0] = args;
28428 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28429 if (!SWIG_IsOK(res1)) {
28430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsPositive" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28431 }
28432 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28433 {
28434 PyThreadState* __tstate = wxPyBeginAllowThreads();
28435 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
28436 wxPyEndAllowThreads(__tstate);
28437 if (PyErr_Occurred()) SWIG_fail;
28438 }
28439 {
28440 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28441 }
28442 return resultobj;
28443 fail:
28444 return NULL;
28445 }
28446
28447
28448 SWIGINTERN PyObject *_wrap_TimeSpan_IsNegative(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28449 PyObject *resultobj = 0;
28450 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28451 bool result;
28452 void *argp1 = 0 ;
28453 int res1 = 0 ;
28454 PyObject *swig_obj[1] ;
28455
28456 if (!args) SWIG_fail;
28457 swig_obj[0] = args;
28458 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28459 if (!SWIG_IsOK(res1)) {
28460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNegative" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28461 }
28462 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28463 {
28464 PyThreadState* __tstate = wxPyBeginAllowThreads();
28465 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
28466 wxPyEndAllowThreads(__tstate);
28467 if (PyErr_Occurred()) SWIG_fail;
28468 }
28469 {
28470 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28471 }
28472 return resultobj;
28473 fail:
28474 return NULL;
28475 }
28476
28477
28478 SWIGINTERN PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28479 PyObject *resultobj = 0;
28480 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28481 wxTimeSpan *arg2 = 0 ;
28482 bool result;
28483 void *argp1 = 0 ;
28484 int res1 = 0 ;
28485 void *argp2 = 0 ;
28486 int res2 = 0 ;
28487 PyObject * obj0 = 0 ;
28488 PyObject * obj1 = 0 ;
28489 char * kwnames[] = {
28490 (char *) "self",(char *) "ts", NULL
28491 };
28492
28493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
28494 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28495 if (!SWIG_IsOK(res1)) {
28496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28497 }
28498 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28499 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28500 if (!SWIG_IsOK(res2)) {
28501 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28502 }
28503 if (!argp2) {
28504 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28505 }
28506 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28507 {
28508 PyThreadState* __tstate = wxPyBeginAllowThreads();
28509 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
28510 wxPyEndAllowThreads(__tstate);
28511 if (PyErr_Occurred()) SWIG_fail;
28512 }
28513 {
28514 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28515 }
28516 return resultobj;
28517 fail:
28518 return NULL;
28519 }
28520
28521
28522 SWIGINTERN PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28523 PyObject *resultobj = 0;
28524 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28525 wxTimeSpan *arg2 = 0 ;
28526 bool result;
28527 void *argp1 = 0 ;
28528 int res1 = 0 ;
28529 void *argp2 = 0 ;
28530 int res2 = 0 ;
28531 PyObject * obj0 = 0 ;
28532 PyObject * obj1 = 0 ;
28533 char * kwnames[] = {
28534 (char *) "self",(char *) "ts", NULL
28535 };
28536
28537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) SWIG_fail;
28538 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28539 if (!SWIG_IsOK(res1)) {
28540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28541 }
28542 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28543 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28544 if (!SWIG_IsOK(res2)) {
28545 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28546 }
28547 if (!argp2) {
28548 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28549 }
28550 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28551 {
28552 PyThreadState* __tstate = wxPyBeginAllowThreads();
28553 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
28554 wxPyEndAllowThreads(__tstate);
28555 if (PyErr_Occurred()) SWIG_fail;
28556 }
28557 {
28558 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28559 }
28560 return resultobj;
28561 fail:
28562 return NULL;
28563 }
28564
28565
28566 SWIGINTERN PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28567 PyObject *resultobj = 0;
28568 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28569 wxTimeSpan *arg2 = 0 ;
28570 bool result;
28571 void *argp1 = 0 ;
28572 int res1 = 0 ;
28573 void *argp2 = 0 ;
28574 int res2 = 0 ;
28575 PyObject * obj0 = 0 ;
28576 PyObject * obj1 = 0 ;
28577 char * kwnames[] = {
28578 (char *) "self",(char *) "t", NULL
28579 };
28580
28581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) SWIG_fail;
28582 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28583 if (!SWIG_IsOK(res1)) {
28584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28585 }
28586 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28587 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28588 if (!SWIG_IsOK(res2)) {
28589 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28590 }
28591 if (!argp2) {
28592 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28593 }
28594 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28595 {
28596 PyThreadState* __tstate = wxPyBeginAllowThreads();
28597 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
28598 wxPyEndAllowThreads(__tstate);
28599 if (PyErr_Occurred()) SWIG_fail;
28600 }
28601 {
28602 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28603 }
28604 return resultobj;
28605 fail:
28606 return NULL;
28607 }
28608
28609
28610 SWIGINTERN PyObject *_wrap_TimeSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28611 PyObject *resultobj = 0;
28612 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28613 int result;
28614 void *argp1 = 0 ;
28615 int res1 = 0 ;
28616 PyObject *swig_obj[1] ;
28617
28618 if (!args) SWIG_fail;
28619 swig_obj[0] = args;
28620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28621 if (!SWIG_IsOK(res1)) {
28622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetWeeks" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28623 }
28624 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28625 {
28626 PyThreadState* __tstate = wxPyBeginAllowThreads();
28627 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
28628 wxPyEndAllowThreads(__tstate);
28629 if (PyErr_Occurred()) SWIG_fail;
28630 }
28631 resultobj = SWIG_From_int(static_cast< int >(result));
28632 return resultobj;
28633 fail:
28634 return NULL;
28635 }
28636
28637
28638 SWIGINTERN PyObject *_wrap_TimeSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28639 PyObject *resultobj = 0;
28640 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28641 int result;
28642 void *argp1 = 0 ;
28643 int res1 = 0 ;
28644 PyObject *swig_obj[1] ;
28645
28646 if (!args) SWIG_fail;
28647 swig_obj[0] = args;
28648 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28649 if (!SWIG_IsOK(res1)) {
28650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetDays" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28651 }
28652 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28653 {
28654 PyThreadState* __tstate = wxPyBeginAllowThreads();
28655 result = (int)((wxTimeSpan const *)arg1)->GetDays();
28656 wxPyEndAllowThreads(__tstate);
28657 if (PyErr_Occurred()) SWIG_fail;
28658 }
28659 resultobj = SWIG_From_int(static_cast< int >(result));
28660 return resultobj;
28661 fail:
28662 return NULL;
28663 }
28664
28665
28666 SWIGINTERN PyObject *_wrap_TimeSpan_GetHours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28667 PyObject *resultobj = 0;
28668 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28669 int result;
28670 void *argp1 = 0 ;
28671 int res1 = 0 ;
28672 PyObject *swig_obj[1] ;
28673
28674 if (!args) SWIG_fail;
28675 swig_obj[0] = args;
28676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28677 if (!SWIG_IsOK(res1)) {
28678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetHours" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28679 }
28680 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28681 {
28682 PyThreadState* __tstate = wxPyBeginAllowThreads();
28683 result = (int)((wxTimeSpan const *)arg1)->GetHours();
28684 wxPyEndAllowThreads(__tstate);
28685 if (PyErr_Occurred()) SWIG_fail;
28686 }
28687 resultobj = SWIG_From_int(static_cast< int >(result));
28688 return resultobj;
28689 fail:
28690 return NULL;
28691 }
28692
28693
28694 SWIGINTERN PyObject *_wrap_TimeSpan_GetMinutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28695 PyObject *resultobj = 0;
28696 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28697 int result;
28698 void *argp1 = 0 ;
28699 int res1 = 0 ;
28700 PyObject *swig_obj[1] ;
28701
28702 if (!args) SWIG_fail;
28703 swig_obj[0] = args;
28704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28705 if (!SWIG_IsOK(res1)) {
28706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMinutes" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28707 }
28708 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28709 {
28710 PyThreadState* __tstate = wxPyBeginAllowThreads();
28711 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
28712 wxPyEndAllowThreads(__tstate);
28713 if (PyErr_Occurred()) SWIG_fail;
28714 }
28715 resultobj = SWIG_From_int(static_cast< int >(result));
28716 return resultobj;
28717 fail:
28718 return NULL;
28719 }
28720
28721
28722 SWIGINTERN PyObject *_wrap_TimeSpan_GetSeconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28723 PyObject *resultobj = 0;
28724 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28725 wxLongLong result;
28726 void *argp1 = 0 ;
28727 int res1 = 0 ;
28728 PyObject *swig_obj[1] ;
28729
28730 if (!args) SWIG_fail;
28731 swig_obj[0] = args;
28732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28733 if (!SWIG_IsOK(res1)) {
28734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetSeconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28735 }
28736 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28737 {
28738 PyThreadState* __tstate = wxPyBeginAllowThreads();
28739 result = ((wxTimeSpan const *)arg1)->GetSeconds();
28740 wxPyEndAllowThreads(__tstate);
28741 if (PyErr_Occurred()) SWIG_fail;
28742 }
28743 {
28744 PyObject *hi, *lo, *shifter, *shifted;
28745 hi = PyLong_FromLong( (&result)->GetHi() );
28746 lo = PyLong_FromLong( (&result)->GetLo() );
28747 shifter = PyLong_FromLong(32);
28748 shifted = PyNumber_Lshift(hi, shifter);
28749 resultobj = PyNumber_Or(shifted, lo);
28750 Py_DECREF(hi);
28751 Py_DECREF(lo);
28752 Py_DECREF(shifter);
28753 Py_DECREF(shifted);
28754 }
28755 return resultobj;
28756 fail:
28757 return NULL;
28758 }
28759
28760
28761 SWIGINTERN PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28762 PyObject *resultobj = 0;
28763 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28764 wxLongLong result;
28765 void *argp1 = 0 ;
28766 int res1 = 0 ;
28767 PyObject *swig_obj[1] ;
28768
28769 if (!args) SWIG_fail;
28770 swig_obj[0] = args;
28771 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28772 if (!SWIG_IsOK(res1)) {
28773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMilliseconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28774 }
28775 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28776 {
28777 PyThreadState* __tstate = wxPyBeginAllowThreads();
28778 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
28779 wxPyEndAllowThreads(__tstate);
28780 if (PyErr_Occurred()) SWIG_fail;
28781 }
28782 {
28783 PyObject *hi, *lo, *shifter, *shifted;
28784 hi = PyLong_FromLong( (&result)->GetHi() );
28785 lo = PyLong_FromLong( (&result)->GetLo() );
28786 shifter = PyLong_FromLong(32);
28787 shifted = PyNumber_Lshift(hi, shifter);
28788 resultobj = PyNumber_Or(shifted, lo);
28789 Py_DECREF(hi);
28790 Py_DECREF(lo);
28791 Py_DECREF(shifter);
28792 Py_DECREF(shifted);
28793 }
28794 return resultobj;
28795 fail:
28796 return NULL;
28797 }
28798
28799
28800 SWIGINTERN PyObject *_wrap_TimeSpan_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28801 PyObject *resultobj = 0;
28802 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28803 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
28804 wxString *arg2 = (wxString *) &arg2_defvalue ;
28805 wxString result;
28806 void *argp1 = 0 ;
28807 int res1 = 0 ;
28808 bool temp2 = false ;
28809 PyObject * obj0 = 0 ;
28810 PyObject * obj1 = 0 ;
28811 char * kwnames[] = {
28812 (char *) "self",(char *) "format", NULL
28813 };
28814
28815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) SWIG_fail;
28816 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28817 if (!SWIG_IsOK(res1)) {
28818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Format" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28819 }
28820 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28821 if (obj1) {
28822 {
28823 arg2 = wxString_in_helper(obj1);
28824 if (arg2 == NULL) SWIG_fail;
28825 temp2 = true;
28826 }
28827 }
28828 {
28829 PyThreadState* __tstate = wxPyBeginAllowThreads();
28830 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
28831 wxPyEndAllowThreads(__tstate);
28832 if (PyErr_Occurred()) SWIG_fail;
28833 }
28834 {
28835 #if wxUSE_UNICODE
28836 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28837 #else
28838 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28839 #endif
28840 }
28841 {
28842 if (temp2)
28843 delete arg2;
28844 }
28845 return resultobj;
28846 fail:
28847 {
28848 if (temp2)
28849 delete arg2;
28850 }
28851 return NULL;
28852 }
28853
28854
28855 SWIGINTERN PyObject *TimeSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28856 PyObject *obj;
28857 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28858 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimeSpan, SWIG_NewClientData(obj));
28859 return SWIG_Py_Void();
28860 }
28861
28862 SWIGINTERN PyObject *TimeSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28863 return SWIG_Python_InitShadowInstance(args);
28864 }
28865
28866 SWIGINTERN PyObject *_wrap_new_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28867 PyObject *resultobj = 0;
28868 int arg1 = (int) 0 ;
28869 int arg2 = (int) 0 ;
28870 int arg3 = (int) 0 ;
28871 int arg4 = (int) 0 ;
28872 wxDateSpan *result = 0 ;
28873 int val1 ;
28874 int ecode1 = 0 ;
28875 int val2 ;
28876 int ecode2 = 0 ;
28877 int val3 ;
28878 int ecode3 = 0 ;
28879 int val4 ;
28880 int ecode4 = 0 ;
28881 PyObject * obj0 = 0 ;
28882 PyObject * obj1 = 0 ;
28883 PyObject * obj2 = 0 ;
28884 PyObject * obj3 = 0 ;
28885 char * kwnames[] = {
28886 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
28887 };
28888
28889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28890 if (obj0) {
28891 ecode1 = SWIG_AsVal_int(obj0, &val1);
28892 if (!SWIG_IsOK(ecode1)) {
28893 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateSpan" "', expected argument " "1"" of type '" "int""'");
28894 }
28895 arg1 = static_cast< int >(val1);
28896 }
28897 if (obj1) {
28898 ecode2 = SWIG_AsVal_int(obj1, &val2);
28899 if (!SWIG_IsOK(ecode2)) {
28900 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateSpan" "', expected argument " "2"" of type '" "int""'");
28901 }
28902 arg2 = static_cast< int >(val2);
28903 }
28904 if (obj2) {
28905 ecode3 = SWIG_AsVal_int(obj2, &val3);
28906 if (!SWIG_IsOK(ecode3)) {
28907 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateSpan" "', expected argument " "3"" of type '" "int""'");
28908 }
28909 arg3 = static_cast< int >(val3);
28910 }
28911 if (obj3) {
28912 ecode4 = SWIG_AsVal_int(obj3, &val4);
28913 if (!SWIG_IsOK(ecode4)) {
28914 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateSpan" "', expected argument " "4"" of type '" "int""'");
28915 }
28916 arg4 = static_cast< int >(val4);
28917 }
28918 {
28919 PyThreadState* __tstate = wxPyBeginAllowThreads();
28920 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
28921 wxPyEndAllowThreads(__tstate);
28922 if (PyErr_Occurred()) SWIG_fail;
28923 }
28924 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_NEW | 0 );
28925 return resultobj;
28926 fail:
28927 return NULL;
28928 }
28929
28930
28931 SWIGINTERN PyObject *_wrap_delete_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28932 PyObject *resultobj = 0;
28933 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
28934 void *argp1 = 0 ;
28935 int res1 = 0 ;
28936 PyObject *swig_obj[1] ;
28937
28938 if (!args) SWIG_fail;
28939 swig_obj[0] = args;
28940 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
28941 if (!SWIG_IsOK(res1)) {
28942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateSpan" "', expected argument " "1"" of type '" "wxDateSpan *""'");
28943 }
28944 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
28945 {
28946 PyThreadState* __tstate = wxPyBeginAllowThreads();
28947 delete arg1;
28948
28949 wxPyEndAllowThreads(__tstate);
28950 if (PyErr_Occurred()) SWIG_fail;
28951 }
28952 resultobj = SWIG_Py_Void();
28953 return resultobj;
28954 fail:
28955 return NULL;
28956 }
28957
28958
28959 SWIGINTERN PyObject *_wrap_DateSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28960 PyObject *resultobj = 0;
28961 int arg1 ;
28962 wxDateSpan result;
28963 int val1 ;
28964 int ecode1 = 0 ;
28965 PyObject * obj0 = 0 ;
28966 char * kwnames[] = {
28967 (char *) "days", NULL
28968 };
28969
28970 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) SWIG_fail;
28971 ecode1 = SWIG_AsVal_int(obj0, &val1);
28972 if (!SWIG_IsOK(ecode1)) {
28973 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Days" "', expected argument " "1"" of type '" "int""'");
28974 }
28975 arg1 = static_cast< int >(val1);
28976 {
28977 PyThreadState* __tstate = wxPyBeginAllowThreads();
28978 result = wxDateSpan::Days(arg1);
28979 wxPyEndAllowThreads(__tstate);
28980 if (PyErr_Occurred()) SWIG_fail;
28981 }
28982 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
28983 return resultobj;
28984 fail:
28985 return NULL;
28986 }
28987
28988
28989 SWIGINTERN PyObject *_wrap_DateSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28990 PyObject *resultobj = 0;
28991 wxDateSpan result;
28992
28993 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Day",0,0,0)) SWIG_fail;
28994 {
28995 PyThreadState* __tstate = wxPyBeginAllowThreads();
28996 result = wxDateSpan::Day();
28997 wxPyEndAllowThreads(__tstate);
28998 if (PyErr_Occurred()) SWIG_fail;
28999 }
29000 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29001 return resultobj;
29002 fail:
29003 return NULL;
29004 }
29005
29006
29007 SWIGINTERN PyObject *_wrap_DateSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29008 PyObject *resultobj = 0;
29009 int arg1 ;
29010 wxDateSpan result;
29011 int val1 ;
29012 int ecode1 = 0 ;
29013 PyObject * obj0 = 0 ;
29014 char * kwnames[] = {
29015 (char *) "weeks", NULL
29016 };
29017
29018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) SWIG_fail;
29019 ecode1 = SWIG_AsVal_int(obj0, &val1);
29020 if (!SWIG_IsOK(ecode1)) {
29021 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Weeks" "', expected argument " "1"" of type '" "int""'");
29022 }
29023 arg1 = static_cast< int >(val1);
29024 {
29025 PyThreadState* __tstate = wxPyBeginAllowThreads();
29026 result = wxDateSpan::Weeks(arg1);
29027 wxPyEndAllowThreads(__tstate);
29028 if (PyErr_Occurred()) SWIG_fail;
29029 }
29030 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29031 return resultobj;
29032 fail:
29033 return NULL;
29034 }
29035
29036
29037 SWIGINTERN PyObject *_wrap_DateSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29038 PyObject *resultobj = 0;
29039 wxDateSpan result;
29040
29041 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Week",0,0,0)) SWIG_fail;
29042 {
29043 PyThreadState* __tstate = wxPyBeginAllowThreads();
29044 result = wxDateSpan::Week();
29045 wxPyEndAllowThreads(__tstate);
29046 if (PyErr_Occurred()) SWIG_fail;
29047 }
29048 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29049 return resultobj;
29050 fail:
29051 return NULL;
29052 }
29053
29054
29055 SWIGINTERN PyObject *_wrap_DateSpan_Months(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29056 PyObject *resultobj = 0;
29057 int arg1 ;
29058 wxDateSpan result;
29059 int val1 ;
29060 int ecode1 = 0 ;
29061 PyObject * obj0 = 0 ;
29062 char * kwnames[] = {
29063 (char *) "mon", NULL
29064 };
29065
29066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) SWIG_fail;
29067 ecode1 = SWIG_AsVal_int(obj0, &val1);
29068 if (!SWIG_IsOK(ecode1)) {
29069 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Months" "', expected argument " "1"" of type '" "int""'");
29070 }
29071 arg1 = static_cast< int >(val1);
29072 {
29073 PyThreadState* __tstate = wxPyBeginAllowThreads();
29074 result = wxDateSpan::Months(arg1);
29075 wxPyEndAllowThreads(__tstate);
29076 if (PyErr_Occurred()) SWIG_fail;
29077 }
29078 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29079 return resultobj;
29080 fail:
29081 return NULL;
29082 }
29083
29084
29085 SWIGINTERN PyObject *_wrap_DateSpan_Month(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29086 PyObject *resultobj = 0;
29087 wxDateSpan result;
29088
29089 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Month",0,0,0)) SWIG_fail;
29090 {
29091 PyThreadState* __tstate = wxPyBeginAllowThreads();
29092 result = wxDateSpan::Month();
29093 wxPyEndAllowThreads(__tstate);
29094 if (PyErr_Occurred()) SWIG_fail;
29095 }
29096 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29097 return resultobj;
29098 fail:
29099 return NULL;
29100 }
29101
29102
29103 SWIGINTERN PyObject *_wrap_DateSpan_Years(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29104 PyObject *resultobj = 0;
29105 int arg1 ;
29106 wxDateSpan result;
29107 int val1 ;
29108 int ecode1 = 0 ;
29109 PyObject * obj0 = 0 ;
29110 char * kwnames[] = {
29111 (char *) "years", NULL
29112 };
29113
29114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) SWIG_fail;
29115 ecode1 = SWIG_AsVal_int(obj0, &val1);
29116 if (!SWIG_IsOK(ecode1)) {
29117 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Years" "', expected argument " "1"" of type '" "int""'");
29118 }
29119 arg1 = static_cast< int >(val1);
29120 {
29121 PyThreadState* __tstate = wxPyBeginAllowThreads();
29122 result = wxDateSpan::Years(arg1);
29123 wxPyEndAllowThreads(__tstate);
29124 if (PyErr_Occurred()) SWIG_fail;
29125 }
29126 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29127 return resultobj;
29128 fail:
29129 return NULL;
29130 }
29131
29132
29133 SWIGINTERN PyObject *_wrap_DateSpan_Year(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29134 PyObject *resultobj = 0;
29135 wxDateSpan result;
29136
29137 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Year",0,0,0)) SWIG_fail;
29138 {
29139 PyThreadState* __tstate = wxPyBeginAllowThreads();
29140 result = wxDateSpan::Year();
29141 wxPyEndAllowThreads(__tstate);
29142 if (PyErr_Occurred()) SWIG_fail;
29143 }
29144 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29145 return resultobj;
29146 fail:
29147 return NULL;
29148 }
29149
29150
29151 SWIGINTERN PyObject *_wrap_DateSpan_SetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29152 PyObject *resultobj = 0;
29153 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29154 int arg2 ;
29155 wxDateSpan *result = 0 ;
29156 void *argp1 = 0 ;
29157 int res1 = 0 ;
29158 int val2 ;
29159 int ecode2 = 0 ;
29160 PyObject * obj0 = 0 ;
29161 PyObject * obj1 = 0 ;
29162 char * kwnames[] = {
29163 (char *) "self",(char *) "n", NULL
29164 };
29165
29166 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) SWIG_fail;
29167 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29168 if (!SWIG_IsOK(res1)) {
29169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetYears" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29170 }
29171 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29172 ecode2 = SWIG_AsVal_int(obj1, &val2);
29173 if (!SWIG_IsOK(ecode2)) {
29174 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetYears" "', expected argument " "2"" of type '" "int""'");
29175 }
29176 arg2 = static_cast< int >(val2);
29177 {
29178 PyThreadState* __tstate = wxPyBeginAllowThreads();
29179 {
29180 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
29181 result = (wxDateSpan *) &_result_ref;
29182 }
29183 wxPyEndAllowThreads(__tstate);
29184 if (PyErr_Occurred()) SWIG_fail;
29185 }
29186 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29187 return resultobj;
29188 fail:
29189 return NULL;
29190 }
29191
29192
29193 SWIGINTERN PyObject *_wrap_DateSpan_SetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29194 PyObject *resultobj = 0;
29195 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29196 int arg2 ;
29197 wxDateSpan *result = 0 ;
29198 void *argp1 = 0 ;
29199 int res1 = 0 ;
29200 int val2 ;
29201 int ecode2 = 0 ;
29202 PyObject * obj0 = 0 ;
29203 PyObject * obj1 = 0 ;
29204 char * kwnames[] = {
29205 (char *) "self",(char *) "n", NULL
29206 };
29207
29208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) SWIG_fail;
29209 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29210 if (!SWIG_IsOK(res1)) {
29211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetMonths" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29212 }
29213 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29214 ecode2 = SWIG_AsVal_int(obj1, &val2);
29215 if (!SWIG_IsOK(ecode2)) {
29216 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetMonths" "', expected argument " "2"" of type '" "int""'");
29217 }
29218 arg2 = static_cast< int >(val2);
29219 {
29220 PyThreadState* __tstate = wxPyBeginAllowThreads();
29221 {
29222 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
29223 result = (wxDateSpan *) &_result_ref;
29224 }
29225 wxPyEndAllowThreads(__tstate);
29226 if (PyErr_Occurred()) SWIG_fail;
29227 }
29228 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29229 return resultobj;
29230 fail:
29231 return NULL;
29232 }
29233
29234
29235 SWIGINTERN PyObject *_wrap_DateSpan_SetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29236 PyObject *resultobj = 0;
29237 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29238 int arg2 ;
29239 wxDateSpan *result = 0 ;
29240 void *argp1 = 0 ;
29241 int res1 = 0 ;
29242 int val2 ;
29243 int ecode2 = 0 ;
29244 PyObject * obj0 = 0 ;
29245 PyObject * obj1 = 0 ;
29246 char * kwnames[] = {
29247 (char *) "self",(char *) "n", NULL
29248 };
29249
29250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) SWIG_fail;
29251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29252 if (!SWIG_IsOK(res1)) {
29253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetWeeks" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29254 }
29255 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29256 ecode2 = SWIG_AsVal_int(obj1, &val2);
29257 if (!SWIG_IsOK(ecode2)) {
29258 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetWeeks" "', expected argument " "2"" of type '" "int""'");
29259 }
29260 arg2 = static_cast< int >(val2);
29261 {
29262 PyThreadState* __tstate = wxPyBeginAllowThreads();
29263 {
29264 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
29265 result = (wxDateSpan *) &_result_ref;
29266 }
29267 wxPyEndAllowThreads(__tstate);
29268 if (PyErr_Occurred()) SWIG_fail;
29269 }
29270 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29271 return resultobj;
29272 fail:
29273 return NULL;
29274 }
29275
29276
29277 SWIGINTERN PyObject *_wrap_DateSpan_SetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29278 PyObject *resultobj = 0;
29279 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29280 int arg2 ;
29281 wxDateSpan *result = 0 ;
29282 void *argp1 = 0 ;
29283 int res1 = 0 ;
29284 int val2 ;
29285 int ecode2 = 0 ;
29286 PyObject * obj0 = 0 ;
29287 PyObject * obj1 = 0 ;
29288 char * kwnames[] = {
29289 (char *) "self",(char *) "n", NULL
29290 };
29291
29292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) SWIG_fail;
29293 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29294 if (!SWIG_IsOK(res1)) {
29295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetDays" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29296 }
29297 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29298 ecode2 = SWIG_AsVal_int(obj1, &val2);
29299 if (!SWIG_IsOK(ecode2)) {
29300 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetDays" "', expected argument " "2"" of type '" "int""'");
29301 }
29302 arg2 = static_cast< int >(val2);
29303 {
29304 PyThreadState* __tstate = wxPyBeginAllowThreads();
29305 {
29306 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
29307 result = (wxDateSpan *) &_result_ref;
29308 }
29309 wxPyEndAllowThreads(__tstate);
29310 if (PyErr_Occurred()) SWIG_fail;
29311 }
29312 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29313 return resultobj;
29314 fail:
29315 return NULL;
29316 }
29317
29318
29319 SWIGINTERN PyObject *_wrap_DateSpan_GetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29320 PyObject *resultobj = 0;
29321 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29322 int result;
29323 void *argp1 = 0 ;
29324 int res1 = 0 ;
29325 PyObject *swig_obj[1] ;
29326
29327 if (!args) SWIG_fail;
29328 swig_obj[0] = args;
29329 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29330 if (!SWIG_IsOK(res1)) {
29331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetYears" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29332 }
29333 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29334 {
29335 PyThreadState* __tstate = wxPyBeginAllowThreads();
29336 result = (int)((wxDateSpan const *)arg1)->GetYears();
29337 wxPyEndAllowThreads(__tstate);
29338 if (PyErr_Occurred()) SWIG_fail;
29339 }
29340 resultobj = SWIG_From_int(static_cast< int >(result));
29341 return resultobj;
29342 fail:
29343 return NULL;
29344 }
29345
29346
29347 SWIGINTERN PyObject *_wrap_DateSpan_GetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29348 PyObject *resultobj = 0;
29349 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29350 int result;
29351 void *argp1 = 0 ;
29352 int res1 = 0 ;
29353 PyObject *swig_obj[1] ;
29354
29355 if (!args) SWIG_fail;
29356 swig_obj[0] = args;
29357 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29358 if (!SWIG_IsOK(res1)) {
29359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetMonths" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29360 }
29361 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29362 {
29363 PyThreadState* __tstate = wxPyBeginAllowThreads();
29364 result = (int)((wxDateSpan const *)arg1)->GetMonths();
29365 wxPyEndAllowThreads(__tstate);
29366 if (PyErr_Occurred()) SWIG_fail;
29367 }
29368 resultobj = SWIG_From_int(static_cast< int >(result));
29369 return resultobj;
29370 fail:
29371 return NULL;
29372 }
29373
29374
29375 SWIGINTERN PyObject *_wrap_DateSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29376 PyObject *resultobj = 0;
29377 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29378 int result;
29379 void *argp1 = 0 ;
29380 int res1 = 0 ;
29381 PyObject *swig_obj[1] ;
29382
29383 if (!args) SWIG_fail;
29384 swig_obj[0] = args;
29385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29386 if (!SWIG_IsOK(res1)) {
29387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetWeeks" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29388 }
29389 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29390 {
29391 PyThreadState* __tstate = wxPyBeginAllowThreads();
29392 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
29393 wxPyEndAllowThreads(__tstate);
29394 if (PyErr_Occurred()) SWIG_fail;
29395 }
29396 resultobj = SWIG_From_int(static_cast< int >(result));
29397 return resultobj;
29398 fail:
29399 return NULL;
29400 }
29401
29402
29403 SWIGINTERN PyObject *_wrap_DateSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29404 PyObject *resultobj = 0;
29405 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29406 int result;
29407 void *argp1 = 0 ;
29408 int res1 = 0 ;
29409 PyObject *swig_obj[1] ;
29410
29411 if (!args) SWIG_fail;
29412 swig_obj[0] = args;
29413 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29414 if (!SWIG_IsOK(res1)) {
29415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29416 }
29417 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29418 {
29419 PyThreadState* __tstate = wxPyBeginAllowThreads();
29420 result = (int)((wxDateSpan const *)arg1)->GetDays();
29421 wxPyEndAllowThreads(__tstate);
29422 if (PyErr_Occurred()) SWIG_fail;
29423 }
29424 resultobj = SWIG_From_int(static_cast< int >(result));
29425 return resultobj;
29426 fail:
29427 return NULL;
29428 }
29429
29430
29431 SWIGINTERN PyObject *_wrap_DateSpan_GetTotalDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29432 PyObject *resultobj = 0;
29433 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29434 int result;
29435 void *argp1 = 0 ;
29436 int res1 = 0 ;
29437 PyObject *swig_obj[1] ;
29438
29439 if (!args) SWIG_fail;
29440 swig_obj[0] = args;
29441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29442 if (!SWIG_IsOK(res1)) {
29443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetTotalDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29444 }
29445 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29446 {
29447 PyThreadState* __tstate = wxPyBeginAllowThreads();
29448 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
29449 wxPyEndAllowThreads(__tstate);
29450 if (PyErr_Occurred()) SWIG_fail;
29451 }
29452 resultobj = SWIG_From_int(static_cast< int >(result));
29453 return resultobj;
29454 fail:
29455 return NULL;
29456 }
29457
29458
29459 SWIGINTERN PyObject *_wrap_DateSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29460 PyObject *resultobj = 0;
29461 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29462 wxDateSpan *arg2 = 0 ;
29463 wxDateSpan *result = 0 ;
29464 void *argp1 = 0 ;
29465 int res1 = 0 ;
29466 void *argp2 = 0 ;
29467 int res2 = 0 ;
29468 PyObject * obj0 = 0 ;
29469 PyObject * obj1 = 0 ;
29470 char * kwnames[] = {
29471 (char *) "self",(char *) "other", NULL
29472 };
29473
29474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
29475 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29476 if (!SWIG_IsOK(res1)) {
29477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Add" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29478 }
29479 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29480 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29481 if (!SWIG_IsOK(res2)) {
29482 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29483 }
29484 if (!argp2) {
29485 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29486 }
29487 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29488 {
29489 PyThreadState* __tstate = wxPyBeginAllowThreads();
29490 {
29491 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
29492 result = (wxDateSpan *) &_result_ref;
29493 }
29494 wxPyEndAllowThreads(__tstate);
29495 if (PyErr_Occurred()) SWIG_fail;
29496 }
29497 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29498 return resultobj;
29499 fail:
29500 return NULL;
29501 }
29502
29503
29504 SWIGINTERN PyObject *_wrap_DateSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29505 PyObject *resultobj = 0;
29506 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29507 wxDateSpan *arg2 = 0 ;
29508 wxDateSpan *result = 0 ;
29509 void *argp1 = 0 ;
29510 int res1 = 0 ;
29511 void *argp2 = 0 ;
29512 int res2 = 0 ;
29513 PyObject * obj0 = 0 ;
29514 PyObject * obj1 = 0 ;
29515 char * kwnames[] = {
29516 (char *) "self",(char *) "other", NULL
29517 };
29518
29519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
29520 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29521 if (!SWIG_IsOK(res1)) {
29522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Subtract" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29523 }
29524 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29525 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29526 if (!SWIG_IsOK(res2)) {
29527 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29528 }
29529 if (!argp2) {
29530 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29531 }
29532 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29533 {
29534 PyThreadState* __tstate = wxPyBeginAllowThreads();
29535 {
29536 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
29537 result = (wxDateSpan *) &_result_ref;
29538 }
29539 wxPyEndAllowThreads(__tstate);
29540 if (PyErr_Occurred()) SWIG_fail;
29541 }
29542 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29543 return resultobj;
29544 fail:
29545 return NULL;
29546 }
29547
29548
29549 SWIGINTERN PyObject *_wrap_DateSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29550 PyObject *resultobj = 0;
29551 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29552 wxDateSpan *result = 0 ;
29553 void *argp1 = 0 ;
29554 int res1 = 0 ;
29555 PyObject *swig_obj[1] ;
29556
29557 if (!args) SWIG_fail;
29558 swig_obj[0] = args;
29559 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29560 if (!SWIG_IsOK(res1)) {
29561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Neg" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29562 }
29563 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29564 {
29565 PyThreadState* __tstate = wxPyBeginAllowThreads();
29566 {
29567 wxDateSpan &_result_ref = (arg1)->Neg();
29568 result = (wxDateSpan *) &_result_ref;
29569 }
29570 wxPyEndAllowThreads(__tstate);
29571 if (PyErr_Occurred()) SWIG_fail;
29572 }
29573 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29574 return resultobj;
29575 fail:
29576 return NULL;
29577 }
29578
29579
29580 SWIGINTERN PyObject *_wrap_DateSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29581 PyObject *resultobj = 0;
29582 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29583 int arg2 ;
29584 wxDateSpan *result = 0 ;
29585 void *argp1 = 0 ;
29586 int res1 = 0 ;
29587 int val2 ;
29588 int ecode2 = 0 ;
29589 PyObject * obj0 = 0 ;
29590 PyObject * obj1 = 0 ;
29591 char * kwnames[] = {
29592 (char *) "self",(char *) "factor", NULL
29593 };
29594
29595 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
29596 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29597 if (!SWIG_IsOK(res1)) {
29598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Multiply" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29599 }
29600 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29601 ecode2 = SWIG_AsVal_int(obj1, &val2);
29602 if (!SWIG_IsOK(ecode2)) {
29603 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
29604 }
29605 arg2 = static_cast< int >(val2);
29606 {
29607 PyThreadState* __tstate = wxPyBeginAllowThreads();
29608 {
29609 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
29610 result = (wxDateSpan *) &_result_ref;
29611 }
29612 wxPyEndAllowThreads(__tstate);
29613 if (PyErr_Occurred()) SWIG_fail;
29614 }
29615 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29616 return resultobj;
29617 fail:
29618 return NULL;
29619 }
29620
29621
29622 SWIGINTERN PyObject *_wrap_DateSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29623 PyObject *resultobj = 0;
29624 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29625 wxDateSpan *arg2 = 0 ;
29626 wxDateSpan *result = 0 ;
29627 void *argp1 = 0 ;
29628 int res1 = 0 ;
29629 void *argp2 = 0 ;
29630 int res2 = 0 ;
29631 PyObject * obj0 = 0 ;
29632 PyObject * obj1 = 0 ;
29633 char * kwnames[] = {
29634 (char *) "self",(char *) "other", NULL
29635 };
29636
29637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
29638 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
29639 if (!SWIG_IsOK(res1)) {
29640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___iadd__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29641 }
29642 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29643 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29644 if (!SWIG_IsOK(res2)) {
29645 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29646 }
29647 if (!argp2) {
29648 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29649 }
29650 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29651 {
29652 PyThreadState* __tstate = wxPyBeginAllowThreads();
29653 {
29654 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
29655 result = (wxDateSpan *) &_result_ref;
29656 }
29657 wxPyEndAllowThreads(__tstate);
29658 if (PyErr_Occurred()) SWIG_fail;
29659 }
29660 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29661 return resultobj;
29662 fail:
29663 return NULL;
29664 }
29665
29666
29667 SWIGINTERN PyObject *_wrap_DateSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29668 PyObject *resultobj = 0;
29669 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29670 wxDateSpan *arg2 = 0 ;
29671 wxDateSpan *result = 0 ;
29672 void *argp1 = 0 ;
29673 int res1 = 0 ;
29674 void *argp2 = 0 ;
29675 int res2 = 0 ;
29676 PyObject * obj0 = 0 ;
29677 PyObject * obj1 = 0 ;
29678 char * kwnames[] = {
29679 (char *) "self",(char *) "other", NULL
29680 };
29681
29682 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
29683 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
29684 if (!SWIG_IsOK(res1)) {
29685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___isub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29686 }
29687 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29688 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29689 if (!SWIG_IsOK(res2)) {
29690 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29691 }
29692 if (!argp2) {
29693 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29694 }
29695 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29696 {
29697 PyThreadState* __tstate = wxPyBeginAllowThreads();
29698 {
29699 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
29700 result = (wxDateSpan *) &_result_ref;
29701 }
29702 wxPyEndAllowThreads(__tstate);
29703 if (PyErr_Occurred()) SWIG_fail;
29704 }
29705 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29706 return resultobj;
29707 fail:
29708 return NULL;
29709 }
29710
29711
29712 SWIGINTERN PyObject *_wrap_DateSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29713 PyObject *resultobj = 0;
29714 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29715 wxDateSpan *result = 0 ;
29716 void *argp1 = 0 ;
29717 int res1 = 0 ;
29718 PyObject *swig_obj[1] ;
29719
29720 if (!args) SWIG_fail;
29721 swig_obj[0] = args;
29722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29723 if (!SWIG_IsOK(res1)) {
29724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___neg__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29725 }
29726 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29727 {
29728 PyThreadState* __tstate = wxPyBeginAllowThreads();
29729 {
29730 wxDateSpan &_result_ref = (arg1)->operator -();
29731 result = (wxDateSpan *) &_result_ref;
29732 }
29733 wxPyEndAllowThreads(__tstate);
29734 if (PyErr_Occurred()) SWIG_fail;
29735 }
29736 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29737 return resultobj;
29738 fail:
29739 return NULL;
29740 }
29741
29742
29743 SWIGINTERN PyObject *_wrap_DateSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29744 PyObject *resultobj = 0;
29745 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29746 int arg2 ;
29747 wxDateSpan *result = 0 ;
29748 void *argp1 = 0 ;
29749 int res1 = 0 ;
29750 int val2 ;
29751 int ecode2 = 0 ;
29752 PyObject * obj0 = 0 ;
29753 PyObject * obj1 = 0 ;
29754 char * kwnames[] = {
29755 (char *) "self",(char *) "factor", NULL
29756 };
29757
29758 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
29759 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
29760 if (!SWIG_IsOK(res1)) {
29761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___imul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29762 }
29763 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29764 ecode2 = SWIG_AsVal_int(obj1, &val2);
29765 if (!SWIG_IsOK(ecode2)) {
29766 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___imul__" "', expected argument " "2"" of type '" "int""'");
29767 }
29768 arg2 = static_cast< int >(val2);
29769 {
29770 PyThreadState* __tstate = wxPyBeginAllowThreads();
29771 {
29772 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
29773 result = (wxDateSpan *) &_result_ref;
29774 }
29775 wxPyEndAllowThreads(__tstate);
29776 if (PyErr_Occurred()) SWIG_fail;
29777 }
29778 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29779 return resultobj;
29780 fail:
29781 return NULL;
29782 }
29783
29784
29785 SWIGINTERN PyObject *_wrap_DateSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29786 PyObject *resultobj = 0;
29787 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29788 wxDateSpan *arg2 = 0 ;
29789 wxDateSpan result;
29790 void *argp1 = 0 ;
29791 int res1 = 0 ;
29792 void *argp2 = 0 ;
29793 int res2 = 0 ;
29794 PyObject * obj0 = 0 ;
29795 PyObject * obj1 = 0 ;
29796 char * kwnames[] = {
29797 (char *) "self",(char *) "other", NULL
29798 };
29799
29800 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
29801 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29802 if (!SWIG_IsOK(res1)) {
29803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___add__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29804 }
29805 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29806 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29807 if (!SWIG_IsOK(res2)) {
29808 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29809 }
29810 if (!argp2) {
29811 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29812 }
29813 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29814 {
29815 PyThreadState* __tstate = wxPyBeginAllowThreads();
29816 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
29817 wxPyEndAllowThreads(__tstate);
29818 if (PyErr_Occurred()) SWIG_fail;
29819 }
29820 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29821 return resultobj;
29822 fail:
29823 return NULL;
29824 }
29825
29826
29827 SWIGINTERN PyObject *_wrap_DateSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29828 PyObject *resultobj = 0;
29829 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29830 wxDateSpan *arg2 = 0 ;
29831 wxDateSpan result;
29832 void *argp1 = 0 ;
29833 int res1 = 0 ;
29834 void *argp2 = 0 ;
29835 int res2 = 0 ;
29836 PyObject * obj0 = 0 ;
29837 PyObject * obj1 = 0 ;
29838 char * kwnames[] = {
29839 (char *) "self",(char *) "other", NULL
29840 };
29841
29842 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
29843 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29844 if (!SWIG_IsOK(res1)) {
29845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___sub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29846 }
29847 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29848 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29849 if (!SWIG_IsOK(res2)) {
29850 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29851 }
29852 if (!argp2) {
29853 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29854 }
29855 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29856 {
29857 PyThreadState* __tstate = wxPyBeginAllowThreads();
29858 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
29859 wxPyEndAllowThreads(__tstate);
29860 if (PyErr_Occurred()) SWIG_fail;
29861 }
29862 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29863 return resultobj;
29864 fail:
29865 return NULL;
29866 }
29867
29868
29869 SWIGINTERN PyObject *_wrap_DateSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29870 PyObject *resultobj = 0;
29871 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29872 int arg2 ;
29873 wxDateSpan result;
29874 void *argp1 = 0 ;
29875 int res1 = 0 ;
29876 int val2 ;
29877 int ecode2 = 0 ;
29878 PyObject * obj0 = 0 ;
29879 PyObject * obj1 = 0 ;
29880 char * kwnames[] = {
29881 (char *) "self",(char *) "n", NULL
29882 };
29883
29884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
29885 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29886 if (!SWIG_IsOK(res1)) {
29887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___mul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29888 }
29889 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29890 ecode2 = SWIG_AsVal_int(obj1, &val2);
29891 if (!SWIG_IsOK(ecode2)) {
29892 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___mul__" "', expected argument " "2"" of type '" "int""'");
29893 }
29894 arg2 = static_cast< int >(val2);
29895 {
29896 PyThreadState* __tstate = wxPyBeginAllowThreads();
29897 result = wxDateSpan___mul__(arg1,arg2);
29898 wxPyEndAllowThreads(__tstate);
29899 if (PyErr_Occurred()) SWIG_fail;
29900 }
29901 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29902 return resultobj;
29903 fail:
29904 return NULL;
29905 }
29906
29907
29908 SWIGINTERN PyObject *_wrap_DateSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29909 PyObject *resultobj = 0;
29910 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29911 int arg2 ;
29912 wxDateSpan result;
29913 void *argp1 = 0 ;
29914 int res1 = 0 ;
29915 int val2 ;
29916 int ecode2 = 0 ;
29917 PyObject * obj0 = 0 ;
29918 PyObject * obj1 = 0 ;
29919 char * kwnames[] = {
29920 (char *) "self",(char *) "n", NULL
29921 };
29922
29923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
29924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29925 if (!SWIG_IsOK(res1)) {
29926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___rmul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29927 }
29928 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29929 ecode2 = SWIG_AsVal_int(obj1, &val2);
29930 if (!SWIG_IsOK(ecode2)) {
29931 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
29932 }
29933 arg2 = static_cast< int >(val2);
29934 {
29935 PyThreadState* __tstate = wxPyBeginAllowThreads();
29936 result = wxDateSpan___rmul__(arg1,arg2);
29937 wxPyEndAllowThreads(__tstate);
29938 if (PyErr_Occurred()) SWIG_fail;
29939 }
29940 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29941 return resultobj;
29942 fail:
29943 return NULL;
29944 }
29945
29946
29947 SWIGINTERN PyObject *_wrap_DateSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29948 PyObject *resultobj = 0;
29949 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29950 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
29951 bool result;
29952 void *argp1 = 0 ;
29953 int res1 = 0 ;
29954 void *argp2 = 0 ;
29955 int res2 = 0 ;
29956 PyObject * obj0 = 0 ;
29957 PyObject * obj1 = 0 ;
29958 char * kwnames[] = {
29959 (char *) "self",(char *) "other", NULL
29960 };
29961
29962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
29963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29964 if (!SWIG_IsOK(res1)) {
29965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___eq__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29966 }
29967 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29968 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29969 if (!SWIG_IsOK(res2)) {
29970 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___eq__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
29971 }
29972 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29973 {
29974 PyThreadState* __tstate = wxPyBeginAllowThreads();
29975 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
29976 wxPyEndAllowThreads(__tstate);
29977 if (PyErr_Occurred()) SWIG_fail;
29978 }
29979 {
29980 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29981 }
29982 return resultobj;
29983 fail:
29984 return NULL;
29985 }
29986
29987
29988 SWIGINTERN PyObject *_wrap_DateSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29989 PyObject *resultobj = 0;
29990 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29991 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
29992 bool result;
29993 void *argp1 = 0 ;
29994 int res1 = 0 ;
29995 void *argp2 = 0 ;
29996 int res2 = 0 ;
29997 PyObject * obj0 = 0 ;
29998 PyObject * obj1 = 0 ;
29999 char * kwnames[] = {
30000 (char *) "self",(char *) "other", NULL
30001 };
30002
30003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
30004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30005 if (!SWIG_IsOK(res1)) {
30006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___ne__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30007 }
30008 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30009 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30010 if (!SWIG_IsOK(res2)) {
30011 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___ne__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
30012 }
30013 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30014 {
30015 PyThreadState* __tstate = wxPyBeginAllowThreads();
30016 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
30017 wxPyEndAllowThreads(__tstate);
30018 if (PyErr_Occurred()) SWIG_fail;
30019 }
30020 {
30021 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30022 }
30023 return resultobj;
30024 fail:
30025 return NULL;
30026 }
30027
30028
30029 SWIGINTERN PyObject *DateSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30030 PyObject *obj;
30031 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30032 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateSpan, SWIG_NewClientData(obj));
30033 return SWIG_Py_Void();
30034 }
30035
30036 SWIGINTERN PyObject *DateSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30037 return SWIG_Python_InitShadowInstance(args);
30038 }
30039
30040 SWIGINTERN PyObject *_wrap_GetLocalTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30041 PyObject *resultobj = 0;
30042 long result;
30043
30044 if (!SWIG_Python_UnpackTuple(args,"GetLocalTime",0,0,0)) SWIG_fail;
30045 {
30046 PyThreadState* __tstate = wxPyBeginAllowThreads();
30047 result = (long)wxGetLocalTime();
30048 wxPyEndAllowThreads(__tstate);
30049 if (PyErr_Occurred()) SWIG_fail;
30050 }
30051 resultobj = SWIG_From_long(static_cast< long >(result));
30052 return resultobj;
30053 fail:
30054 return NULL;
30055 }
30056
30057
30058 SWIGINTERN PyObject *_wrap_GetUTCTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30059 PyObject *resultobj = 0;
30060 long result;
30061
30062 if (!SWIG_Python_UnpackTuple(args,"GetUTCTime",0,0,0)) SWIG_fail;
30063 {
30064 PyThreadState* __tstate = wxPyBeginAllowThreads();
30065 result = (long)wxGetUTCTime();
30066 wxPyEndAllowThreads(__tstate);
30067 if (PyErr_Occurred()) SWIG_fail;
30068 }
30069 resultobj = SWIG_From_long(static_cast< long >(result));
30070 return resultobj;
30071 fail:
30072 return NULL;
30073 }
30074
30075
30076 SWIGINTERN PyObject *_wrap_GetCurrentTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30077 PyObject *resultobj = 0;
30078 long result;
30079
30080 if (!SWIG_Python_UnpackTuple(args,"GetCurrentTime",0,0,0)) SWIG_fail;
30081 {
30082 PyThreadState* __tstate = wxPyBeginAllowThreads();
30083 result = (long)wxGetCurrentTime();
30084 wxPyEndAllowThreads(__tstate);
30085 if (PyErr_Occurred()) SWIG_fail;
30086 }
30087 resultobj = SWIG_From_long(static_cast< long >(result));
30088 return resultobj;
30089 fail:
30090 return NULL;
30091 }
30092
30093
30094 SWIGINTERN PyObject *_wrap_GetLocalTimeMillis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30095 PyObject *resultobj = 0;
30096 wxLongLong result;
30097
30098 if (!SWIG_Python_UnpackTuple(args,"GetLocalTimeMillis",0,0,0)) SWIG_fail;
30099 {
30100 PyThreadState* __tstate = wxPyBeginAllowThreads();
30101 result = wxGetLocalTimeMillis();
30102 wxPyEndAllowThreads(__tstate);
30103 if (PyErr_Occurred()) SWIG_fail;
30104 }
30105 {
30106 PyObject *hi, *lo, *shifter, *shifted;
30107 hi = PyLong_FromLong( (&result)->GetHi() );
30108 lo = PyLong_FromLong( (&result)->GetLo() );
30109 shifter = PyLong_FromLong(32);
30110 shifted = PyNumber_Lshift(hi, shifter);
30111 resultobj = PyNumber_Or(shifted, lo);
30112 Py_DECREF(hi);
30113 Py_DECREF(lo);
30114 Py_DECREF(shifter);
30115 Py_DECREF(shifted);
30116 }
30117 return resultobj;
30118 fail:
30119 return NULL;
30120 }
30121
30122
30123 SWIGINTERN int DefaultDateTime_set(PyObject *) {
30124 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTime is read-only.");
30125 return 1;
30126 }
30127
30128
30129 SWIGINTERN PyObject *DefaultDateTime_get(void) {
30130 PyObject *pyobj = 0;
30131
30132 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0 );
30133 return pyobj;
30134 }
30135
30136
30137 SWIGINTERN PyObject *_wrap_new_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30138 PyObject *resultobj = 0;
30139 wxDataFormatId arg1 ;
30140 wxDataFormat *result = 0 ;
30141 int val1 ;
30142 int ecode1 = 0 ;
30143 PyObject * obj0 = 0 ;
30144 char * kwnames[] = {
30145 (char *) "type", NULL
30146 };
30147
30148 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) SWIG_fail;
30149 ecode1 = SWIG_AsVal_int(obj0, &val1);
30150 if (!SWIG_IsOK(ecode1)) {
30151 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DataFormat" "', expected argument " "1"" of type '" "wxDataFormatId""'");
30152 }
30153 arg1 = static_cast< wxDataFormatId >(val1);
30154 {
30155 PyThreadState* __tstate = wxPyBeginAllowThreads();
30156 result = (wxDataFormat *)new wxDataFormat(arg1);
30157 wxPyEndAllowThreads(__tstate);
30158 if (PyErr_Occurred()) SWIG_fail;
30159 }
30160 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_NEW | 0 );
30161 return resultobj;
30162 fail:
30163 return NULL;
30164 }
30165
30166
30167 SWIGINTERN PyObject *_wrap_new_CustomDataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30168 PyObject *resultobj = 0;
30169 wxString *arg1 = 0 ;
30170 wxDataFormat *result = 0 ;
30171 bool temp1 = false ;
30172 PyObject * obj0 = 0 ;
30173 char * kwnames[] = {
30174 (char *) "format", NULL
30175 };
30176
30177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) SWIG_fail;
30178 {
30179 arg1 = wxString_in_helper(obj0);
30180 if (arg1 == NULL) SWIG_fail;
30181 temp1 = true;
30182 }
30183 {
30184 PyThreadState* __tstate = wxPyBeginAllowThreads();
30185 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
30186 wxPyEndAllowThreads(__tstate);
30187 if (PyErr_Occurred()) SWIG_fail;
30188 }
30189 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
30190 {
30191 if (temp1)
30192 delete arg1;
30193 }
30194 return resultobj;
30195 fail:
30196 {
30197 if (temp1)
30198 delete arg1;
30199 }
30200 return NULL;
30201 }
30202
30203
30204 SWIGINTERN PyObject *_wrap_delete_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30205 PyObject *resultobj = 0;
30206 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30207 void *argp1 = 0 ;
30208 int res1 = 0 ;
30209 PyObject *swig_obj[1] ;
30210
30211 if (!args) SWIG_fail;
30212 swig_obj[0] = args;
30213 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, SWIG_POINTER_DISOWN | 0 );
30214 if (!SWIG_IsOK(res1)) {
30215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataFormat" "', expected argument " "1"" of type '" "wxDataFormat *""'");
30216 }
30217 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30218 {
30219 PyThreadState* __tstate = wxPyBeginAllowThreads();
30220 delete arg1;
30221
30222 wxPyEndAllowThreads(__tstate);
30223 if (PyErr_Occurred()) SWIG_fail;
30224 }
30225 resultobj = SWIG_Py_Void();
30226 return resultobj;
30227 fail:
30228 return NULL;
30229 }
30230
30231
30232 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
30233 PyObject *resultobj = 0;
30234 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30235 wxDataFormatId arg2 ;
30236 bool result;
30237 void *argp1 = 0 ;
30238 int res1 = 0 ;
30239 int val2 ;
30240 int ecode2 = 0 ;
30241
30242 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30243 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30244 if (!SWIG_IsOK(res1)) {
30245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30246 }
30247 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30248 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
30249 if (!SWIG_IsOK(ecode2)) {
30250 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
30251 }
30252 arg2 = static_cast< wxDataFormatId >(val2);
30253 {
30254 PyThreadState* __tstate = wxPyBeginAllowThreads();
30255 result = (bool)((wxDataFormat const *)arg1)->operator ==(arg2);
30256 wxPyEndAllowThreads(__tstate);
30257 if (PyErr_Occurred()) SWIG_fail;
30258 }
30259 {
30260 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30261 }
30262 return resultobj;
30263 fail:
30264 return NULL;
30265 }
30266
30267
30268 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
30269 PyObject *resultobj = 0;
30270 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30271 wxDataFormatId arg2 ;
30272 bool result;
30273 void *argp1 = 0 ;
30274 int res1 = 0 ;
30275 int val2 ;
30276 int ecode2 = 0 ;
30277
30278 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30279 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30280 if (!SWIG_IsOK(res1)) {
30281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30282 }
30283 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30284 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
30285 if (!SWIG_IsOK(ecode2)) {
30286 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
30287 }
30288 arg2 = static_cast< wxDataFormatId >(val2);
30289 {
30290 PyThreadState* __tstate = wxPyBeginAllowThreads();
30291 result = (bool)((wxDataFormat const *)arg1)->operator !=(arg2);
30292 wxPyEndAllowThreads(__tstate);
30293 if (PyErr_Occurred()) SWIG_fail;
30294 }
30295 {
30296 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30297 }
30298 return resultobj;
30299 fail:
30300 return NULL;
30301 }
30302
30303
30304 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
30305 PyObject *resultobj = 0;
30306 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30307 wxDataFormat *arg2 = 0 ;
30308 bool result;
30309 void *argp1 = 0 ;
30310 int res1 = 0 ;
30311 void *argp2 = 0 ;
30312 int res2 = 0 ;
30313
30314 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30315 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30316 if (!SWIG_IsOK(res1)) {
30317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30318 }
30319 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30320 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30321 if (!SWIG_IsOK(res2)) {
30322 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30323 }
30324 if (!argp2) {
30325 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30326 }
30327 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30328 {
30329 PyThreadState* __tstate = wxPyBeginAllowThreads();
30330 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
30331 wxPyEndAllowThreads(__tstate);
30332 if (PyErr_Occurred()) SWIG_fail;
30333 }
30334 {
30335 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30336 }
30337 return resultobj;
30338 fail:
30339 return NULL;
30340 }
30341
30342
30343 SWIGINTERN PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
30344 int argc;
30345 PyObject *argv[3];
30346
30347 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___eq__",0,2,argv))) SWIG_fail;
30348 --argc;
30349 if (argc == 2) {
30350 int _v = 0;
30351 {
30352 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
30353 _v = SWIG_CheckState(res);
30354 }
30355 if (!_v) goto check_1;
30356 return _wrap_DataFormat___eq____SWIG_1(self, argc, argv);
30357 }
30358 check_1:
30359
30360 if (argc == 2) {
30361 return _wrap_DataFormat___eq____SWIG_0(self, argc, argv);
30362 }
30363
30364 fail:
30365 Py_INCREF(Py_NotImplemented);
30366 return Py_NotImplemented;
30367 }
30368
30369
30370 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
30371 PyObject *resultobj = 0;
30372 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30373 wxDataFormat *arg2 = 0 ;
30374 bool result;
30375 void *argp1 = 0 ;
30376 int res1 = 0 ;
30377 void *argp2 = 0 ;
30378 int res2 = 0 ;
30379
30380 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30382 if (!SWIG_IsOK(res1)) {
30383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30384 }
30385 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30386 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30387 if (!SWIG_IsOK(res2)) {
30388 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30389 }
30390 if (!argp2) {
30391 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30392 }
30393 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30394 {
30395 PyThreadState* __tstate = wxPyBeginAllowThreads();
30396 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
30397 wxPyEndAllowThreads(__tstate);
30398 if (PyErr_Occurred()) SWIG_fail;
30399 }
30400 {
30401 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30402 }
30403 return resultobj;
30404 fail:
30405 return NULL;
30406 }
30407
30408
30409 SWIGINTERN PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
30410 int argc;
30411 PyObject *argv[3];
30412
30413 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___ne__",0,2,argv))) SWIG_fail;
30414 --argc;
30415 if (argc == 2) {
30416 int _v = 0;
30417 {
30418 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
30419 _v = SWIG_CheckState(res);
30420 }
30421 if (!_v) goto check_1;
30422 return _wrap_DataFormat___ne____SWIG_1(self, argc, argv);
30423 }
30424 check_1:
30425
30426 if (argc == 2) {
30427 return _wrap_DataFormat___ne____SWIG_0(self, argc, argv);
30428 }
30429
30430 fail:
30431 Py_INCREF(Py_NotImplemented);
30432 return Py_NotImplemented;
30433 }
30434
30435
30436 SWIGINTERN PyObject *_wrap_DataFormat_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30437 PyObject *resultobj = 0;
30438 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30439 wxDataFormatId arg2 ;
30440 void *argp1 = 0 ;
30441 int res1 = 0 ;
30442 int val2 ;
30443 int ecode2 = 0 ;
30444 PyObject * obj0 = 0 ;
30445 PyObject * obj1 = 0 ;
30446 char * kwnames[] = {
30447 (char *) "self",(char *) "format", NULL
30448 };
30449
30450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
30451 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30452 if (!SWIG_IsOK(res1)) {
30453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetType" "', expected argument " "1"" of type '" "wxDataFormat *""'");
30454 }
30455 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30456 ecode2 = SWIG_AsVal_int(obj1, &val2);
30457 if (!SWIG_IsOK(ecode2)) {
30458 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat_SetType" "', expected argument " "2"" of type '" "wxDataFormatId""'");
30459 }
30460 arg2 = static_cast< wxDataFormatId >(val2);
30461 {
30462 PyThreadState* __tstate = wxPyBeginAllowThreads();
30463 (arg1)->SetType(arg2);
30464 wxPyEndAllowThreads(__tstate);
30465 if (PyErr_Occurred()) SWIG_fail;
30466 }
30467 resultobj = SWIG_Py_Void();
30468 return resultobj;
30469 fail:
30470 return NULL;
30471 }
30472
30473
30474 SWIGINTERN PyObject *_wrap_DataFormat_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30475 PyObject *resultobj = 0;
30476 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30477 wxDataFormatId result;
30478 void *argp1 = 0 ;
30479 int res1 = 0 ;
30480 PyObject *swig_obj[1] ;
30481
30482 if (!args) SWIG_fail;
30483 swig_obj[0] = args;
30484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30485 if (!SWIG_IsOK(res1)) {
30486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetType" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30487 }
30488 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30489 {
30490 PyThreadState* __tstate = wxPyBeginAllowThreads();
30491 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
30492 wxPyEndAllowThreads(__tstate);
30493 if (PyErr_Occurred()) SWIG_fail;
30494 }
30495 resultobj = SWIG_From_int(static_cast< int >(result));
30496 return resultobj;
30497 fail:
30498 return NULL;
30499 }
30500
30501
30502 SWIGINTERN PyObject *_wrap_DataFormat_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30503 PyObject *resultobj = 0;
30504 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30505 wxString result;
30506 void *argp1 = 0 ;
30507 int res1 = 0 ;
30508 PyObject *swig_obj[1] ;
30509
30510 if (!args) SWIG_fail;
30511 swig_obj[0] = args;
30512 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30513 if (!SWIG_IsOK(res1)) {
30514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetId" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30515 }
30516 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30517 {
30518 PyThreadState* __tstate = wxPyBeginAllowThreads();
30519 result = ((wxDataFormat const *)arg1)->GetId();
30520 wxPyEndAllowThreads(__tstate);
30521 if (PyErr_Occurred()) SWIG_fail;
30522 }
30523 {
30524 #if wxUSE_UNICODE
30525 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30526 #else
30527 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30528 #endif
30529 }
30530 return resultobj;
30531 fail:
30532 return NULL;
30533 }
30534
30535
30536 SWIGINTERN PyObject *_wrap_DataFormat_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30537 PyObject *resultobj = 0;
30538 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30539 wxString *arg2 = 0 ;
30540 void *argp1 = 0 ;
30541 int res1 = 0 ;
30542 bool temp2 = false ;
30543 PyObject * obj0 = 0 ;
30544 PyObject * obj1 = 0 ;
30545 char * kwnames[] = {
30546 (char *) "self",(char *) "format", NULL
30547 };
30548
30549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
30550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30551 if (!SWIG_IsOK(res1)) {
30552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetId" "', expected argument " "1"" of type '" "wxDataFormat *""'");
30553 }
30554 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30555 {
30556 arg2 = wxString_in_helper(obj1);
30557 if (arg2 == NULL) SWIG_fail;
30558 temp2 = true;
30559 }
30560 {
30561 PyThreadState* __tstate = wxPyBeginAllowThreads();
30562 (arg1)->SetId((wxString const &)*arg2);
30563 wxPyEndAllowThreads(__tstate);
30564 if (PyErr_Occurred()) SWIG_fail;
30565 }
30566 resultobj = SWIG_Py_Void();
30567 {
30568 if (temp2)
30569 delete arg2;
30570 }
30571 return resultobj;
30572 fail:
30573 {
30574 if (temp2)
30575 delete arg2;
30576 }
30577 return NULL;
30578 }
30579
30580
30581 SWIGINTERN PyObject *DataFormat_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30582 PyObject *obj;
30583 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30584 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataFormat, SWIG_NewClientData(obj));
30585 return SWIG_Py_Void();
30586 }
30587
30588 SWIGINTERN PyObject *DataFormat_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30589 return SWIG_Python_InitShadowInstance(args);
30590 }
30591
30592 SWIGINTERN int FormatInvalid_set(PyObject *) {
30593 SWIG_Error(SWIG_AttributeError,"Variable FormatInvalid is read-only.");
30594 return 1;
30595 }
30596
30597
30598 SWIGINTERN PyObject *FormatInvalid_get(void) {
30599 PyObject *pyobj = 0;
30600
30601 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0 );
30602 return pyobj;
30603 }
30604
30605
30606 SWIGINTERN PyObject *_wrap_delete_DataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30607 PyObject *resultobj = 0;
30608 wxDataObject *arg1 = (wxDataObject *) 0 ;
30609 void *argp1 = 0 ;
30610 int res1 = 0 ;
30611 PyObject *swig_obj[1] ;
30612
30613 if (!args) SWIG_fail;
30614 swig_obj[0] = args;
30615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
30616 if (!SWIG_IsOK(res1)) {
30617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataObject" "', expected argument " "1"" of type '" "wxDataObject *""'");
30618 }
30619 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30620 {
30621 PyThreadState* __tstate = wxPyBeginAllowThreads();
30622 delete arg1;
30623
30624 wxPyEndAllowThreads(__tstate);
30625 if (PyErr_Occurred()) SWIG_fail;
30626 }
30627 resultobj = SWIG_Py_Void();
30628 return resultobj;
30629 fail:
30630 return NULL;
30631 }
30632
30633
30634 SWIGINTERN PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30635 PyObject *resultobj = 0;
30636 wxDataObject *arg1 = (wxDataObject *) 0 ;
30637 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
30638 SwigValueWrapper<wxDataFormat > result;
30639 void *argp1 = 0 ;
30640 int res1 = 0 ;
30641 int val2 ;
30642 int ecode2 = 0 ;
30643 PyObject * obj0 = 0 ;
30644 PyObject * obj1 = 0 ;
30645 char * kwnames[] = {
30646 (char *) "self",(char *) "dir", NULL
30647 };
30648
30649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) SWIG_fail;
30650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30651 if (!SWIG_IsOK(res1)) {
30652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "1"" of type '" "wxDataObject const *""'");
30653 }
30654 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30655 if (obj1) {
30656 ecode2 = SWIG_AsVal_int(obj1, &val2);
30657 if (!SWIG_IsOK(ecode2)) {
30658 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
30659 }
30660 arg2 = static_cast< wxDataObject::Direction >(val2);
30661 }
30662 {
30663 PyThreadState* __tstate = wxPyBeginAllowThreads();
30664 result = ((wxDataObject const *)arg1)->GetPreferredFormat(arg2);
30665 wxPyEndAllowThreads(__tstate);
30666 if (PyErr_Occurred()) SWIG_fail;
30667 }
30668 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
30669 return resultobj;
30670 fail:
30671 return NULL;
30672 }
30673
30674
30675 SWIGINTERN PyObject *_wrap_DataObject_GetFormatCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30676 PyObject *resultobj = 0;
30677 wxDataObject *arg1 = (wxDataObject *) 0 ;
30678 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
30679 size_t result;
30680 void *argp1 = 0 ;
30681 int res1 = 0 ;
30682 int val2 ;
30683 int ecode2 = 0 ;
30684 PyObject * obj0 = 0 ;
30685 PyObject * obj1 = 0 ;
30686 char * kwnames[] = {
30687 (char *) "self",(char *) "dir", NULL
30688 };
30689
30690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) SWIG_fail;
30691 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30692 if (!SWIG_IsOK(res1)) {
30693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetFormatCount" "', expected argument " "1"" of type '" "wxDataObject const *""'");
30694 }
30695 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30696 if (obj1) {
30697 ecode2 = SWIG_AsVal_int(obj1, &val2);
30698 if (!SWIG_IsOK(ecode2)) {
30699 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetFormatCount" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
30700 }
30701 arg2 = static_cast< wxDataObject::Direction >(val2);
30702 }
30703 {
30704 PyThreadState* __tstate = wxPyBeginAllowThreads();
30705 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount(arg2);
30706 wxPyEndAllowThreads(__tstate);
30707 if (PyErr_Occurred()) SWIG_fail;
30708 }
30709 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
30710 return resultobj;
30711 fail:
30712 return NULL;
30713 }
30714
30715
30716 SWIGINTERN PyObject *_wrap_DataObject_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30717 PyObject *resultobj = 0;
30718 wxDataObject *arg1 = (wxDataObject *) 0 ;
30719 wxDataFormat *arg2 = 0 ;
30720 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
30721 bool result;
30722 void *argp1 = 0 ;
30723 int res1 = 0 ;
30724 void *argp2 = 0 ;
30725 int res2 = 0 ;
30726 int val3 ;
30727 int ecode3 = 0 ;
30728 PyObject * obj0 = 0 ;
30729 PyObject * obj1 = 0 ;
30730 PyObject * obj2 = 0 ;
30731 char * kwnames[] = {
30732 (char *) "self",(char *) "format",(char *) "dir", NULL
30733 };
30734
30735 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30736 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30737 if (!SWIG_IsOK(res1)) {
30738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_IsSupported" "', expected argument " "1"" of type '" "wxDataObject const *""'");
30739 }
30740 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30741 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30742 if (!SWIG_IsOK(res2)) {
30743 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30744 }
30745 if (!argp2) {
30746 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30747 }
30748 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30749 if (obj2) {
30750 ecode3 = SWIG_AsVal_int(obj2, &val3);
30751 if (!SWIG_IsOK(ecode3)) {
30752 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObject_IsSupported" "', expected argument " "3"" of type '" "wxDataObject::Direction""'");
30753 }
30754 arg3 = static_cast< wxDataObject::Direction >(val3);
30755 }
30756 {
30757 PyThreadState* __tstate = wxPyBeginAllowThreads();
30758 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,arg3);
30759 wxPyEndAllowThreads(__tstate);
30760 if (PyErr_Occurred()) SWIG_fail;
30761 }
30762 {
30763 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30764 }
30765 return resultobj;
30766 fail:
30767 return NULL;
30768 }
30769
30770
30771 SWIGINTERN PyObject *_wrap_DataObject_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30772 PyObject *resultobj = 0;
30773 wxDataObject *arg1 = (wxDataObject *) 0 ;
30774 wxDataFormat *arg2 = 0 ;
30775 size_t result;
30776 void *argp1 = 0 ;
30777 int res1 = 0 ;
30778 void *argp2 = 0 ;
30779 int res2 = 0 ;
30780 PyObject * obj0 = 0 ;
30781 PyObject * obj1 = 0 ;
30782 char * kwnames[] = {
30783 (char *) "self",(char *) "format", NULL
30784 };
30785
30786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) SWIG_fail;
30787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30788 if (!SWIG_IsOK(res1)) {
30789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataSize" "', expected argument " "1"" of type '" "wxDataObject const *""'");
30790 }
30791 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30792 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30793 if (!SWIG_IsOK(res2)) {
30794 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30795 }
30796 if (!argp2) {
30797 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30798 }
30799 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30800 {
30801 PyThreadState* __tstate = wxPyBeginAllowThreads();
30802 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
30803 wxPyEndAllowThreads(__tstate);
30804 if (PyErr_Occurred()) SWIG_fail;
30805 }
30806 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
30807 return resultobj;
30808 fail:
30809 return NULL;
30810 }
30811
30812
30813 SWIGINTERN PyObject *_wrap_DataObject_GetAllFormats(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30814 PyObject *resultobj = 0;
30815 wxDataObject *arg1 = (wxDataObject *) 0 ;
30816 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
30817 PyObject *result = 0 ;
30818 void *argp1 = 0 ;
30819 int res1 = 0 ;
30820 int val2 ;
30821 int ecode2 = 0 ;
30822 PyObject * obj0 = 0 ;
30823 PyObject * obj1 = 0 ;
30824 char * kwnames[] = {
30825 (char *) "self",(char *) "dir", NULL
30826 };
30827
30828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) SWIG_fail;
30829 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30830 if (!SWIG_IsOK(res1)) {
30831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetAllFormats" "', expected argument " "1"" of type '" "wxDataObject *""'");
30832 }
30833 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30834 if (obj1) {
30835 ecode2 = SWIG_AsVal_int(obj1, &val2);
30836 if (!SWIG_IsOK(ecode2)) {
30837 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetAllFormats" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
30838 }
30839 arg2 = static_cast< wxDataObject::Direction >(val2);
30840 }
30841 {
30842 PyThreadState* __tstate = wxPyBeginAllowThreads();
30843 result = (PyObject *)wxDataObject_GetAllFormats(arg1,arg2);
30844 wxPyEndAllowThreads(__tstate);
30845 if (PyErr_Occurred()) SWIG_fail;
30846 }
30847 resultobj = result;
30848 return resultobj;
30849 fail:
30850 return NULL;
30851 }
30852
30853
30854 SWIGINTERN PyObject *_wrap_DataObject_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30855 PyObject *resultobj = 0;
30856 wxDataObject *arg1 = (wxDataObject *) 0 ;
30857 wxDataFormat *arg2 = 0 ;
30858 PyObject *result = 0 ;
30859 void *argp1 = 0 ;
30860 int res1 = 0 ;
30861 void *argp2 = 0 ;
30862 int res2 = 0 ;
30863 PyObject * obj0 = 0 ;
30864 PyObject * obj1 = 0 ;
30865 char * kwnames[] = {
30866 (char *) "self",(char *) "format", NULL
30867 };
30868
30869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) SWIG_fail;
30870 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30871 if (!SWIG_IsOK(res1)) {
30872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataHere" "', expected argument " "1"" of type '" "wxDataObject *""'");
30873 }
30874 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30875 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30876 if (!SWIG_IsOK(res2)) {
30877 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30878 }
30879 if (!argp2) {
30880 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30881 }
30882 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30883 {
30884 PyThreadState* __tstate = wxPyBeginAllowThreads();
30885 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
30886 wxPyEndAllowThreads(__tstate);
30887 if (PyErr_Occurred()) SWIG_fail;
30888 }
30889 resultobj = result;
30890 return resultobj;
30891 fail:
30892 return NULL;
30893 }
30894
30895
30896 SWIGINTERN PyObject *_wrap_DataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30897 PyObject *resultobj = 0;
30898 wxDataObject *arg1 = (wxDataObject *) 0 ;
30899 wxDataFormat *arg2 = 0 ;
30900 PyObject *arg3 = (PyObject *) 0 ;
30901 bool result;
30902 void *argp1 = 0 ;
30903 int res1 = 0 ;
30904 void *argp2 = 0 ;
30905 int res2 = 0 ;
30906 PyObject * obj0 = 0 ;
30907 PyObject * obj1 = 0 ;
30908 PyObject * obj2 = 0 ;
30909 char * kwnames[] = {
30910 (char *) "self",(char *) "format",(char *) "data", NULL
30911 };
30912
30913 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30914 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30915 if (!SWIG_IsOK(res1)) {
30916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_SetData" "', expected argument " "1"" of type '" "wxDataObject *""'");
30917 }
30918 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30919 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30920 if (!SWIG_IsOK(res2)) {
30921 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30922 }
30923 if (!argp2) {
30924 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30925 }
30926 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30927 arg3 = obj2;
30928 {
30929 PyThreadState* __tstate = wxPyBeginAllowThreads();
30930 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
30931 wxPyEndAllowThreads(__tstate);
30932 if (PyErr_Occurred()) SWIG_fail;
30933 }
30934 {
30935 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30936 }
30937 return resultobj;
30938 fail:
30939 return NULL;
30940 }
30941
30942
30943 SWIGINTERN PyObject *DataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30944 PyObject *obj;
30945 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30946 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObject, SWIG_NewClientData(obj));
30947 return SWIG_Py_Void();
30948 }
30949
30950 SWIGINTERN PyObject *_wrap_new_DataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30951 PyObject *resultobj = 0;
30952 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
30953 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
30954 wxDataObjectSimple *result = 0 ;
30955 void *argp1 = 0 ;
30956 int res1 = 0 ;
30957 PyObject * obj0 = 0 ;
30958 char * kwnames[] = {
30959 (char *) "format", NULL
30960 };
30961
30962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) SWIG_fail;
30963 if (obj0) {
30964 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
30965 if (!SWIG_IsOK(res1)) {
30966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
30967 }
30968 if (!argp1) {
30969 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
30970 }
30971 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30972 }
30973 {
30974 PyThreadState* __tstate = wxPyBeginAllowThreads();
30975 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
30976 wxPyEndAllowThreads(__tstate);
30977 if (PyErr_Occurred()) SWIG_fail;
30978 }
30979 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_NEW | 0 );
30980 return resultobj;
30981 fail:
30982 return NULL;
30983 }
30984
30985
30986 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30987 PyObject *resultobj = 0;
30988 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
30989 wxDataFormat *result = 0 ;
30990 void *argp1 = 0 ;
30991 int res1 = 0 ;
30992 PyObject *swig_obj[1] ;
30993
30994 if (!args) SWIG_fail;
30995 swig_obj[0] = args;
30996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
30997 if (!SWIG_IsOK(res1)) {
30998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
30999 }
31000 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31001 {
31002 PyThreadState* __tstate = wxPyBeginAllowThreads();
31003 {
31004 wxDataFormat const &_result_ref = (arg1)->GetFormat();
31005 result = (wxDataFormat *) &_result_ref;
31006 }
31007 wxPyEndAllowThreads(__tstate);
31008 if (PyErr_Occurred()) SWIG_fail;
31009 }
31010 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, 0 | 0 );
31011 return resultobj;
31012 fail:
31013 return NULL;
31014 }
31015
31016
31017 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31018 PyObject *resultobj = 0;
31019 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31020 wxDataFormat *arg2 = 0 ;
31021 void *argp1 = 0 ;
31022 int res1 = 0 ;
31023 void *argp2 = 0 ;
31024 int res2 = 0 ;
31025 PyObject * obj0 = 0 ;
31026 PyObject * obj1 = 0 ;
31027 char * kwnames[] = {
31028 (char *) "self",(char *) "format", NULL
31029 };
31030
31031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) SWIG_fail;
31032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31033 if (!SWIG_IsOK(res1)) {
31034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
31035 }
31036 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31037 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31038 if (!SWIG_IsOK(res2)) {
31039 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31040 }
31041 if (!argp2) {
31042 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31043 }
31044 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31045 {
31046 PyThreadState* __tstate = wxPyBeginAllowThreads();
31047 (arg1)->SetFormat((wxDataFormat const &)*arg2);
31048 wxPyEndAllowThreads(__tstate);
31049 if (PyErr_Occurred()) SWIG_fail;
31050 }
31051 resultobj = SWIG_Py_Void();
31052 return resultobj;
31053 fail:
31054 return NULL;
31055 }
31056
31057
31058 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31059 PyObject *resultobj = 0;
31060 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31061 size_t result;
31062 void *argp1 = 0 ;
31063 int res1 = 0 ;
31064 PyObject *swig_obj[1] ;
31065
31066 if (!args) SWIG_fail;
31067 swig_obj[0] = args;
31068 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31069 if (!SWIG_IsOK(res1)) {
31070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataSize" "', expected argument " "1"" of type '" "wxDataObjectSimple const *""'");
31071 }
31072 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31073 {
31074 PyThreadState* __tstate = wxPyBeginAllowThreads();
31075 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
31076 wxPyEndAllowThreads(__tstate);
31077 if (PyErr_Occurred()) SWIG_fail;
31078 }
31079 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
31080 return resultobj;
31081 fail:
31082 return NULL;
31083 }
31084
31085
31086 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31087 PyObject *resultobj = 0;
31088 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31089 PyObject *result = 0 ;
31090 void *argp1 = 0 ;
31091 int res1 = 0 ;
31092 PyObject *swig_obj[1] ;
31093
31094 if (!args) SWIG_fail;
31095 swig_obj[0] = args;
31096 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31097 if (!SWIG_IsOK(res1)) {
31098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataHere" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
31099 }
31100 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31101 {
31102 PyThreadState* __tstate = wxPyBeginAllowThreads();
31103 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
31104 wxPyEndAllowThreads(__tstate);
31105 if (PyErr_Occurred()) SWIG_fail;
31106 }
31107 resultobj = result;
31108 return resultobj;
31109 fail:
31110 return NULL;
31111 }
31112
31113
31114 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31115 PyObject *resultobj = 0;
31116 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31117 PyObject *arg2 = (PyObject *) 0 ;
31118 bool result;
31119 void *argp1 = 0 ;
31120 int res1 = 0 ;
31121 PyObject * obj0 = 0 ;
31122 PyObject * obj1 = 0 ;
31123 char * kwnames[] = {
31124 (char *) "self",(char *) "data", NULL
31125 };
31126
31127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
31128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31129 if (!SWIG_IsOK(res1)) {
31130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetData" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
31131 }
31132 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31133 arg2 = obj1;
31134 {
31135 PyThreadState* __tstate = wxPyBeginAllowThreads();
31136 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
31137 wxPyEndAllowThreads(__tstate);
31138 if (PyErr_Occurred()) SWIG_fail;
31139 }
31140 {
31141 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31142 }
31143 return resultobj;
31144 fail:
31145 return NULL;
31146 }
31147
31148
31149 SWIGINTERN PyObject *DataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31150 PyObject *obj;
31151 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31152 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectSimple, SWIG_NewClientData(obj));
31153 return SWIG_Py_Void();
31154 }
31155
31156 SWIGINTERN PyObject *DataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31157 return SWIG_Python_InitShadowInstance(args);
31158 }
31159
31160 SWIGINTERN PyObject *_wrap_new_PyDataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31161 PyObject *resultobj = 0;
31162 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
31163 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
31164 wxPyDataObjectSimple *result = 0 ;
31165 void *argp1 = 0 ;
31166 int res1 = 0 ;
31167 PyObject * obj0 = 0 ;
31168 char * kwnames[] = {
31169 (char *) "format", NULL
31170 };
31171
31172 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) SWIG_fail;
31173 if (obj0) {
31174 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
31175 if (!SWIG_IsOK(res1)) {
31176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31177 }
31178 if (!argp1) {
31179 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31180 }
31181 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31182 }
31183 {
31184 PyThreadState* __tstate = wxPyBeginAllowThreads();
31185 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
31186 wxPyEndAllowThreads(__tstate);
31187 if (PyErr_Occurred()) SWIG_fail;
31188 }
31189 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_NEW | 0 );
31190 return resultobj;
31191 fail:
31192 return NULL;
31193 }
31194
31195
31196 SWIGINTERN PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31197 PyObject *resultobj = 0;
31198 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
31199 PyObject *arg2 = (PyObject *) 0 ;
31200 PyObject *arg3 = (PyObject *) 0 ;
31201 void *argp1 = 0 ;
31202 int res1 = 0 ;
31203 PyObject * obj0 = 0 ;
31204 PyObject * obj1 = 0 ;
31205 PyObject * obj2 = 0 ;
31206 char * kwnames[] = {
31207 (char *) "self",(char *) "self",(char *) "_class", NULL
31208 };
31209
31210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDataObjectSimple, 0 | 0 );
31212 if (!SWIG_IsOK(res1)) {
31213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyDataObjectSimple__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDataObjectSimple *""'");
31214 }
31215 arg1 = reinterpret_cast< wxPyDataObjectSimple * >(argp1);
31216 arg2 = obj1;
31217 arg3 = obj2;
31218 {
31219 PyThreadState* __tstate = wxPyBeginAllowThreads();
31220 (arg1)->_setCallbackInfo(arg2,arg3);
31221 wxPyEndAllowThreads(__tstate);
31222 if (PyErr_Occurred()) SWIG_fail;
31223 }
31224 resultobj = SWIG_Py_Void();
31225 return resultobj;
31226 fail:
31227 return NULL;
31228 }
31229
31230
31231 SWIGINTERN PyObject *PyDataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31232 PyObject *obj;
31233 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31234 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDataObjectSimple, SWIG_NewClientData(obj));
31235 return SWIG_Py_Void();
31236 }
31237
31238 SWIGINTERN PyObject *PyDataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31239 return SWIG_Python_InitShadowInstance(args);
31240 }
31241
31242 SWIGINTERN PyObject *_wrap_new_DataObjectComposite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31243 PyObject *resultobj = 0;
31244 wxDataObjectComposite *result = 0 ;
31245
31246 if (!SWIG_Python_UnpackTuple(args,"new_DataObjectComposite",0,0,0)) SWIG_fail;
31247 {
31248 PyThreadState* __tstate = wxPyBeginAllowThreads();
31249 result = (wxDataObjectComposite *)new wxDataObjectComposite();
31250 wxPyEndAllowThreads(__tstate);
31251 if (PyErr_Occurred()) SWIG_fail;
31252 }
31253 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_NEW | 0 );
31254 return resultobj;
31255 fail:
31256 return NULL;
31257 }
31258
31259
31260 SWIGINTERN PyObject *_wrap_DataObjectComposite_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31261 PyObject *resultobj = 0;
31262 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
31263 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
31264 bool arg3 = (bool) false ;
31265 void *argp1 = 0 ;
31266 int res1 = 0 ;
31267 int res2 = 0 ;
31268 bool val3 ;
31269 int ecode3 = 0 ;
31270 PyObject * obj0 = 0 ;
31271 PyObject * obj1 = 0 ;
31272 PyObject * obj2 = 0 ;
31273 char * kwnames[] = {
31274 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
31275 };
31276
31277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
31279 if (!SWIG_IsOK(res1)) {
31280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_Add" "', expected argument " "1"" of type '" "wxDataObjectComposite *""'");
31281 }
31282 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
31283 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_DISOWN | 0 );
31284 if (!SWIG_IsOK(res2)) {
31285 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectComposite_Add" "', expected argument " "2"" of type '" "wxDataObjectSimple *""'");
31286 }
31287 if (obj2) {
31288 ecode3 = SWIG_AsVal_bool(obj2, &val3);
31289 if (!SWIG_IsOK(ecode3)) {
31290 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObjectComposite_Add" "', expected argument " "3"" of type '" "bool""'");
31291 }
31292 arg3 = static_cast< bool >(val3);
31293 }
31294 {
31295 PyThreadState* __tstate = wxPyBeginAllowThreads();
31296 (arg1)->Add(arg2,arg3);
31297 wxPyEndAllowThreads(__tstate);
31298 if (PyErr_Occurred()) SWIG_fail;
31299 }
31300 resultobj = SWIG_Py_Void();
31301 return resultobj;
31302 fail:
31303 return NULL;
31304 }
31305
31306
31307 SWIGINTERN PyObject *DataObjectComposite_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31308 PyObject *obj;
31309 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31310 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectComposite, SWIG_NewClientData(obj));
31311 return SWIG_Py_Void();
31312 }
31313
31314 SWIGINTERN PyObject *DataObjectComposite_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31315 return SWIG_Python_InitShadowInstance(args);
31316 }
31317
31318 SWIGINTERN PyObject *_wrap_new_TextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31319 PyObject *resultobj = 0;
31320 wxString const &arg1_defvalue = wxPyEmptyString ;
31321 wxString *arg1 = (wxString *) &arg1_defvalue ;
31322 wxTextDataObject *result = 0 ;
31323 bool temp1 = false ;
31324 PyObject * obj0 = 0 ;
31325 char * kwnames[] = {
31326 (char *) "text", NULL
31327 };
31328
31329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) SWIG_fail;
31330 if (obj0) {
31331 {
31332 arg1 = wxString_in_helper(obj0);
31333 if (arg1 == NULL) SWIG_fail;
31334 temp1 = true;
31335 }
31336 }
31337 {
31338 PyThreadState* __tstate = wxPyBeginAllowThreads();
31339 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
31340 wxPyEndAllowThreads(__tstate);
31341 if (PyErr_Occurred()) SWIG_fail;
31342 }
31343 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_NEW | 0 );
31344 {
31345 if (temp1)
31346 delete arg1;
31347 }
31348 return resultobj;
31349 fail:
31350 {
31351 if (temp1)
31352 delete arg1;
31353 }
31354 return NULL;
31355 }
31356
31357
31358 SWIGINTERN PyObject *_wrap_TextDataObject_GetTextLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31359 PyObject *resultobj = 0;
31360 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
31361 size_t result;
31362 void *argp1 = 0 ;
31363 int res1 = 0 ;
31364 PyObject *swig_obj[1] ;
31365
31366 if (!args) SWIG_fail;
31367 swig_obj[0] = args;
31368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
31369 if (!SWIG_IsOK(res1)) {
31370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetTextLength" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
31371 }
31372 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
31373 {
31374 PyThreadState* __tstate = wxPyBeginAllowThreads();
31375 result = (size_t)(arg1)->GetTextLength();
31376 wxPyEndAllowThreads(__tstate);
31377 if (PyErr_Occurred()) SWIG_fail;
31378 }
31379 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
31380 return resultobj;
31381 fail:
31382 return NULL;
31383 }
31384
31385
31386 SWIGINTERN PyObject *_wrap_TextDataObject_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31387 PyObject *resultobj = 0;
31388 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
31389 wxString result;
31390 void *argp1 = 0 ;
31391 int res1 = 0 ;
31392 PyObject *swig_obj[1] ;
31393
31394 if (!args) SWIG_fail;
31395 swig_obj[0] = args;
31396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
31397 if (!SWIG_IsOK(res1)) {
31398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
31399 }
31400 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
31401 {
31402 PyThreadState* __tstate = wxPyBeginAllowThreads();
31403 result = (arg1)->GetText();
31404 wxPyEndAllowThreads(__tstate);
31405 if (PyErr_Occurred()) SWIG_fail;
31406 }
31407 {
31408 #if wxUSE_UNICODE
31409 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31410 #else
31411 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31412 #endif
31413 }
31414 return resultobj;
31415 fail:
31416 return NULL;
31417 }
31418
31419
31420 SWIGINTERN PyObject *_wrap_TextDataObject_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31421 PyObject *resultobj = 0;
31422 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
31423 wxString *arg2 = 0 ;
31424 void *argp1 = 0 ;
31425 int res1 = 0 ;
31426 bool temp2 = false ;
31427 PyObject * obj0 = 0 ;
31428 PyObject * obj1 = 0 ;
31429 char * kwnames[] = {
31430 (char *) "self",(char *) "text", NULL
31431 };
31432
31433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
31434 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
31435 if (!SWIG_IsOK(res1)) {
31436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_SetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
31437 }
31438 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
31439 {
31440 arg2 = wxString_in_helper(obj1);
31441 if (arg2 == NULL) SWIG_fail;
31442 temp2 = true;
31443 }
31444 {
31445 PyThreadState* __tstate = wxPyBeginAllowThreads();
31446 (arg1)->SetText((wxString const &)*arg2);
31447 wxPyEndAllowThreads(__tstate);
31448 if (PyErr_Occurred()) SWIG_fail;
31449 }
31450 resultobj = SWIG_Py_Void();
31451 {
31452 if (temp2)
31453 delete arg2;
31454 }
31455 return resultobj;
31456 fail:
31457 {
31458 if (temp2)
31459 delete arg2;
31460 }
31461 return NULL;
31462 }
31463
31464
31465 SWIGINTERN PyObject *TextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31466 PyObject *obj;
31467 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31468 SWIG_TypeNewClientData(SWIGTYPE_p_wxTextDataObject, SWIG_NewClientData(obj));
31469 return SWIG_Py_Void();
31470 }
31471
31472 SWIGINTERN PyObject *TextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31473 return SWIG_Python_InitShadowInstance(args);
31474 }
31475
31476 SWIGINTERN PyObject *_wrap_new_PyTextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31477 PyObject *resultobj = 0;
31478 wxString const &arg1_defvalue = wxPyEmptyString ;
31479 wxString *arg1 = (wxString *) &arg1_defvalue ;
31480 wxPyTextDataObject *result = 0 ;
31481 bool temp1 = false ;
31482 PyObject * obj0 = 0 ;
31483 char * kwnames[] = {
31484 (char *) "text", NULL
31485 };
31486
31487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) SWIG_fail;
31488 if (obj0) {
31489 {
31490 arg1 = wxString_in_helper(obj0);
31491 if (arg1 == NULL) SWIG_fail;
31492 temp1 = true;
31493 }
31494 }
31495 {
31496 PyThreadState* __tstate = wxPyBeginAllowThreads();
31497 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
31498 wxPyEndAllowThreads(__tstate);
31499 if (PyErr_Occurred()) SWIG_fail;
31500 }
31501 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_NEW | 0 );
31502 {
31503 if (temp1)
31504 delete arg1;
31505 }
31506 return resultobj;
31507 fail:
31508 {
31509 if (temp1)
31510 delete arg1;
31511 }
31512 return NULL;
31513 }
31514
31515
31516 SWIGINTERN PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31517 PyObject *resultobj = 0;
31518 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
31519 PyObject *arg2 = (PyObject *) 0 ;
31520 PyObject *arg3 = (PyObject *) 0 ;
31521 void *argp1 = 0 ;
31522 int res1 = 0 ;
31523 PyObject * obj0 = 0 ;
31524 PyObject * obj1 = 0 ;
31525 PyObject * obj2 = 0 ;
31526 char * kwnames[] = {
31527 (char *) "self",(char *) "self",(char *) "_class", NULL
31528 };
31529
31530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDataObject, 0 | 0 );
31532 if (!SWIG_IsOK(res1)) {
31533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTextDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDataObject *""'");
31534 }
31535 arg1 = reinterpret_cast< wxPyTextDataObject * >(argp1);
31536 arg2 = obj1;
31537 arg3 = obj2;
31538 {
31539 PyThreadState* __tstate = wxPyBeginAllowThreads();
31540 (arg1)->_setCallbackInfo(arg2,arg3);
31541 wxPyEndAllowThreads(__tstate);
31542 if (PyErr_Occurred()) SWIG_fail;
31543 }
31544 resultobj = SWIG_Py_Void();
31545 return resultobj;
31546 fail:
31547 return NULL;
31548 }
31549
31550
31551 SWIGINTERN PyObject *PyTextDataObject_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_wxPyTextDataObject, SWIG_NewClientData(obj));
31555 return SWIG_Py_Void();
31556 }
31557
31558 SWIGINTERN PyObject *PyTextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31559 return SWIG_Python_InitShadowInstance(args);
31560 }
31561
31562 SWIGINTERN PyObject *_wrap_new_BitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31563 PyObject *resultobj = 0;
31564 wxBitmap const &arg1_defvalue = wxNullBitmap ;
31565 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
31566 wxBitmapDataObject *result = 0 ;
31567 void *argp1 = 0 ;
31568 int res1 = 0 ;
31569 PyObject * obj0 = 0 ;
31570 char * kwnames[] = {
31571 (char *) "bitmap", NULL
31572 };
31573
31574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) SWIG_fail;
31575 if (obj0) {
31576 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
31577 if (!SWIG_IsOK(res1)) {
31578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
31579 }
31580 if (!argp1) {
31581 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
31582 }
31583 arg1 = reinterpret_cast< wxBitmap * >(argp1);
31584 }
31585 {
31586 PyThreadState* __tstate = wxPyBeginAllowThreads();
31587 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
31588 wxPyEndAllowThreads(__tstate);
31589 if (PyErr_Occurred()) SWIG_fail;
31590 }
31591 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_NEW | 0 );
31592 return resultobj;
31593 fail:
31594 return NULL;
31595 }
31596
31597
31598 SWIGINTERN PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31599 PyObject *resultobj = 0;
31600 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
31601 wxBitmap result;
31602 void *argp1 = 0 ;
31603 int res1 = 0 ;
31604 PyObject *swig_obj[1] ;
31605
31606 if (!args) SWIG_fail;
31607 swig_obj[0] = args;
31608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
31609 if (!SWIG_IsOK(res1)) {
31610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_GetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject const *""'");
31611 }
31612 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
31613 {
31614 PyThreadState* __tstate = wxPyBeginAllowThreads();
31615 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
31616 wxPyEndAllowThreads(__tstate);
31617 if (PyErr_Occurred()) SWIG_fail;
31618 }
31619 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
31620 return resultobj;
31621 fail:
31622 return NULL;
31623 }
31624
31625
31626 SWIGINTERN PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31627 PyObject *resultobj = 0;
31628 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
31629 wxBitmap *arg2 = 0 ;
31630 void *argp1 = 0 ;
31631 int res1 = 0 ;
31632 void *argp2 = 0 ;
31633 int res2 = 0 ;
31634 PyObject * obj0 = 0 ;
31635 PyObject * obj1 = 0 ;
31636 char * kwnames[] = {
31637 (char *) "self",(char *) "bitmap", NULL
31638 };
31639
31640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
31641 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
31642 if (!SWIG_IsOK(res1)) {
31643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject *""'");
31644 }
31645 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
31646 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
31647 if (!SWIG_IsOK(res2)) {
31648 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
31649 }
31650 if (!argp2) {
31651 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
31652 }
31653 arg2 = reinterpret_cast< wxBitmap * >(argp2);
31654 {
31655 PyThreadState* __tstate = wxPyBeginAllowThreads();
31656 (arg1)->SetBitmap((wxBitmap const &)*arg2);
31657 wxPyEndAllowThreads(__tstate);
31658 if (PyErr_Occurred()) SWIG_fail;
31659 }
31660 resultobj = SWIG_Py_Void();
31661 return resultobj;
31662 fail:
31663 return NULL;
31664 }
31665
31666
31667 SWIGINTERN PyObject *BitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31668 PyObject *obj;
31669 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31670 SWIG_TypeNewClientData(SWIGTYPE_p_wxBitmapDataObject, SWIG_NewClientData(obj));
31671 return SWIG_Py_Void();
31672 }
31673
31674 SWIGINTERN PyObject *BitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31675 return SWIG_Python_InitShadowInstance(args);
31676 }
31677
31678 SWIGINTERN PyObject *_wrap_new_PyBitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31679 PyObject *resultobj = 0;
31680 wxBitmap const &arg1_defvalue = wxNullBitmap ;
31681 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
31682 wxPyBitmapDataObject *result = 0 ;
31683 void *argp1 = 0 ;
31684 int res1 = 0 ;
31685 PyObject * obj0 = 0 ;
31686 char * kwnames[] = {
31687 (char *) "bitmap", NULL
31688 };
31689
31690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) SWIG_fail;
31691 if (obj0) {
31692 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
31693 if (!SWIG_IsOK(res1)) {
31694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
31695 }
31696 if (!argp1) {
31697 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
31698 }
31699 arg1 = reinterpret_cast< wxBitmap * >(argp1);
31700 }
31701 {
31702 PyThreadState* __tstate = wxPyBeginAllowThreads();
31703 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
31704 wxPyEndAllowThreads(__tstate);
31705 if (PyErr_Occurred()) SWIG_fail;
31706 }
31707 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_NEW | 0 );
31708 return resultobj;
31709 fail:
31710 return NULL;
31711 }
31712
31713
31714 SWIGINTERN PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31715 PyObject *resultobj = 0;
31716 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
31717 PyObject *arg2 = (PyObject *) 0 ;
31718 PyObject *arg3 = (PyObject *) 0 ;
31719 void *argp1 = 0 ;
31720 int res1 = 0 ;
31721 PyObject * obj0 = 0 ;
31722 PyObject * obj1 = 0 ;
31723 PyObject * obj2 = 0 ;
31724 char * kwnames[] = {
31725 (char *) "self",(char *) "self",(char *) "_class", NULL
31726 };
31727
31728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31729 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyBitmapDataObject, 0 | 0 );
31730 if (!SWIG_IsOK(res1)) {
31731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyBitmapDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyBitmapDataObject *""'");
31732 }
31733 arg1 = reinterpret_cast< wxPyBitmapDataObject * >(argp1);
31734 arg2 = obj1;
31735 arg3 = obj2;
31736 {
31737 PyThreadState* __tstate = wxPyBeginAllowThreads();
31738 (arg1)->_setCallbackInfo(arg2,arg3);
31739 wxPyEndAllowThreads(__tstate);
31740 if (PyErr_Occurred()) SWIG_fail;
31741 }
31742 resultobj = SWIG_Py_Void();
31743 return resultobj;
31744 fail:
31745 return NULL;
31746 }
31747
31748
31749 SWIGINTERN PyObject *PyBitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31750 PyObject *obj;
31751 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31752 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyBitmapDataObject, SWIG_NewClientData(obj));
31753 return SWIG_Py_Void();
31754 }
31755
31756 SWIGINTERN PyObject *PyBitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31757 return SWIG_Python_InitShadowInstance(args);
31758 }
31759
31760 SWIGINTERN PyObject *_wrap_new_FileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31761 PyObject *resultobj = 0;
31762 wxFileDataObject *result = 0 ;
31763
31764 if (!SWIG_Python_UnpackTuple(args,"new_FileDataObject",0,0,0)) SWIG_fail;
31765 {
31766 PyThreadState* __tstate = wxPyBeginAllowThreads();
31767 result = (wxFileDataObject *)new wxFileDataObject();
31768 wxPyEndAllowThreads(__tstate);
31769 if (PyErr_Occurred()) SWIG_fail;
31770 }
31771 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_NEW | 0 );
31772 return resultobj;
31773 fail:
31774 return NULL;
31775 }
31776
31777
31778 SWIGINTERN PyObject *_wrap_FileDataObject_GetFilenames(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31779 PyObject *resultobj = 0;
31780 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
31781 wxArrayString *result = 0 ;
31782 void *argp1 = 0 ;
31783 int res1 = 0 ;
31784 PyObject *swig_obj[1] ;
31785
31786 if (!args) SWIG_fail;
31787 swig_obj[0] = args;
31788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
31789 if (!SWIG_IsOK(res1)) {
31790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_GetFilenames" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
31791 }
31792 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
31793 {
31794 PyThreadState* __tstate = wxPyBeginAllowThreads();
31795 {
31796 wxArrayString const &_result_ref = (arg1)->GetFilenames();
31797 result = (wxArrayString *) &_result_ref;
31798 }
31799 wxPyEndAllowThreads(__tstate);
31800 if (PyErr_Occurred()) SWIG_fail;
31801 }
31802 {
31803 resultobj = wxArrayString2PyList_helper(*result);
31804 }
31805 return resultobj;
31806 fail:
31807 return NULL;
31808 }
31809
31810
31811 SWIGINTERN PyObject *_wrap_FileDataObject_AddFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31812 PyObject *resultobj = 0;
31813 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
31814 wxString *arg2 = 0 ;
31815 void *argp1 = 0 ;
31816 int res1 = 0 ;
31817 bool temp2 = false ;
31818 PyObject * obj0 = 0 ;
31819 PyObject * obj1 = 0 ;
31820 char * kwnames[] = {
31821 (char *) "self",(char *) "filename", NULL
31822 };
31823
31824 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) SWIG_fail;
31825 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
31826 if (!SWIG_IsOK(res1)) {
31827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_AddFile" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
31828 }
31829 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
31830 {
31831 arg2 = wxString_in_helper(obj1);
31832 if (arg2 == NULL) SWIG_fail;
31833 temp2 = true;
31834 }
31835 {
31836 PyThreadState* __tstate = wxPyBeginAllowThreads();
31837 (arg1)->AddFile((wxString const &)*arg2);
31838 wxPyEndAllowThreads(__tstate);
31839 if (PyErr_Occurred()) SWIG_fail;
31840 }
31841 resultobj = SWIG_Py_Void();
31842 {
31843 if (temp2)
31844 delete arg2;
31845 }
31846 return resultobj;
31847 fail:
31848 {
31849 if (temp2)
31850 delete arg2;
31851 }
31852 return NULL;
31853 }
31854
31855
31856 SWIGINTERN PyObject *FileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31857 PyObject *obj;
31858 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31859 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileDataObject, SWIG_NewClientData(obj));
31860 return SWIG_Py_Void();
31861 }
31862
31863 SWIGINTERN PyObject *FileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31864 return SWIG_Python_InitShadowInstance(args);
31865 }
31866
31867 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31868 PyObject *resultobj = 0;
31869 wxDataFormat *arg1 = 0 ;
31870 wxCustomDataObject *result = 0 ;
31871 void *argp1 = 0 ;
31872 int res1 = 0 ;
31873
31874 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
31875 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
31876 if (!SWIG_IsOK(res1)) {
31877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31878 }
31879 if (!argp1) {
31880 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31881 }
31882 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31883 {
31884 PyThreadState* __tstate = wxPyBeginAllowThreads();
31885 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
31886 wxPyEndAllowThreads(__tstate);
31887 if (PyErr_Occurred()) SWIG_fail;
31888 }
31889 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
31890 return resultobj;
31891 fail:
31892 return NULL;
31893 }
31894
31895
31896 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31897 PyObject *resultobj = 0;
31898 wxString *arg1 = 0 ;
31899 wxCustomDataObject *result = 0 ;
31900 bool temp1 = false ;
31901
31902 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
31903 {
31904 arg1 = wxString_in_helper(swig_obj[0]);
31905 if (arg1 == NULL) SWIG_fail;
31906 temp1 = true;
31907 }
31908 {
31909 PyThreadState* __tstate = wxPyBeginAllowThreads();
31910 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
31911 wxPyEndAllowThreads(__tstate);
31912 if (PyErr_Occurred()) SWIG_fail;
31913 }
31914 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
31915 {
31916 if (temp1)
31917 delete arg1;
31918 }
31919 return resultobj;
31920 fail:
31921 {
31922 if (temp1)
31923 delete arg1;
31924 }
31925 return NULL;
31926 }
31927
31928
31929 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
31930 PyObject *resultobj = 0;
31931 wxCustomDataObject *result = 0 ;
31932
31933 if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
31934 {
31935 PyThreadState* __tstate = wxPyBeginAllowThreads();
31936 result = (wxCustomDataObject *)new wxCustomDataObject();
31937 wxPyEndAllowThreads(__tstate);
31938 if (PyErr_Occurred()) SWIG_fail;
31939 }
31940 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
31941 return resultobj;
31942 fail:
31943 return NULL;
31944 }
31945
31946
31947 SWIGINTERN PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
31948 int argc;
31949 PyObject *argv[2];
31950
31951 if (!(argc = SWIG_Python_UnpackTuple(args,"new_CustomDataObject",0,1,argv))) SWIG_fail;
31952 --argc;
31953 if (argc == 0) {
31954 return _wrap_new_CustomDataObject__SWIG_2(self, argc, argv);
31955 }
31956 if (argc == 1) {
31957 int _v = 0;
31958 {
31959 {
31960 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
31961 }
31962 }
31963 if (!_v) goto check_2;
31964 return _wrap_new_CustomDataObject__SWIG_1(self, argc, argv);
31965 }
31966 check_2:
31967
31968 if (argc == 1) {
31969 return _wrap_new_CustomDataObject__SWIG_0(self, argc, argv);
31970 }
31971
31972 fail:
31973 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
31974 return NULL;
31975 }
31976
31977
31978 SWIGINTERN PyObject *_wrap_CustomDataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31979 PyObject *resultobj = 0;
31980 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
31981 PyObject *arg2 = (PyObject *) 0 ;
31982 bool result;
31983 void *argp1 = 0 ;
31984 int res1 = 0 ;
31985 PyObject * obj0 = 0 ;
31986 PyObject * obj1 = 0 ;
31987 char * kwnames[] = {
31988 (char *) "self",(char *) "data", NULL
31989 };
31990
31991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
31992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
31993 if (!SWIG_IsOK(res1)) {
31994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_SetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
31995 }
31996 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
31997 arg2 = obj1;
31998 {
31999 PyThreadState* __tstate = wxPyBeginAllowThreads();
32000 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
32001 wxPyEndAllowThreads(__tstate);
32002 if (PyErr_Occurred()) SWIG_fail;
32003 }
32004 {
32005 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32006 }
32007 return resultobj;
32008 fail:
32009 return NULL;
32010 }
32011
32012
32013 SWIGINTERN PyObject *_wrap_CustomDataObject_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32014 PyObject *resultobj = 0;
32015 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
32016 size_t result;
32017 void *argp1 = 0 ;
32018 int res1 = 0 ;
32019 PyObject *swig_obj[1] ;
32020
32021 if (!args) SWIG_fail;
32022 swig_obj[0] = args;
32023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
32024 if (!SWIG_IsOK(res1)) {
32025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetSize" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
32026 }
32027 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
32028 {
32029 PyThreadState* __tstate = wxPyBeginAllowThreads();
32030 result = (size_t)(arg1)->GetSize();
32031 wxPyEndAllowThreads(__tstate);
32032 if (PyErr_Occurred()) SWIG_fail;
32033 }
32034 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32035 return resultobj;
32036 fail:
32037 return NULL;
32038 }
32039
32040
32041 SWIGINTERN PyObject *_wrap_CustomDataObject_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32042 PyObject *resultobj = 0;
32043 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
32044 PyObject *result = 0 ;
32045 void *argp1 = 0 ;
32046 int res1 = 0 ;
32047 PyObject *swig_obj[1] ;
32048
32049 if (!args) SWIG_fail;
32050 swig_obj[0] = args;
32051 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
32052 if (!SWIG_IsOK(res1)) {
32053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
32054 }
32055 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
32056 {
32057 PyThreadState* __tstate = wxPyBeginAllowThreads();
32058 result = (PyObject *)wxCustomDataObject_GetData(arg1);
32059 wxPyEndAllowThreads(__tstate);
32060 if (PyErr_Occurred()) SWIG_fail;
32061 }
32062 resultobj = result;
32063 return resultobj;
32064 fail:
32065 return NULL;
32066 }
32067
32068
32069 SWIGINTERN PyObject *CustomDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32070 PyObject *obj;
32071 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32072 SWIG_TypeNewClientData(SWIGTYPE_p_wxCustomDataObject, SWIG_NewClientData(obj));
32073 return SWIG_Py_Void();
32074 }
32075
32076 SWIGINTERN PyObject *CustomDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32077 return SWIG_Python_InitShadowInstance(args);
32078 }
32079
32080 SWIGINTERN PyObject *_wrap_new_URLDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32081 PyObject *resultobj = 0;
32082 wxURLDataObject *result = 0 ;
32083
32084 if (!SWIG_Python_UnpackTuple(args,"new_URLDataObject",0,0,0)) SWIG_fail;
32085 {
32086 PyThreadState* __tstate = wxPyBeginAllowThreads();
32087 result = (wxURLDataObject *)new wxURLDataObject();
32088 wxPyEndAllowThreads(__tstate);
32089 if (PyErr_Occurred()) SWIG_fail;
32090 }
32091 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_NEW | 0 );
32092 return resultobj;
32093 fail:
32094 return NULL;
32095 }
32096
32097
32098 SWIGINTERN PyObject *_wrap_URLDataObject_GetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32099 PyObject *resultobj = 0;
32100 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
32101 wxString result;
32102 void *argp1 = 0 ;
32103 int res1 = 0 ;
32104 PyObject *swig_obj[1] ;
32105
32106 if (!args) SWIG_fail;
32107 swig_obj[0] = args;
32108 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
32109 if (!SWIG_IsOK(res1)) {
32110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_GetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
32111 }
32112 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
32113 {
32114 PyThreadState* __tstate = wxPyBeginAllowThreads();
32115 result = (arg1)->GetURL();
32116 wxPyEndAllowThreads(__tstate);
32117 if (PyErr_Occurred()) SWIG_fail;
32118 }
32119 {
32120 #if wxUSE_UNICODE
32121 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32122 #else
32123 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32124 #endif
32125 }
32126 return resultobj;
32127 fail:
32128 return NULL;
32129 }
32130
32131
32132 SWIGINTERN PyObject *_wrap_URLDataObject_SetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32133 PyObject *resultobj = 0;
32134 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
32135 wxString *arg2 = 0 ;
32136 void *argp1 = 0 ;
32137 int res1 = 0 ;
32138 bool temp2 = false ;
32139 PyObject * obj0 = 0 ;
32140 PyObject * obj1 = 0 ;
32141 char * kwnames[] = {
32142 (char *) "self",(char *) "url", NULL
32143 };
32144
32145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) SWIG_fail;
32146 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
32147 if (!SWIG_IsOK(res1)) {
32148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_SetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
32149 }
32150 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
32151 {
32152 arg2 = wxString_in_helper(obj1);
32153 if (arg2 == NULL) SWIG_fail;
32154 temp2 = true;
32155 }
32156 {
32157 PyThreadState* __tstate = wxPyBeginAllowThreads();
32158 (arg1)->SetURL((wxString const &)*arg2);
32159 wxPyEndAllowThreads(__tstate);
32160 if (PyErr_Occurred()) SWIG_fail;
32161 }
32162 resultobj = SWIG_Py_Void();
32163 {
32164 if (temp2)
32165 delete arg2;
32166 }
32167 return resultobj;
32168 fail:
32169 {
32170 if (temp2)
32171 delete arg2;
32172 }
32173 return NULL;
32174 }
32175
32176
32177 SWIGINTERN PyObject *URLDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32178 PyObject *obj;
32179 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32180 SWIG_TypeNewClientData(SWIGTYPE_p_wxURLDataObject, SWIG_NewClientData(obj));
32181 return SWIG_Py_Void();
32182 }
32183
32184 SWIGINTERN PyObject *URLDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32185 return SWIG_Python_InitShadowInstance(args);
32186 }
32187
32188 SWIGINTERN PyObject *_wrap_new_MetafileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32189 PyObject *resultobj = 0;
32190 wxMetafileDataObject *result = 0 ;
32191
32192 if (!SWIG_Python_UnpackTuple(args,"new_MetafileDataObject",0,0,0)) SWIG_fail;
32193 {
32194 PyThreadState* __tstate = wxPyBeginAllowThreads();
32195 result = (wxMetafileDataObject *)new wxMetafileDataObject();
32196 wxPyEndAllowThreads(__tstate);
32197 if (PyErr_Occurred()) SWIG_fail;
32198 }
32199 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_NEW | 0 );
32200 return resultobj;
32201 fail:
32202 return NULL;
32203 }
32204
32205
32206 SWIGINTERN PyObject *_wrap_MetafileDataObject_SetMetafile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32207 PyObject *resultobj = 0;
32208 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
32209 wxMetafile *arg2 = 0 ;
32210 void *argp1 = 0 ;
32211 int res1 = 0 ;
32212 void *argp2 = 0 ;
32213 int res2 = 0 ;
32214 PyObject * obj0 = 0 ;
32215 PyObject * obj1 = 0 ;
32216 char * kwnames[] = {
32217 (char *) "self",(char *) "metafile", NULL
32218 };
32219
32220 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MetafileDataObject_SetMetafile",kwnames,&obj0,&obj1)) SWIG_fail;
32221 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMetafileDataObject, 0 | 0 );
32222 if (!SWIG_IsOK(res1)) {
32223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetafileDataObject_SetMetafile" "', expected argument " "1"" of type '" "wxMetafileDataObject *""'");
32224 }
32225 arg1 = reinterpret_cast< wxMetafileDataObject * >(argp1);
32226 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxMetafile, 0 | 0);
32227 if (!SWIG_IsOK(res2)) {
32228 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MetafileDataObject_SetMetafile" "', expected argument " "2"" of type '" "wxMetafile const &""'");
32229 }
32230 if (!argp2) {
32231 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MetafileDataObject_SetMetafile" "', expected argument " "2"" of type '" "wxMetafile const &""'");
32232 }
32233 arg2 = reinterpret_cast< wxMetafile * >(argp2);
32234 {
32235 PyThreadState* __tstate = wxPyBeginAllowThreads();
32236 (arg1)->SetMetafile((wxMetafile const &)*arg2);
32237 wxPyEndAllowThreads(__tstate);
32238 if (PyErr_Occurred()) SWIG_fail;
32239 }
32240 resultobj = SWIG_Py_Void();
32241 return resultobj;
32242 fail:
32243 return NULL;
32244 }
32245
32246
32247 SWIGINTERN PyObject *_wrap_MetafileDataObject_GetMetafile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32248 PyObject *resultobj = 0;
32249 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
32250 wxMetafile result;
32251 void *argp1 = 0 ;
32252 int res1 = 0 ;
32253 PyObject *swig_obj[1] ;
32254
32255 if (!args) SWIG_fail;
32256 swig_obj[0] = args;
32257 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMetafileDataObject, 0 | 0 );
32258 if (!SWIG_IsOK(res1)) {
32259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetafileDataObject_GetMetafile" "', expected argument " "1"" of type '" "wxMetafileDataObject const *""'");
32260 }
32261 arg1 = reinterpret_cast< wxMetafileDataObject * >(argp1);
32262 {
32263 PyThreadState* __tstate = wxPyBeginAllowThreads();
32264 result = ((wxMetafileDataObject const *)arg1)->GetMetafile();
32265 wxPyEndAllowThreads(__tstate);
32266 if (PyErr_Occurred()) SWIG_fail;
32267 }
32268 resultobj = SWIG_NewPointerObj((new wxMetafile(static_cast< const wxMetafile& >(result))), SWIGTYPE_p_wxMetafile, SWIG_POINTER_OWN | 0 );
32269 return resultobj;
32270 fail:
32271 return NULL;
32272 }
32273
32274
32275 SWIGINTERN PyObject *MetafileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32276 PyObject *obj;
32277 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32278 SWIG_TypeNewClientData(SWIGTYPE_p_wxMetafileDataObject, SWIG_NewClientData(obj));
32279 return SWIG_Py_Void();
32280 }
32281
32282 SWIGINTERN PyObject *MetafileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32283 return SWIG_Python_InitShadowInstance(args);
32284 }
32285
32286 SWIGINTERN PyObject *_wrap_IsDragResultOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32287 PyObject *resultobj = 0;
32288 wxDragResult arg1 ;
32289 bool result;
32290 int val1 ;
32291 int ecode1 = 0 ;
32292 PyObject * obj0 = 0 ;
32293 char * kwnames[] = {
32294 (char *) "res", NULL
32295 };
32296
32297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) SWIG_fail;
32298 ecode1 = SWIG_AsVal_int(obj0, &val1);
32299 if (!SWIG_IsOK(ecode1)) {
32300 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsDragResultOk" "', expected argument " "1"" of type '" "wxDragResult""'");
32301 }
32302 arg1 = static_cast< wxDragResult >(val1);
32303 {
32304 PyThreadState* __tstate = wxPyBeginAllowThreads();
32305 result = (bool)wxIsDragResultOk(arg1);
32306 wxPyEndAllowThreads(__tstate);
32307 if (PyErr_Occurred()) SWIG_fail;
32308 }
32309 {
32310 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32311 }
32312 return resultobj;
32313 fail:
32314 return NULL;
32315 }
32316
32317
32318 SWIGINTERN PyObject *_wrap_new_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32319 PyObject *resultobj = 0;
32320 wxWindow *arg1 = (wxWindow *) 0 ;
32321 wxCursor const &arg2_defvalue = wxNullCursor ;
32322 wxCursor *arg2 = (wxCursor *) &arg2_defvalue ;
32323 wxCursor const &arg3_defvalue = wxNullCursor ;
32324 wxCursor *arg3 = (wxCursor *) &arg3_defvalue ;
32325 wxCursor const &arg4_defvalue = wxNullCursor ;
32326 wxCursor *arg4 = (wxCursor *) &arg4_defvalue ;
32327 wxPyDropSource *result = 0 ;
32328 void *argp1 = 0 ;
32329 int res1 = 0 ;
32330 void *argp2 = 0 ;
32331 int res2 = 0 ;
32332 void *argp3 = 0 ;
32333 int res3 = 0 ;
32334 void *argp4 = 0 ;
32335 int res4 = 0 ;
32336 PyObject * obj0 = 0 ;
32337 PyObject * obj1 = 0 ;
32338 PyObject * obj2 = 0 ;
32339 PyObject * obj3 = 0 ;
32340 char * kwnames[] = {
32341 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
32342 };
32343
32344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32345 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32346 if (!SWIG_IsOK(res1)) {
32347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropSource" "', expected argument " "1"" of type '" "wxWindow *""'");
32348 }
32349 arg1 = reinterpret_cast< wxWindow * >(argp1);
32350 if (obj1) {
32351 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
32352 if (!SWIG_IsOK(res2)) {
32353 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxCursor const &""'");
32354 }
32355 if (!argp2) {
32356 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxCursor const &""'");
32357 }
32358 arg2 = reinterpret_cast< wxCursor * >(argp2);
32359 }
32360 if (obj2) {
32361 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxCursor, 0 | 0);
32362 if (!SWIG_IsOK(res3)) {
32363 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxCursor const &""'");
32364 }
32365 if (!argp3) {
32366 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxCursor const &""'");
32367 }
32368 arg3 = reinterpret_cast< wxCursor * >(argp3);
32369 }
32370 if (obj3) {
32371 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxCursor, 0 | 0);
32372 if (!SWIG_IsOK(res4)) {
32373 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxCursor const &""'");
32374 }
32375 if (!argp4) {
32376 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxCursor const &""'");
32377 }
32378 arg4 = reinterpret_cast< wxCursor * >(argp4);
32379 }
32380 {
32381 PyThreadState* __tstate = wxPyBeginAllowThreads();
32382 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxCursor const &)*arg2,(wxCursor const &)*arg3,(wxCursor const &)*arg4);
32383 wxPyEndAllowThreads(__tstate);
32384 if (PyErr_Occurred()) SWIG_fail;
32385 }
32386 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_NEW | 0 );
32387 return resultobj;
32388 fail:
32389 return NULL;
32390 }
32391
32392
32393 SWIGINTERN PyObject *_wrap_DropSource__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32394 PyObject *resultobj = 0;
32395 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32396 PyObject *arg2 = (PyObject *) 0 ;
32397 PyObject *arg3 = (PyObject *) 0 ;
32398 int arg4 ;
32399 void *argp1 = 0 ;
32400 int res1 = 0 ;
32401 int val4 ;
32402 int ecode4 = 0 ;
32403 PyObject * obj0 = 0 ;
32404 PyObject * obj1 = 0 ;
32405 PyObject * obj2 = 0 ;
32406 PyObject * obj3 = 0 ;
32407 char * kwnames[] = {
32408 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
32409 };
32410
32411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32412 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32413 if (!SWIG_IsOK(res1)) {
32414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32415 }
32416 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32417 arg2 = obj1;
32418 arg3 = obj2;
32419 ecode4 = SWIG_AsVal_int(obj3, &val4);
32420 if (!SWIG_IsOK(ecode4)) {
32421 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropSource__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
32422 }
32423 arg4 = static_cast< int >(val4);
32424 {
32425 PyThreadState* __tstate = wxPyBeginAllowThreads();
32426 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
32427 wxPyEndAllowThreads(__tstate);
32428 if (PyErr_Occurred()) SWIG_fail;
32429 }
32430 resultobj = SWIG_Py_Void();
32431 return resultobj;
32432 fail:
32433 return NULL;
32434 }
32435
32436
32437 SWIGINTERN PyObject *_wrap_delete_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32438 PyObject *resultobj = 0;
32439 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32440 void *argp1 = 0 ;
32441 int res1 = 0 ;
32442 PyObject *swig_obj[1] ;
32443
32444 if (!args) SWIG_fail;
32445 swig_obj[0] = args;
32446 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_DISOWN | 0 );
32447 if (!SWIG_IsOK(res1)) {
32448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropSource" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32449 }
32450 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32451 {
32452 PyThreadState* __tstate = wxPyBeginAllowThreads();
32453 delete arg1;
32454
32455 wxPyEndAllowThreads(__tstate);
32456 if (PyErr_Occurred()) SWIG_fail;
32457 }
32458 resultobj = SWIG_Py_Void();
32459 return resultobj;
32460 fail:
32461 return NULL;
32462 }
32463
32464
32465 SWIGINTERN PyObject *_wrap_DropSource_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32466 PyObject *resultobj = 0;
32467 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32468 wxDataObject *arg2 = 0 ;
32469 void *argp1 = 0 ;
32470 int res1 = 0 ;
32471 void *argp2 = 0 ;
32472 int res2 = 0 ;
32473 PyObject * obj0 = 0 ;
32474 PyObject * obj1 = 0 ;
32475 char * kwnames[] = {
32476 (char *) "self",(char *) "data", NULL
32477 };
32478
32479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
32480 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32481 if (!SWIG_IsOK(res1)) {
32482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetData" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32483 }
32484 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32485 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
32486 if (!SWIG_IsOK(res2)) {
32487 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
32488 }
32489 if (!argp2) {
32490 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
32491 }
32492 arg2 = reinterpret_cast< wxDataObject * >(argp2);
32493 {
32494 PyThreadState* __tstate = wxPyBeginAllowThreads();
32495 (arg1)->SetData(*arg2);
32496 wxPyEndAllowThreads(__tstate);
32497 if (PyErr_Occurred()) SWIG_fail;
32498 }
32499 resultobj = SWIG_Py_Void();
32500 return resultobj;
32501 fail:
32502 return NULL;
32503 }
32504
32505
32506 SWIGINTERN PyObject *_wrap_DropSource_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32507 PyObject *resultobj = 0;
32508 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32509 wxDataObject *result = 0 ;
32510 void *argp1 = 0 ;
32511 int res1 = 0 ;
32512 PyObject *swig_obj[1] ;
32513
32514 if (!args) SWIG_fail;
32515 swig_obj[0] = args;
32516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32517 if (!SWIG_IsOK(res1)) {
32518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32519 }
32520 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32521 {
32522 PyThreadState* __tstate = wxPyBeginAllowThreads();
32523 result = (wxDataObject *)(arg1)->GetDataObject();
32524 wxPyEndAllowThreads(__tstate);
32525 if (PyErr_Occurred()) SWIG_fail;
32526 }
32527 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
32528 return resultobj;
32529 fail:
32530 return NULL;
32531 }
32532
32533
32534 SWIGINTERN PyObject *_wrap_DropSource_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32535 PyObject *resultobj = 0;
32536 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32537 wxDragResult arg2 ;
32538 wxCursor *arg3 = 0 ;
32539 void *argp1 = 0 ;
32540 int res1 = 0 ;
32541 int val2 ;
32542 int ecode2 = 0 ;
32543 void *argp3 = 0 ;
32544 int res3 = 0 ;
32545 PyObject * obj0 = 0 ;
32546 PyObject * obj1 = 0 ;
32547 PyObject * obj2 = 0 ;
32548 char * kwnames[] = {
32549 (char *) "self",(char *) "res",(char *) "cursor", NULL
32550 };
32551
32552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32554 if (!SWIG_IsOK(res1)) {
32555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetCursor" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32556 }
32557 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32558 ecode2 = SWIG_AsVal_int(obj1, &val2);
32559 if (!SWIG_IsOK(ecode2)) {
32560 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_SetCursor" "', expected argument " "2"" of type '" "wxDragResult""'");
32561 }
32562 arg2 = static_cast< wxDragResult >(val2);
32563 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxCursor, 0 | 0);
32564 if (!SWIG_IsOK(res3)) {
32565 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
32566 }
32567 if (!argp3) {
32568 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
32569 }
32570 arg3 = reinterpret_cast< wxCursor * >(argp3);
32571 {
32572 PyThreadState* __tstate = wxPyBeginAllowThreads();
32573 (arg1)->SetCursor(arg2,(wxCursor const &)*arg3);
32574 wxPyEndAllowThreads(__tstate);
32575 if (PyErr_Occurred()) SWIG_fail;
32576 }
32577 resultobj = SWIG_Py_Void();
32578 return resultobj;
32579 fail:
32580 return NULL;
32581 }
32582
32583
32584 SWIGINTERN PyObject *_wrap_DropSource_DoDragDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32585 PyObject *resultobj = 0;
32586 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32587 int arg2 = (int) wxDrag_CopyOnly ;
32588 wxDragResult result;
32589 void *argp1 = 0 ;
32590 int res1 = 0 ;
32591 int val2 ;
32592 int ecode2 = 0 ;
32593 PyObject * obj0 = 0 ;
32594 PyObject * obj1 = 0 ;
32595 char * kwnames[] = {
32596 (char *) "self",(char *) "flags", NULL
32597 };
32598
32599 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) SWIG_fail;
32600 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32601 if (!SWIG_IsOK(res1)) {
32602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_DoDragDrop" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32603 }
32604 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32605 if (obj1) {
32606 ecode2 = SWIG_AsVal_int(obj1, &val2);
32607 if (!SWIG_IsOK(ecode2)) {
32608 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_DoDragDrop" "', expected argument " "2"" of type '" "int""'");
32609 }
32610 arg2 = static_cast< int >(val2);
32611 }
32612 {
32613 PyThreadState* __tstate = wxPyBeginAllowThreads();
32614 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
32615 wxPyEndAllowThreads(__tstate);
32616 if (PyErr_Occurred()) SWIG_fail;
32617 }
32618 resultobj = SWIG_From_int(static_cast< int >(result));
32619 return resultobj;
32620 fail:
32621 return NULL;
32622 }
32623
32624
32625 SWIGINTERN PyObject *_wrap_DropSource_GiveFeedback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32626 PyObject *resultobj = 0;
32627 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32628 wxDragResult arg2 ;
32629 bool result;
32630 void *argp1 = 0 ;
32631 int res1 = 0 ;
32632 int val2 ;
32633 int ecode2 = 0 ;
32634 PyObject * obj0 = 0 ;
32635 PyObject * obj1 = 0 ;
32636 char * kwnames[] = {
32637 (char *) "self",(char *) "effect", NULL
32638 };
32639
32640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_GiveFeedback",kwnames,&obj0,&obj1)) SWIG_fail;
32641 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32642 if (!SWIG_IsOK(res1)) {
32643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GiveFeedback" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32644 }
32645 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32646 ecode2 = SWIG_AsVal_int(obj1, &val2);
32647 if (!SWIG_IsOK(ecode2)) {
32648 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_GiveFeedback" "', expected argument " "2"" of type '" "wxDragResult""'");
32649 }
32650 arg2 = static_cast< wxDragResult >(val2);
32651 {
32652 PyThreadState* __tstate = wxPyBeginAllowThreads();
32653 result = (bool)(arg1)->GiveFeedback(arg2);
32654 wxPyEndAllowThreads(__tstate);
32655 if (PyErr_Occurred()) SWIG_fail;
32656 }
32657 {
32658 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32659 }
32660 return resultobj;
32661 fail:
32662 return NULL;
32663 }
32664
32665
32666 SWIGINTERN PyObject *DropSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32667 PyObject *obj;
32668 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32669 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropSource, SWIG_NewClientData(obj));
32670 return SWIG_Py_Void();
32671 }
32672
32673 SWIGINTERN PyObject *DropSource_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32674 return SWIG_Python_InitShadowInstance(args);
32675 }
32676
32677 SWIGINTERN PyObject *_wrap_new_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32678 PyObject *resultobj = 0;
32679 wxDataObject *arg1 = (wxDataObject *) NULL ;
32680 wxPyDropTarget *result = 0 ;
32681 int res1 = 0 ;
32682 PyObject * obj0 = 0 ;
32683 char * kwnames[] = {
32684 (char *) "dataObject", NULL
32685 };
32686
32687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) SWIG_fail;
32688 if (obj0) {
32689 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
32690 if (!SWIG_IsOK(res1)) {
32691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropTarget" "', expected argument " "1"" of type '" "wxDataObject *""'");
32692 }
32693 }
32694 {
32695 PyThreadState* __tstate = wxPyBeginAllowThreads();
32696 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
32697 wxPyEndAllowThreads(__tstate);
32698 if (PyErr_Occurred()) SWIG_fail;
32699 }
32700 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_NEW | 0 );
32701 return resultobj;
32702 fail:
32703 return NULL;
32704 }
32705
32706
32707 SWIGINTERN PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32708 PyObject *resultobj = 0;
32709 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32710 PyObject *arg2 = (PyObject *) 0 ;
32711 PyObject *arg3 = (PyObject *) 0 ;
32712 void *argp1 = 0 ;
32713 int res1 = 0 ;
32714 PyObject * obj0 = 0 ;
32715 PyObject * obj1 = 0 ;
32716 PyObject * obj2 = 0 ;
32717 char * kwnames[] = {
32718 (char *) "self",(char *) "self",(char *) "_class", NULL
32719 };
32720
32721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32722 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32723 if (!SWIG_IsOK(res1)) {
32724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32725 }
32726 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32727 arg2 = obj1;
32728 arg3 = obj2;
32729 {
32730 PyThreadState* __tstate = wxPyBeginAllowThreads();
32731 (arg1)->_setCallbackInfo(arg2,arg3);
32732 wxPyEndAllowThreads(__tstate);
32733 if (PyErr_Occurred()) SWIG_fail;
32734 }
32735 resultobj = SWIG_Py_Void();
32736 return resultobj;
32737 fail:
32738 return NULL;
32739 }
32740
32741
32742 SWIGINTERN PyObject *_wrap_delete_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32743 PyObject *resultobj = 0;
32744 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32745 void *argp1 = 0 ;
32746 int res1 = 0 ;
32747 PyObject *swig_obj[1] ;
32748
32749 if (!args) SWIG_fail;
32750 swig_obj[0] = args;
32751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
32752 if (!SWIG_IsOK(res1)) {
32753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropTarget" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32754 }
32755 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32756 {
32757 PyThreadState* __tstate = wxPyBeginAllowThreads();
32758 delete arg1;
32759
32760 wxPyEndAllowThreads(__tstate);
32761 if (PyErr_Occurred()) SWIG_fail;
32762 }
32763 resultobj = SWIG_Py_Void();
32764 return resultobj;
32765 fail:
32766 return NULL;
32767 }
32768
32769
32770 SWIGINTERN PyObject *_wrap_DropTarget_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32771 PyObject *resultobj = 0;
32772 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32773 wxDataObject *result = 0 ;
32774 void *argp1 = 0 ;
32775 int res1 = 0 ;
32776 PyObject *swig_obj[1] ;
32777
32778 if (!args) SWIG_fail;
32779 swig_obj[0] = args;
32780 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32781 if (!SWIG_IsOK(res1)) {
32782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32783 }
32784 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32785 {
32786 PyThreadState* __tstate = wxPyBeginAllowThreads();
32787 result = (wxDataObject *)(arg1)->GetDataObject();
32788 wxPyEndAllowThreads(__tstate);
32789 if (PyErr_Occurred()) SWIG_fail;
32790 }
32791 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
32792 return resultobj;
32793 fail:
32794 return NULL;
32795 }
32796
32797
32798 SWIGINTERN PyObject *_wrap_DropTarget_SetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32799 PyObject *resultobj = 0;
32800 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32801 wxDataObject *arg2 = (wxDataObject *) 0 ;
32802 void *argp1 = 0 ;
32803 int res1 = 0 ;
32804 int res2 = 0 ;
32805 PyObject * obj0 = 0 ;
32806 PyObject * obj1 = 0 ;
32807 char * kwnames[] = {
32808 (char *) "self",(char *) "dataObject", NULL
32809 };
32810
32811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) SWIG_fail;
32812 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32813 if (!SWIG_IsOK(res1)) {
32814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32815 }
32816 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32817 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
32818 if (!SWIG_IsOK(res2)) {
32819 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropTarget_SetDataObject" "', expected argument " "2"" of type '" "wxDataObject *""'");
32820 }
32821 {
32822 PyThreadState* __tstate = wxPyBeginAllowThreads();
32823 (arg1)->SetDataObject(arg2);
32824 wxPyEndAllowThreads(__tstate);
32825 if (PyErr_Occurred()) SWIG_fail;
32826 }
32827 resultobj = SWIG_Py_Void();
32828 return resultobj;
32829 fail:
32830 return NULL;
32831 }
32832
32833
32834 SWIGINTERN PyObject *_wrap_DropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32835 PyObject *resultobj = 0;
32836 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32837 int arg2 ;
32838 int arg3 ;
32839 wxDragResult arg4 ;
32840 wxDragResult result;
32841 void *argp1 = 0 ;
32842 int res1 = 0 ;
32843 int val2 ;
32844 int ecode2 = 0 ;
32845 int val3 ;
32846 int ecode3 = 0 ;
32847 int val4 ;
32848 int ecode4 = 0 ;
32849 PyObject * obj0 = 0 ;
32850 PyObject * obj1 = 0 ;
32851 PyObject * obj2 = 0 ;
32852 PyObject * obj3 = 0 ;
32853 char * kwnames[] = {
32854 (char *) "self",(char *) "x",(char *) "y",(char *) "_def", NULL
32855 };
32856
32857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32859 if (!SWIG_IsOK(res1)) {
32860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32861 }
32862 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32863 ecode2 = SWIG_AsVal_int(obj1, &val2);
32864 if (!SWIG_IsOK(ecode2)) {
32865 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
32866 }
32867 arg2 = static_cast< int >(val2);
32868 ecode3 = SWIG_AsVal_int(obj2, &val3);
32869 if (!SWIG_IsOK(ecode3)) {
32870 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
32871 }
32872 arg3 = static_cast< int >(val3);
32873 ecode4 = SWIG_AsVal_int(obj3, &val4);
32874 if (!SWIG_IsOK(ecode4)) {
32875 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
32876 }
32877 arg4 = static_cast< wxDragResult >(val4);
32878 {
32879 PyThreadState* __tstate = wxPyBeginAllowThreads();
32880 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
32881 wxPyEndAllowThreads(__tstate);
32882 if (PyErr_Occurred()) SWIG_fail;
32883 }
32884 resultobj = SWIG_From_int(static_cast< int >(result));
32885 return resultobj;
32886 fail:
32887 return NULL;
32888 }
32889
32890
32891 SWIGINTERN PyObject *_wrap_DropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32892 PyObject *resultobj = 0;
32893 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32894 int arg2 ;
32895 int arg3 ;
32896 wxDragResult arg4 ;
32897 wxDragResult result;
32898 void *argp1 = 0 ;
32899 int res1 = 0 ;
32900 int val2 ;
32901 int ecode2 = 0 ;
32902 int val3 ;
32903 int ecode3 = 0 ;
32904 int val4 ;
32905 int ecode4 = 0 ;
32906 PyObject * obj0 = 0 ;
32907 PyObject * obj1 = 0 ;
32908 PyObject * obj2 = 0 ;
32909 PyObject * obj3 = 0 ;
32910 char * kwnames[] = {
32911 (char *) "self",(char *) "x",(char *) "y",(char *) "_def", NULL
32912 };
32913
32914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32915 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32916 if (!SWIG_IsOK(res1)) {
32917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32918 }
32919 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32920 ecode2 = SWIG_AsVal_int(obj1, &val2);
32921 if (!SWIG_IsOK(ecode2)) {
32922 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
32923 }
32924 arg2 = static_cast< int >(val2);
32925 ecode3 = SWIG_AsVal_int(obj2, &val3);
32926 if (!SWIG_IsOK(ecode3)) {
32927 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
32928 }
32929 arg3 = static_cast< int >(val3);
32930 ecode4 = SWIG_AsVal_int(obj3, &val4);
32931 if (!SWIG_IsOK(ecode4)) {
32932 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
32933 }
32934 arg4 = static_cast< wxDragResult >(val4);
32935 {
32936 PyThreadState* __tstate = wxPyBeginAllowThreads();
32937 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
32938 wxPyEndAllowThreads(__tstate);
32939 if (PyErr_Occurred()) SWIG_fail;
32940 }
32941 resultobj = SWIG_From_int(static_cast< int >(result));
32942 return resultobj;
32943 fail:
32944 return NULL;
32945 }
32946
32947
32948 SWIGINTERN PyObject *_wrap_DropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32949 PyObject *resultobj = 0;
32950 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32951 void *argp1 = 0 ;
32952 int res1 = 0 ;
32953 PyObject *swig_obj[1] ;
32954
32955 if (!args) SWIG_fail;
32956 swig_obj[0] = args;
32957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32958 if (!SWIG_IsOK(res1)) {
32959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32960 }
32961 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32962 {
32963 PyThreadState* __tstate = wxPyBeginAllowThreads();
32964 (arg1)->OnLeave();
32965 wxPyEndAllowThreads(__tstate);
32966 if (PyErr_Occurred()) SWIG_fail;
32967 }
32968 resultobj = SWIG_Py_Void();
32969 return resultobj;
32970 fail:
32971 return NULL;
32972 }
32973
32974
32975 SWIGINTERN PyObject *_wrap_DropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32976 PyObject *resultobj = 0;
32977 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32978 int arg2 ;
32979 int arg3 ;
32980 bool result;
32981 void *argp1 = 0 ;
32982 int res1 = 0 ;
32983 int val2 ;
32984 int ecode2 = 0 ;
32985 int val3 ;
32986 int ecode3 = 0 ;
32987 PyObject * obj0 = 0 ;
32988 PyObject * obj1 = 0 ;
32989 PyObject * obj2 = 0 ;
32990 char * kwnames[] = {
32991 (char *) "self",(char *) "x",(char *) "y", NULL
32992 };
32993
32994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32996 if (!SWIG_IsOK(res1)) {
32997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32998 }
32999 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33000 ecode2 = SWIG_AsVal_int(obj1, &val2);
33001 if (!SWIG_IsOK(ecode2)) {
33002 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
33003 }
33004 arg2 = static_cast< int >(val2);
33005 ecode3 = SWIG_AsVal_int(obj2, &val3);
33006 if (!SWIG_IsOK(ecode3)) {
33007 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
33008 }
33009 arg3 = static_cast< int >(val3);
33010 {
33011 PyThreadState* __tstate = wxPyBeginAllowThreads();
33012 result = (bool)(arg1)->OnDrop(arg2,arg3);
33013 wxPyEndAllowThreads(__tstate);
33014 if (PyErr_Occurred()) SWIG_fail;
33015 }
33016 {
33017 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33018 }
33019 return resultobj;
33020 fail:
33021 return NULL;
33022 }
33023
33024
33025 SWIGINTERN PyObject *_wrap_DropTarget_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33026 PyObject *resultobj = 0;
33027 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33028 bool result;
33029 void *argp1 = 0 ;
33030 int res1 = 0 ;
33031 PyObject *swig_obj[1] ;
33032
33033 if (!args) SWIG_fail;
33034 swig_obj[0] = args;
33035 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33036 if (!SWIG_IsOK(res1)) {
33037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetData" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33038 }
33039 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33040 {
33041 PyThreadState* __tstate = wxPyBeginAllowThreads();
33042 result = (bool)(arg1)->GetData();
33043 wxPyEndAllowThreads(__tstate);
33044 if (PyErr_Occurred()) SWIG_fail;
33045 }
33046 {
33047 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33048 }
33049 return resultobj;
33050 fail:
33051 return NULL;
33052 }
33053
33054
33055 SWIGINTERN PyObject *_wrap_DropTarget_SetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33056 PyObject *resultobj = 0;
33057 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33058 wxDragResult arg2 ;
33059 void *argp1 = 0 ;
33060 int res1 = 0 ;
33061 int val2 ;
33062 int ecode2 = 0 ;
33063 PyObject * obj0 = 0 ;
33064 PyObject * obj1 = 0 ;
33065 char * kwnames[] = {
33066 (char *) "self",(char *) "action", NULL
33067 };
33068
33069 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDefaultAction",kwnames,&obj0,&obj1)) SWIG_fail;
33070 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33071 if (!SWIG_IsOK(res1)) {
33072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33073 }
33074 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33075 ecode2 = SWIG_AsVal_int(obj1, &val2);
33076 if (!SWIG_IsOK(ecode2)) {
33077 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "2"" of type '" "wxDragResult""'");
33078 }
33079 arg2 = static_cast< wxDragResult >(val2);
33080 {
33081 PyThreadState* __tstate = wxPyBeginAllowThreads();
33082 (arg1)->SetDefaultAction(arg2);
33083 wxPyEndAllowThreads(__tstate);
33084 if (PyErr_Occurred()) SWIG_fail;
33085 }
33086 resultobj = SWIG_Py_Void();
33087 return resultobj;
33088 fail:
33089 return NULL;
33090 }
33091
33092
33093 SWIGINTERN PyObject *_wrap_DropTarget_GetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33094 PyObject *resultobj = 0;
33095 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33096 wxDragResult result;
33097 void *argp1 = 0 ;
33098 int res1 = 0 ;
33099 PyObject *swig_obj[1] ;
33100
33101 if (!args) SWIG_fail;
33102 swig_obj[0] = args;
33103 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33104 if (!SWIG_IsOK(res1)) {
33105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33106 }
33107 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33108 {
33109 PyThreadState* __tstate = wxPyBeginAllowThreads();
33110 result = (wxDragResult)(arg1)->GetDefaultAction();
33111 wxPyEndAllowThreads(__tstate);
33112 if (PyErr_Occurred()) SWIG_fail;
33113 }
33114 resultobj = SWIG_From_int(static_cast< int >(result));
33115 return resultobj;
33116 fail:
33117 return NULL;
33118 }
33119
33120
33121 SWIGINTERN PyObject *DropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33122 PyObject *obj;
33123 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33124 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropTarget, SWIG_NewClientData(obj));
33125 return SWIG_Py_Void();
33126 }
33127
33128 SWIGINTERN PyObject *DropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33129 return SWIG_Python_InitShadowInstance(args);
33130 }
33131
33132 SWIGINTERN PyObject *_wrap_new_TextDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33133 PyObject *resultobj = 0;
33134 wxPyTextDropTarget *result = 0 ;
33135
33136 if (!SWIG_Python_UnpackTuple(args,"new_TextDropTarget",0,0,0)) SWIG_fail;
33137 {
33138 PyThreadState* __tstate = wxPyBeginAllowThreads();
33139 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
33140 wxPyEndAllowThreads(__tstate);
33141 if (PyErr_Occurred()) SWIG_fail;
33142 }
33143 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_NEW | 0 );
33144 return resultobj;
33145 fail:
33146 return NULL;
33147 }
33148
33149
33150 SWIGINTERN PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33151 PyObject *resultobj = 0;
33152 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33153 PyObject *arg2 = (PyObject *) 0 ;
33154 PyObject *arg3 = (PyObject *) 0 ;
33155 void *argp1 = 0 ;
33156 int res1 = 0 ;
33157 PyObject * obj0 = 0 ;
33158 PyObject * obj1 = 0 ;
33159 PyObject * obj2 = 0 ;
33160 char * kwnames[] = {
33161 (char *) "self",(char *) "self",(char *) "_class", NULL
33162 };
33163
33164 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33165 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33166 if (!SWIG_IsOK(res1)) {
33167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33168 }
33169 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33170 arg2 = obj1;
33171 arg3 = obj2;
33172 {
33173 PyThreadState* __tstate = wxPyBeginAllowThreads();
33174 (arg1)->_setCallbackInfo(arg2,arg3);
33175 wxPyEndAllowThreads(__tstate);
33176 if (PyErr_Occurred()) SWIG_fail;
33177 }
33178 resultobj = SWIG_Py_Void();
33179 return resultobj;
33180 fail:
33181 return NULL;
33182 }
33183
33184
33185 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDropText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33186 PyObject *resultobj = 0;
33187 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33188 int arg2 ;
33189 int arg3 ;
33190 wxString *arg4 = 0 ;
33191 bool result;
33192 void *argp1 = 0 ;
33193 int res1 = 0 ;
33194 int val2 ;
33195 int ecode2 = 0 ;
33196 int val3 ;
33197 int ecode3 = 0 ;
33198 bool temp4 = false ;
33199 PyObject * obj0 = 0 ;
33200 PyObject * obj1 = 0 ;
33201 PyObject * obj2 = 0 ;
33202 PyObject * obj3 = 0 ;
33203 char * kwnames[] = {
33204 (char *) "self",(char *) "x",(char *) "y",(char *) "text", NULL
33205 };
33206
33207 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDropText",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33208 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33209 if (!SWIG_IsOK(res1)) {
33210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDropText" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33211 }
33212 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33213 ecode2 = SWIG_AsVal_int(obj1, &val2);
33214 if (!SWIG_IsOK(ecode2)) {
33215 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDropText" "', expected argument " "2"" of type '" "int""'");
33216 }
33217 arg2 = static_cast< int >(val2);
33218 ecode3 = SWIG_AsVal_int(obj2, &val3);
33219 if (!SWIG_IsOK(ecode3)) {
33220 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDropText" "', expected argument " "3"" of type '" "int""'");
33221 }
33222 arg3 = static_cast< int >(val3);
33223 {
33224 arg4 = wxString_in_helper(obj3);
33225 if (arg4 == NULL) SWIG_fail;
33226 temp4 = true;
33227 }
33228 {
33229 PyThreadState* __tstate = wxPyBeginAllowThreads();
33230 result = (bool)(arg1)->OnDropText(arg2,arg3,(wxString const &)*arg4);
33231 wxPyEndAllowThreads(__tstate);
33232 if (PyErr_Occurred()) SWIG_fail;
33233 }
33234 {
33235 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33236 }
33237 {
33238 if (temp4)
33239 delete arg4;
33240 }
33241 return resultobj;
33242 fail:
33243 {
33244 if (temp4)
33245 delete arg4;
33246 }
33247 return NULL;
33248 }
33249
33250
33251 SWIGINTERN PyObject *_wrap_TextDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33252 PyObject *resultobj = 0;
33253 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33254 int arg2 ;
33255 int arg3 ;
33256 wxDragResult arg4 ;
33257 wxDragResult result;
33258 void *argp1 = 0 ;
33259 int res1 = 0 ;
33260 int val2 ;
33261 int ecode2 = 0 ;
33262 int val3 ;
33263 int ecode3 = 0 ;
33264 int val4 ;
33265 int ecode4 = 0 ;
33266 PyObject * obj0 = 0 ;
33267 PyObject * obj1 = 0 ;
33268 PyObject * obj2 = 0 ;
33269 PyObject * obj3 = 0 ;
33270 char * kwnames[] = {
33271 (char *) "self",(char *) "x",(char *) "y",(char *) "_def", NULL
33272 };
33273
33274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33275 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33276 if (!SWIG_IsOK(res1)) {
33277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33278 }
33279 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33280 ecode2 = SWIG_AsVal_int(obj1, &val2);
33281 if (!SWIG_IsOK(ecode2)) {
33282 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
33283 }
33284 arg2 = static_cast< int >(val2);
33285 ecode3 = SWIG_AsVal_int(obj2, &val3);
33286 if (!SWIG_IsOK(ecode3)) {
33287 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
33288 }
33289 arg3 = static_cast< int >(val3);
33290 ecode4 = SWIG_AsVal_int(obj3, &val4);
33291 if (!SWIG_IsOK(ecode4)) {
33292 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
33293 }
33294 arg4 = static_cast< wxDragResult >(val4);
33295 {
33296 PyThreadState* __tstate = wxPyBeginAllowThreads();
33297 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
33298 wxPyEndAllowThreads(__tstate);
33299 if (PyErr_Occurred()) SWIG_fail;
33300 }
33301 resultobj = SWIG_From_int(static_cast< int >(result));
33302 return resultobj;
33303 fail:
33304 return NULL;
33305 }
33306
33307
33308 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33309 PyObject *resultobj = 0;
33310 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33311 int arg2 ;
33312 int arg3 ;
33313 wxDragResult arg4 ;
33314 wxDragResult result;
33315 void *argp1 = 0 ;
33316 int res1 = 0 ;
33317 int val2 ;
33318 int ecode2 = 0 ;
33319 int val3 ;
33320 int ecode3 = 0 ;
33321 int val4 ;
33322 int ecode4 = 0 ;
33323 PyObject * obj0 = 0 ;
33324 PyObject * obj1 = 0 ;
33325 PyObject * obj2 = 0 ;
33326 PyObject * obj3 = 0 ;
33327 char * kwnames[] = {
33328 (char *) "self",(char *) "x",(char *) "y",(char *) "_def", NULL
33329 };
33330
33331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33332 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33333 if (!SWIG_IsOK(res1)) {
33334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33335 }
33336 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33337 ecode2 = SWIG_AsVal_int(obj1, &val2);
33338 if (!SWIG_IsOK(ecode2)) {
33339 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
33340 }
33341 arg2 = static_cast< int >(val2);
33342 ecode3 = SWIG_AsVal_int(obj2, &val3);
33343 if (!SWIG_IsOK(ecode3)) {
33344 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
33345 }
33346 arg3 = static_cast< int >(val3);
33347 ecode4 = SWIG_AsVal_int(obj3, &val4);
33348 if (!SWIG_IsOK(ecode4)) {
33349 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
33350 }
33351 arg4 = static_cast< wxDragResult >(val4);
33352 {
33353 PyThreadState* __tstate = wxPyBeginAllowThreads();
33354 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
33355 wxPyEndAllowThreads(__tstate);
33356 if (PyErr_Occurred()) SWIG_fail;
33357 }
33358 resultobj = SWIG_From_int(static_cast< int >(result));
33359 return resultobj;
33360 fail:
33361 return NULL;
33362 }
33363
33364
33365 SWIGINTERN PyObject *_wrap_TextDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33366 PyObject *resultobj = 0;
33367 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33368 void *argp1 = 0 ;
33369 int res1 = 0 ;
33370 PyObject *swig_obj[1] ;
33371
33372 if (!args) SWIG_fail;
33373 swig_obj[0] = args;
33374 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33375 if (!SWIG_IsOK(res1)) {
33376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33377 }
33378 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33379 {
33380 PyThreadState* __tstate = wxPyBeginAllowThreads();
33381 (arg1)->OnLeave();
33382 wxPyEndAllowThreads(__tstate);
33383 if (PyErr_Occurred()) SWIG_fail;
33384 }
33385 resultobj = SWIG_Py_Void();
33386 return resultobj;
33387 fail:
33388 return NULL;
33389 }
33390
33391
33392 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33393 PyObject *resultobj = 0;
33394 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33395 int arg2 ;
33396 int arg3 ;
33397 bool result;
33398 void *argp1 = 0 ;
33399 int res1 = 0 ;
33400 int val2 ;
33401 int ecode2 = 0 ;
33402 int val3 ;
33403 int ecode3 = 0 ;
33404 PyObject * obj0 = 0 ;
33405 PyObject * obj1 = 0 ;
33406 PyObject * obj2 = 0 ;
33407 char * kwnames[] = {
33408 (char *) "self",(char *) "x",(char *) "y", NULL
33409 };
33410
33411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33412 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33413 if (!SWIG_IsOK(res1)) {
33414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33415 }
33416 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33417 ecode2 = SWIG_AsVal_int(obj1, &val2);
33418 if (!SWIG_IsOK(ecode2)) {
33419 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
33420 }
33421 arg2 = static_cast< int >(val2);
33422 ecode3 = SWIG_AsVal_int(obj2, &val3);
33423 if (!SWIG_IsOK(ecode3)) {
33424 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
33425 }
33426 arg3 = static_cast< int >(val3);
33427 {
33428 PyThreadState* __tstate = wxPyBeginAllowThreads();
33429 result = (bool)(arg1)->OnDrop(arg2,arg3);
33430 wxPyEndAllowThreads(__tstate);
33431 if (PyErr_Occurred()) SWIG_fail;
33432 }
33433 {
33434 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33435 }
33436 return resultobj;
33437 fail:
33438 return NULL;
33439 }
33440
33441
33442 SWIGINTERN PyObject *_wrap_TextDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33443 PyObject *resultobj = 0;
33444 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33445 int arg2 ;
33446 int arg3 ;
33447 wxDragResult arg4 ;
33448 wxDragResult result;
33449 void *argp1 = 0 ;
33450 int res1 = 0 ;
33451 int val2 ;
33452 int ecode2 = 0 ;
33453 int val3 ;
33454 int ecode3 = 0 ;
33455 int val4 ;
33456 int ecode4 = 0 ;
33457 PyObject * obj0 = 0 ;
33458 PyObject * obj1 = 0 ;
33459 PyObject * obj2 = 0 ;
33460 PyObject * obj3 = 0 ;
33461 char * kwnames[] = {
33462 (char *) "self",(char *) "x",(char *) "y",(char *) "_def", NULL
33463 };
33464
33465 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33466 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33467 if (!SWIG_IsOK(res1)) {
33468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33469 }
33470 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33471 ecode2 = SWIG_AsVal_int(obj1, &val2);
33472 if (!SWIG_IsOK(ecode2)) {
33473 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
33474 }
33475 arg2 = static_cast< int >(val2);
33476 ecode3 = SWIG_AsVal_int(obj2, &val3);
33477 if (!SWIG_IsOK(ecode3)) {
33478 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
33479 }
33480 arg3 = static_cast< int >(val3);
33481 ecode4 = SWIG_AsVal_int(obj3, &val4);
33482 if (!SWIG_IsOK(ecode4)) {
33483 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
33484 }
33485 arg4 = static_cast< wxDragResult >(val4);
33486 {
33487 PyThreadState* __tstate = wxPyBeginAllowThreads();
33488 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
33489 wxPyEndAllowThreads(__tstate);
33490 if (PyErr_Occurred()) SWIG_fail;
33491 }
33492 resultobj = SWIG_From_int(static_cast< int >(result));
33493 return resultobj;
33494 fail:
33495 return NULL;
33496 }
33497
33498
33499 SWIGINTERN PyObject *TextDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33500 PyObject *obj;
33501 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33502 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDropTarget, SWIG_NewClientData(obj));
33503 return SWIG_Py_Void();
33504 }
33505
33506 SWIGINTERN PyObject *TextDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33507 return SWIG_Python_InitShadowInstance(args);
33508 }
33509
33510 SWIGINTERN PyObject *_wrap_new_FileDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33511 PyObject *resultobj = 0;
33512 wxPyFileDropTarget *result = 0 ;
33513
33514 if (!SWIG_Python_UnpackTuple(args,"new_FileDropTarget",0,0,0)) SWIG_fail;
33515 {
33516 PyThreadState* __tstate = wxPyBeginAllowThreads();
33517 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
33518 wxPyEndAllowThreads(__tstate);
33519 if (PyErr_Occurred()) SWIG_fail;
33520 }
33521 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_NEW | 0 );
33522 return resultobj;
33523 fail:
33524 return NULL;
33525 }
33526
33527
33528 SWIGINTERN PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33529 PyObject *resultobj = 0;
33530 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33531 PyObject *arg2 = (PyObject *) 0 ;
33532 PyObject *arg3 = (PyObject *) 0 ;
33533 void *argp1 = 0 ;
33534 int res1 = 0 ;
33535 PyObject * obj0 = 0 ;
33536 PyObject * obj1 = 0 ;
33537 PyObject * obj2 = 0 ;
33538 char * kwnames[] = {
33539 (char *) "self",(char *) "self",(char *) "_class", NULL
33540 };
33541
33542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33543 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33544 if (!SWIG_IsOK(res1)) {
33545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33546 }
33547 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33548 arg2 = obj1;
33549 arg3 = obj2;
33550 {
33551 PyThreadState* __tstate = wxPyBeginAllowThreads();
33552 (arg1)->_setCallbackInfo(arg2,arg3);
33553 wxPyEndAllowThreads(__tstate);
33554 if (PyErr_Occurred()) SWIG_fail;
33555 }
33556 resultobj = SWIG_Py_Void();
33557 return resultobj;
33558 fail:
33559 return NULL;
33560 }
33561
33562
33563 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDropFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33564 PyObject *resultobj = 0;
33565 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33566 int arg2 ;
33567 int arg3 ;
33568 wxArrayString *arg4 = 0 ;
33569 bool result;
33570 void *argp1 = 0 ;
33571 int res1 = 0 ;
33572 int val2 ;
33573 int ecode2 = 0 ;
33574 int val3 ;
33575 int ecode3 = 0 ;
33576 bool temp4 = false ;
33577 PyObject * obj0 = 0 ;
33578 PyObject * obj1 = 0 ;
33579 PyObject * obj2 = 0 ;
33580 PyObject * obj3 = 0 ;
33581 char * kwnames[] = {
33582 (char *) "self",(char *) "x",(char *) "y",(char *) "filenames", NULL
33583 };
33584
33585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDropFiles",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33586 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33587 if (!SWIG_IsOK(res1)) {
33588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33589 }
33590 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33591 ecode2 = SWIG_AsVal_int(obj1, &val2);
33592 if (!SWIG_IsOK(ecode2)) {
33593 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "2"" of type '" "int""'");
33594 }
33595 arg2 = static_cast< int >(val2);
33596 ecode3 = SWIG_AsVal_int(obj2, &val3);
33597 if (!SWIG_IsOK(ecode3)) {
33598 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "3"" of type '" "int""'");
33599 }
33600 arg3 = static_cast< int >(val3);
33601 {
33602 if (! PySequence_Check(obj3)) {
33603 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
33604 SWIG_fail;
33605 }
33606 arg4 = new wxArrayString;
33607 temp4 = true;
33608 int i, len=PySequence_Length(obj3);
33609 for (i=0; i<len; i++) {
33610 PyObject* item = PySequence_GetItem(obj3, i);
33611 wxString* s = wxString_in_helper(item);
33612 if (PyErr_Occurred()) SWIG_fail;
33613 arg4->Add(*s);
33614 delete s;
33615 Py_DECREF(item);
33616 }
33617 }
33618 {
33619 PyThreadState* __tstate = wxPyBeginAllowThreads();
33620 result = (bool)(arg1)->OnDropFiles(arg2,arg3,(wxArrayString const &)*arg4);
33621 wxPyEndAllowThreads(__tstate);
33622 if (PyErr_Occurred()) SWIG_fail;
33623 }
33624 {
33625 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33626 }
33627 {
33628 if (temp4) delete arg4;
33629 }
33630 return resultobj;
33631 fail:
33632 {
33633 if (temp4) delete arg4;
33634 }
33635 return NULL;
33636 }
33637
33638
33639 SWIGINTERN PyObject *_wrap_FileDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33640 PyObject *resultobj = 0;
33641 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33642 int arg2 ;
33643 int arg3 ;
33644 wxDragResult arg4 ;
33645 wxDragResult result;
33646 void *argp1 = 0 ;
33647 int res1 = 0 ;
33648 int val2 ;
33649 int ecode2 = 0 ;
33650 int val3 ;
33651 int ecode3 = 0 ;
33652 int val4 ;
33653 int ecode4 = 0 ;
33654 PyObject * obj0 = 0 ;
33655 PyObject * obj1 = 0 ;
33656 PyObject * obj2 = 0 ;
33657 PyObject * obj3 = 0 ;
33658 char * kwnames[] = {
33659 (char *) "self",(char *) "x",(char *) "y",(char *) "_def", NULL
33660 };
33661
33662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33664 if (!SWIG_IsOK(res1)) {
33665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33666 }
33667 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33668 ecode2 = SWIG_AsVal_int(obj1, &val2);
33669 if (!SWIG_IsOK(ecode2)) {
33670 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
33671 }
33672 arg2 = static_cast< int >(val2);
33673 ecode3 = SWIG_AsVal_int(obj2, &val3);
33674 if (!SWIG_IsOK(ecode3)) {
33675 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
33676 }
33677 arg3 = static_cast< int >(val3);
33678 ecode4 = SWIG_AsVal_int(obj3, &val4);
33679 if (!SWIG_IsOK(ecode4)) {
33680 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
33681 }
33682 arg4 = static_cast< wxDragResult >(val4);
33683 {
33684 PyThreadState* __tstate = wxPyBeginAllowThreads();
33685 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
33686 wxPyEndAllowThreads(__tstate);
33687 if (PyErr_Occurred()) SWIG_fail;
33688 }
33689 resultobj = SWIG_From_int(static_cast< int >(result));
33690 return resultobj;
33691 fail:
33692 return NULL;
33693 }
33694
33695
33696 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33697 PyObject *resultobj = 0;
33698 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33699 int arg2 ;
33700 int arg3 ;
33701 wxDragResult arg4 ;
33702 wxDragResult result;
33703 void *argp1 = 0 ;
33704 int res1 = 0 ;
33705 int val2 ;
33706 int ecode2 = 0 ;
33707 int val3 ;
33708 int ecode3 = 0 ;
33709 int val4 ;
33710 int ecode4 = 0 ;
33711 PyObject * obj0 = 0 ;
33712 PyObject * obj1 = 0 ;
33713 PyObject * obj2 = 0 ;
33714 PyObject * obj3 = 0 ;
33715 char * kwnames[] = {
33716 (char *) "self",(char *) "x",(char *) "y",(char *) "_def", NULL
33717 };
33718
33719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33721 if (!SWIG_IsOK(res1)) {
33722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33723 }
33724 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33725 ecode2 = SWIG_AsVal_int(obj1, &val2);
33726 if (!SWIG_IsOK(ecode2)) {
33727 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
33728 }
33729 arg2 = static_cast< int >(val2);
33730 ecode3 = SWIG_AsVal_int(obj2, &val3);
33731 if (!SWIG_IsOK(ecode3)) {
33732 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
33733 }
33734 arg3 = static_cast< int >(val3);
33735 ecode4 = SWIG_AsVal_int(obj3, &val4);
33736 if (!SWIG_IsOK(ecode4)) {
33737 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
33738 }
33739 arg4 = static_cast< wxDragResult >(val4);
33740 {
33741 PyThreadState* __tstate = wxPyBeginAllowThreads();
33742 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
33743 wxPyEndAllowThreads(__tstate);
33744 if (PyErr_Occurred()) SWIG_fail;
33745 }
33746 resultobj = SWIG_From_int(static_cast< int >(result));
33747 return resultobj;
33748 fail:
33749 return NULL;
33750 }
33751
33752
33753 SWIGINTERN PyObject *_wrap_FileDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33754 PyObject *resultobj = 0;
33755 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33756 void *argp1 = 0 ;
33757 int res1 = 0 ;
33758 PyObject *swig_obj[1] ;
33759
33760 if (!args) SWIG_fail;
33761 swig_obj[0] = args;
33762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33763 if (!SWIG_IsOK(res1)) {
33764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33765 }
33766 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33767 {
33768 PyThreadState* __tstate = wxPyBeginAllowThreads();
33769 (arg1)->OnLeave();
33770 wxPyEndAllowThreads(__tstate);
33771 if (PyErr_Occurred()) SWIG_fail;
33772 }
33773 resultobj = SWIG_Py_Void();
33774 return resultobj;
33775 fail:
33776 return NULL;
33777 }
33778
33779
33780 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33781 PyObject *resultobj = 0;
33782 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33783 int arg2 ;
33784 int arg3 ;
33785 bool result;
33786 void *argp1 = 0 ;
33787 int res1 = 0 ;
33788 int val2 ;
33789 int ecode2 = 0 ;
33790 int val3 ;
33791 int ecode3 = 0 ;
33792 PyObject * obj0 = 0 ;
33793 PyObject * obj1 = 0 ;
33794 PyObject * obj2 = 0 ;
33795 char * kwnames[] = {
33796 (char *) "self",(char *) "x",(char *) "y", NULL
33797 };
33798
33799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33800 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33801 if (!SWIG_IsOK(res1)) {
33802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33803 }
33804 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33805 ecode2 = SWIG_AsVal_int(obj1, &val2);
33806 if (!SWIG_IsOK(ecode2)) {
33807 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
33808 }
33809 arg2 = static_cast< int >(val2);
33810 ecode3 = SWIG_AsVal_int(obj2, &val3);
33811 if (!SWIG_IsOK(ecode3)) {
33812 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
33813 }
33814 arg3 = static_cast< int >(val3);
33815 {
33816 PyThreadState* __tstate = wxPyBeginAllowThreads();
33817 result = (bool)(arg1)->OnDrop(arg2,arg3);
33818 wxPyEndAllowThreads(__tstate);
33819 if (PyErr_Occurred()) SWIG_fail;
33820 }
33821 {
33822 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33823 }
33824 return resultobj;
33825 fail:
33826 return NULL;
33827 }
33828
33829
33830 SWIGINTERN PyObject *_wrap_FileDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33831 PyObject *resultobj = 0;
33832 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33833 int arg2 ;
33834 int arg3 ;
33835 wxDragResult arg4 ;
33836 wxDragResult result;
33837 void *argp1 = 0 ;
33838 int res1 = 0 ;
33839 int val2 ;
33840 int ecode2 = 0 ;
33841 int val3 ;
33842 int ecode3 = 0 ;
33843 int val4 ;
33844 int ecode4 = 0 ;
33845 PyObject * obj0 = 0 ;
33846 PyObject * obj1 = 0 ;
33847 PyObject * obj2 = 0 ;
33848 PyObject * obj3 = 0 ;
33849 char * kwnames[] = {
33850 (char *) "self",(char *) "x",(char *) "y",(char *) "_def", NULL
33851 };
33852
33853 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33854 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33855 if (!SWIG_IsOK(res1)) {
33856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33857 }
33858 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33859 ecode2 = SWIG_AsVal_int(obj1, &val2);
33860 if (!SWIG_IsOK(ecode2)) {
33861 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
33862 }
33863 arg2 = static_cast< int >(val2);
33864 ecode3 = SWIG_AsVal_int(obj2, &val3);
33865 if (!SWIG_IsOK(ecode3)) {
33866 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
33867 }
33868 arg3 = static_cast< int >(val3);
33869 ecode4 = SWIG_AsVal_int(obj3, &val4);
33870 if (!SWIG_IsOK(ecode4)) {
33871 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
33872 }
33873 arg4 = static_cast< wxDragResult >(val4);
33874 {
33875 PyThreadState* __tstate = wxPyBeginAllowThreads();
33876 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
33877 wxPyEndAllowThreads(__tstate);
33878 if (PyErr_Occurred()) SWIG_fail;
33879 }
33880 resultobj = SWIG_From_int(static_cast< int >(result));
33881 return resultobj;
33882 fail:
33883 return NULL;
33884 }
33885
33886
33887 SWIGINTERN PyObject *FileDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33888 PyObject *obj;
33889 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33890 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileDropTarget, SWIG_NewClientData(obj));
33891 return SWIG_Py_Void();
33892 }
33893
33894 SWIGINTERN PyObject *FileDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33895 return SWIG_Python_InitShadowInstance(args);
33896 }
33897
33898 SWIGINTERN PyObject *_wrap_new_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33899 PyObject *resultobj = 0;
33900 wxClipboard *result = 0 ;
33901
33902 if (!SWIG_Python_UnpackTuple(args,"new_Clipboard",0,0,0)) SWIG_fail;
33903 {
33904 PyThreadState* __tstate = wxPyBeginAllowThreads();
33905 result = (wxClipboard *)new wxClipboard();
33906 wxPyEndAllowThreads(__tstate);
33907 if (PyErr_Occurred()) SWIG_fail;
33908 }
33909 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, SWIG_POINTER_NEW | 0 );
33910 return resultobj;
33911 fail:
33912 return NULL;
33913 }
33914
33915
33916 SWIGINTERN PyObject *_wrap_delete_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33917 PyObject *resultobj = 0;
33918 wxClipboard *arg1 = (wxClipboard *) 0 ;
33919 void *argp1 = 0 ;
33920 int res1 = 0 ;
33921 PyObject *swig_obj[1] ;
33922
33923 if (!args) SWIG_fail;
33924 swig_obj[0] = args;
33925 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, SWIG_POINTER_DISOWN | 0 );
33926 if (!SWIG_IsOK(res1)) {
33927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Clipboard" "', expected argument " "1"" of type '" "wxClipboard *""'");
33928 }
33929 arg1 = reinterpret_cast< wxClipboard * >(argp1);
33930 {
33931 PyThreadState* __tstate = wxPyBeginAllowThreads();
33932 delete arg1;
33933
33934 wxPyEndAllowThreads(__tstate);
33935 if (PyErr_Occurred()) SWIG_fail;
33936 }
33937 resultobj = SWIG_Py_Void();
33938 return resultobj;
33939 fail:
33940 return NULL;
33941 }
33942
33943
33944 SWIGINTERN PyObject *_wrap_Clipboard_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33945 PyObject *resultobj = 0;
33946 wxClipboard *arg1 = (wxClipboard *) 0 ;
33947 bool result;
33948 void *argp1 = 0 ;
33949 int res1 = 0 ;
33950 PyObject *swig_obj[1] ;
33951
33952 if (!args) SWIG_fail;
33953 swig_obj[0] = args;
33954 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
33955 if (!SWIG_IsOK(res1)) {
33956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Open" "', expected argument " "1"" of type '" "wxClipboard *""'");
33957 }
33958 arg1 = reinterpret_cast< wxClipboard * >(argp1);
33959 {
33960 PyThreadState* __tstate = wxPyBeginAllowThreads();
33961 result = (bool)(arg1)->Open();
33962 wxPyEndAllowThreads(__tstate);
33963 if (PyErr_Occurred()) SWIG_fail;
33964 }
33965 {
33966 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33967 }
33968 return resultobj;
33969 fail:
33970 return NULL;
33971 }
33972
33973
33974 SWIGINTERN PyObject *_wrap_Clipboard_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33975 PyObject *resultobj = 0;
33976 wxClipboard *arg1 = (wxClipboard *) 0 ;
33977 void *argp1 = 0 ;
33978 int res1 = 0 ;
33979 PyObject *swig_obj[1] ;
33980
33981 if (!args) SWIG_fail;
33982 swig_obj[0] = args;
33983 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
33984 if (!SWIG_IsOK(res1)) {
33985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Close" "', expected argument " "1"" of type '" "wxClipboard *""'");
33986 }
33987 arg1 = reinterpret_cast< wxClipboard * >(argp1);
33988 {
33989 PyThreadState* __tstate = wxPyBeginAllowThreads();
33990 (arg1)->Close();
33991 wxPyEndAllowThreads(__tstate);
33992 if (PyErr_Occurred()) SWIG_fail;
33993 }
33994 resultobj = SWIG_Py_Void();
33995 return resultobj;
33996 fail:
33997 return NULL;
33998 }
33999
34000
34001 SWIGINTERN PyObject *_wrap_Clipboard_IsOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34002 PyObject *resultobj = 0;
34003 wxClipboard *arg1 = (wxClipboard *) 0 ;
34004 bool result;
34005 void *argp1 = 0 ;
34006 int res1 = 0 ;
34007 PyObject *swig_obj[1] ;
34008
34009 if (!args) SWIG_fail;
34010 swig_obj[0] = args;
34011 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34012 if (!SWIG_IsOK(res1)) {
34013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsOpened" "', expected argument " "1"" of type '" "wxClipboard const *""'");
34014 }
34015 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34016 {
34017 PyThreadState* __tstate = wxPyBeginAllowThreads();
34018 result = (bool)((wxClipboard const *)arg1)->IsOpened();
34019 wxPyEndAllowThreads(__tstate);
34020 if (PyErr_Occurred()) SWIG_fail;
34021 }
34022 {
34023 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34024 }
34025 return resultobj;
34026 fail:
34027 return NULL;
34028 }
34029
34030
34031 SWIGINTERN PyObject *_wrap_Clipboard_AddData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34032 PyObject *resultobj = 0;
34033 wxClipboard *arg1 = (wxClipboard *) 0 ;
34034 wxDataObject *arg2 = (wxDataObject *) 0 ;
34035 bool result;
34036 void *argp1 = 0 ;
34037 int res1 = 0 ;
34038 int res2 = 0 ;
34039 PyObject * obj0 = 0 ;
34040 PyObject * obj1 = 0 ;
34041 char * kwnames[] = {
34042 (char *) "self",(char *) "data", NULL
34043 };
34044
34045 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) SWIG_fail;
34046 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34047 if (!SWIG_IsOK(res1)) {
34048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_AddData" "', expected argument " "1"" of type '" "wxClipboard *""'");
34049 }
34050 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34051 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34052 if (!SWIG_IsOK(res2)) {
34053 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_AddData" "', expected argument " "2"" of type '" "wxDataObject *""'");
34054 }
34055 {
34056 PyThreadState* __tstate = wxPyBeginAllowThreads();
34057 result = (bool)(arg1)->AddData(arg2);
34058 wxPyEndAllowThreads(__tstate);
34059 if (PyErr_Occurred()) SWIG_fail;
34060 }
34061 {
34062 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34063 }
34064 return resultobj;
34065 fail:
34066 return NULL;
34067 }
34068
34069
34070 SWIGINTERN PyObject *_wrap_Clipboard_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34071 PyObject *resultobj = 0;
34072 wxClipboard *arg1 = (wxClipboard *) 0 ;
34073 wxDataObject *arg2 = (wxDataObject *) 0 ;
34074 bool result;
34075 void *argp1 = 0 ;
34076 int res1 = 0 ;
34077 int res2 = 0 ;
34078 PyObject * obj0 = 0 ;
34079 PyObject * obj1 = 0 ;
34080 char * kwnames[] = {
34081 (char *) "self",(char *) "data", NULL
34082 };
34083
34084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
34085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34086 if (!SWIG_IsOK(res1)) {
34087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_SetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
34088 }
34089 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34090 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34091 if (!SWIG_IsOK(res2)) {
34092 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_SetData" "', expected argument " "2"" of type '" "wxDataObject *""'");
34093 }
34094 {
34095 PyThreadState* __tstate = wxPyBeginAllowThreads();
34096 result = (bool)(arg1)->SetData(arg2);
34097 wxPyEndAllowThreads(__tstate);
34098 if (PyErr_Occurred()) SWIG_fail;
34099 }
34100 {
34101 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34102 }
34103 return resultobj;
34104 fail:
34105 return NULL;
34106 }
34107
34108
34109 SWIGINTERN PyObject *_wrap_Clipboard_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34110 PyObject *resultobj = 0;
34111 wxClipboard *arg1 = (wxClipboard *) 0 ;
34112 wxDataFormat *arg2 = 0 ;
34113 bool result;
34114 void *argp1 = 0 ;
34115 int res1 = 0 ;
34116 void *argp2 = 0 ;
34117 int res2 = 0 ;
34118 PyObject * obj0 = 0 ;
34119 PyObject * obj1 = 0 ;
34120 char * kwnames[] = {
34121 (char *) "self",(char *) "format", NULL
34122 };
34123
34124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) SWIG_fail;
34125 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34126 if (!SWIG_IsOK(res1)) {
34127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsSupported" "', expected argument " "1"" of type '" "wxClipboard *""'");
34128 }
34129 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34130 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
34131 if (!SWIG_IsOK(res2)) {
34132 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
34133 }
34134 if (!argp2) {
34135 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
34136 }
34137 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
34138 {
34139 PyThreadState* __tstate = wxPyBeginAllowThreads();
34140 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
34141 wxPyEndAllowThreads(__tstate);
34142 if (PyErr_Occurred()) SWIG_fail;
34143 }
34144 {
34145 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34146 }
34147 return resultobj;
34148 fail:
34149 return NULL;
34150 }
34151
34152
34153 SWIGINTERN PyObject *_wrap_Clipboard_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34154 PyObject *resultobj = 0;
34155 wxClipboard *arg1 = (wxClipboard *) 0 ;
34156 wxDataObject *arg2 = 0 ;
34157 bool result;
34158 void *argp1 = 0 ;
34159 int res1 = 0 ;
34160 void *argp2 = 0 ;
34161 int res2 = 0 ;
34162 PyObject * obj0 = 0 ;
34163 PyObject * obj1 = 0 ;
34164 char * kwnames[] = {
34165 (char *) "self",(char *) "data", NULL
34166 };
34167
34168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) SWIG_fail;
34169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34170 if (!SWIG_IsOK(res1)) {
34171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_GetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
34172 }
34173 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34174 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
34175 if (!SWIG_IsOK(res2)) {
34176 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
34177 }
34178 if (!argp2) {
34179 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
34180 }
34181 arg2 = reinterpret_cast< wxDataObject * >(argp2);
34182 {
34183 PyThreadState* __tstate = wxPyBeginAllowThreads();
34184 result = (bool)(arg1)->GetData(*arg2);
34185 wxPyEndAllowThreads(__tstate);
34186 if (PyErr_Occurred()) SWIG_fail;
34187 }
34188 {
34189 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34190 }
34191 return resultobj;
34192 fail:
34193 return NULL;
34194 }
34195
34196
34197 SWIGINTERN PyObject *_wrap_Clipboard_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34198 PyObject *resultobj = 0;
34199 wxClipboard *arg1 = (wxClipboard *) 0 ;
34200 void *argp1 = 0 ;
34201 int res1 = 0 ;
34202 PyObject *swig_obj[1] ;
34203
34204 if (!args) SWIG_fail;
34205 swig_obj[0] = args;
34206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34207 if (!SWIG_IsOK(res1)) {
34208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Clear" "', expected argument " "1"" of type '" "wxClipboard *""'");
34209 }
34210 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34211 {
34212 PyThreadState* __tstate = wxPyBeginAllowThreads();
34213 (arg1)->Clear();
34214 wxPyEndAllowThreads(__tstate);
34215 if (PyErr_Occurred()) SWIG_fail;
34216 }
34217 resultobj = SWIG_Py_Void();
34218 return resultobj;
34219 fail:
34220 return NULL;
34221 }
34222
34223
34224 SWIGINTERN PyObject *_wrap_Clipboard_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34225 PyObject *resultobj = 0;
34226 wxClipboard *arg1 = (wxClipboard *) 0 ;
34227 bool result;
34228 void *argp1 = 0 ;
34229 int res1 = 0 ;
34230 PyObject *swig_obj[1] ;
34231
34232 if (!args) SWIG_fail;
34233 swig_obj[0] = args;
34234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34235 if (!SWIG_IsOK(res1)) {
34236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Flush" "', expected argument " "1"" of type '" "wxClipboard *""'");
34237 }
34238 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34239 {
34240 PyThreadState* __tstate = wxPyBeginAllowThreads();
34241 result = (bool)(arg1)->Flush();
34242 wxPyEndAllowThreads(__tstate);
34243 if (PyErr_Occurred()) SWIG_fail;
34244 }
34245 {
34246 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34247 }
34248 return resultobj;
34249 fail:
34250 return NULL;
34251 }
34252
34253
34254 SWIGINTERN PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34255 PyObject *resultobj = 0;
34256 wxClipboard *arg1 = (wxClipboard *) 0 ;
34257 bool arg2 = (bool) true ;
34258 void *argp1 = 0 ;
34259 int res1 = 0 ;
34260 bool val2 ;
34261 int ecode2 = 0 ;
34262 PyObject * obj0 = 0 ;
34263 PyObject * obj1 = 0 ;
34264 char * kwnames[] = {
34265 (char *) "self",(char *) "primary", NULL
34266 };
34267
34268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) SWIG_fail;
34269 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34270 if (!SWIG_IsOK(res1)) {
34271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "1"" of type '" "wxClipboard *""'");
34272 }
34273 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34274 if (obj1) {
34275 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34276 if (!SWIG_IsOK(ecode2)) {
34277 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "2"" of type '" "bool""'");
34278 }
34279 arg2 = static_cast< bool >(val2);
34280 }
34281 {
34282 PyThreadState* __tstate = wxPyBeginAllowThreads();
34283 (arg1)->UsePrimarySelection(arg2);
34284 wxPyEndAllowThreads(__tstate);
34285 if (PyErr_Occurred()) SWIG_fail;
34286 }
34287 resultobj = SWIG_Py_Void();
34288 return resultobj;
34289 fail:
34290 return NULL;
34291 }
34292
34293
34294 SWIGINTERN PyObject *_wrap_Clipboard_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34295 PyObject *resultobj = 0;
34296 wxClipboard *result = 0 ;
34297
34298 if (!SWIG_Python_UnpackTuple(args,"Clipboard_Get",0,0,0)) SWIG_fail;
34299 {
34300 PyThreadState* __tstate = wxPyBeginAllowThreads();
34301 result = (wxClipboard *)wxClipboard::Get();
34302 wxPyEndAllowThreads(__tstate);
34303 if (PyErr_Occurred()) SWIG_fail;
34304 }
34305 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, 0 | 0 );
34306 return resultobj;
34307 fail:
34308 return NULL;
34309 }
34310
34311
34312 SWIGINTERN PyObject *Clipboard_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34313 PyObject *obj;
34314 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34315 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboard, SWIG_NewClientData(obj));
34316 return SWIG_Py_Void();
34317 }
34318
34319 SWIGINTERN PyObject *Clipboard_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34320 return SWIG_Python_InitShadowInstance(args);
34321 }
34322
34323 SWIGINTERN PyObject *_wrap_new_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34324 PyObject *resultobj = 0;
34325 wxClipboard *arg1 = (wxClipboard *) NULL ;
34326 wxClipboardLocker *result = 0 ;
34327 void *argp1 = 0 ;
34328 int res1 = 0 ;
34329 PyObject * obj0 = 0 ;
34330 char * kwnames[] = {
34331 (char *) "clipboard", NULL
34332 };
34333
34334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) SWIG_fail;
34335 if (obj0) {
34336 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34337 if (!SWIG_IsOK(res1)) {
34338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboard *""'");
34339 }
34340 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34341 }
34342 {
34343 PyThreadState* __tstate = wxPyBeginAllowThreads();
34344 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
34345 wxPyEndAllowThreads(__tstate);
34346 if (PyErr_Occurred()) SWIG_fail;
34347 }
34348 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_NEW | 0 );
34349 return resultobj;
34350 fail:
34351 return NULL;
34352 }
34353
34354
34355 SWIGINTERN PyObject *_wrap_delete_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34356 PyObject *resultobj = 0;
34357 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
34358 void *argp1 = 0 ;
34359 int res1 = 0 ;
34360 PyObject *swig_obj[1] ;
34361
34362 if (!args) SWIG_fail;
34363 swig_obj[0] = args;
34364 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_DISOWN | 0 );
34365 if (!SWIG_IsOK(res1)) {
34366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
34367 }
34368 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
34369 {
34370 PyThreadState* __tstate = wxPyBeginAllowThreads();
34371 delete arg1;
34372
34373 wxPyEndAllowThreads(__tstate);
34374 if (PyErr_Occurred()) SWIG_fail;
34375 }
34376 resultobj = SWIG_Py_Void();
34377 return resultobj;
34378 fail:
34379 return NULL;
34380 }
34381
34382
34383 SWIGINTERN PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34384 PyObject *resultobj = 0;
34385 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
34386 bool result;
34387 void *argp1 = 0 ;
34388 int res1 = 0 ;
34389 PyObject *swig_obj[1] ;
34390
34391 if (!args) SWIG_fail;
34392 swig_obj[0] = args;
34393 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, 0 | 0 );
34394 if (!SWIG_IsOK(res1)) {
34395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClipboardLocker___nonzero__" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
34396 }
34397 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
34398 {
34399 PyThreadState* __tstate = wxPyBeginAllowThreads();
34400 result = (bool)wxClipboardLocker___nonzero__(arg1);
34401 wxPyEndAllowThreads(__tstate);
34402 if (PyErr_Occurred()) SWIG_fail;
34403 }
34404 {
34405 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34406 }
34407 return resultobj;
34408 fail:
34409 return NULL;
34410 }
34411
34412
34413 SWIGINTERN PyObject *ClipboardLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34414 PyObject *obj;
34415 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34416 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardLocker, SWIG_NewClientData(obj));
34417 return SWIG_Py_Void();
34418 }
34419
34420 SWIGINTERN PyObject *ClipboardLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34421 return SWIG_Python_InitShadowInstance(args);
34422 }
34423
34424 SWIGINTERN PyObject *_wrap_new_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34425 PyObject *resultobj = 0;
34426 int arg1 = (int) 0 ;
34427 int arg2 = (int) 0 ;
34428 int arg3 = (int) 0 ;
34429 int arg4 = (int) 0 ;
34430 wxVideoMode *result = 0 ;
34431 int val1 ;
34432 int ecode1 = 0 ;
34433 int val2 ;
34434 int ecode2 = 0 ;
34435 int val3 ;
34436 int ecode3 = 0 ;
34437 int val4 ;
34438 int ecode4 = 0 ;
34439 PyObject * obj0 = 0 ;
34440 PyObject * obj1 = 0 ;
34441 PyObject * obj2 = 0 ;
34442 PyObject * obj3 = 0 ;
34443 char * kwnames[] = {
34444 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
34445 };
34446
34447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34448 if (obj0) {
34449 ecode1 = SWIG_AsVal_int(obj0, &val1);
34450 if (!SWIG_IsOK(ecode1)) {
34451 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VideoMode" "', expected argument " "1"" of type '" "int""'");
34452 }
34453 arg1 = static_cast< int >(val1);
34454 }
34455 if (obj1) {
34456 ecode2 = SWIG_AsVal_int(obj1, &val2);
34457 if (!SWIG_IsOK(ecode2)) {
34458 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VideoMode" "', expected argument " "2"" of type '" "int""'");
34459 }
34460 arg2 = static_cast< int >(val2);
34461 }
34462 if (obj2) {
34463 ecode3 = SWIG_AsVal_int(obj2, &val3);
34464 if (!SWIG_IsOK(ecode3)) {
34465 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_VideoMode" "', expected argument " "3"" of type '" "int""'");
34466 }
34467 arg3 = static_cast< int >(val3);
34468 }
34469 if (obj3) {
34470 ecode4 = SWIG_AsVal_int(obj3, &val4);
34471 if (!SWIG_IsOK(ecode4)) {
34472 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_VideoMode" "', expected argument " "4"" of type '" "int""'");
34473 }
34474 arg4 = static_cast< int >(val4);
34475 }
34476 {
34477 PyThreadState* __tstate = wxPyBeginAllowThreads();
34478 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
34479 wxPyEndAllowThreads(__tstate);
34480 if (PyErr_Occurred()) SWIG_fail;
34481 }
34482 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_NEW | 0 );
34483 return resultobj;
34484 fail:
34485 return NULL;
34486 }
34487
34488
34489 SWIGINTERN PyObject *_wrap_delete_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34490 PyObject *resultobj = 0;
34491 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34492 void *argp1 = 0 ;
34493 int res1 = 0 ;
34494 PyObject *swig_obj[1] ;
34495
34496 if (!args) SWIG_fail;
34497 swig_obj[0] = args;
34498 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, SWIG_POINTER_DISOWN | 0 );
34499 if (!SWIG_IsOK(res1)) {
34500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VideoMode" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34501 }
34502 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34503 {
34504 PyThreadState* __tstate = wxPyBeginAllowThreads();
34505 delete arg1;
34506
34507 wxPyEndAllowThreads(__tstate);
34508 if (PyErr_Occurred()) SWIG_fail;
34509 }
34510 resultobj = SWIG_Py_Void();
34511 return resultobj;
34512 fail:
34513 return NULL;
34514 }
34515
34516
34517 SWIGINTERN PyObject *_wrap_VideoMode_Matches(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34518 PyObject *resultobj = 0;
34519 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34520 wxVideoMode *arg2 = 0 ;
34521 bool result;
34522 void *argp1 = 0 ;
34523 int res1 = 0 ;
34524 void *argp2 = 0 ;
34525 int res2 = 0 ;
34526 PyObject * obj0 = 0 ;
34527 PyObject * obj1 = 0 ;
34528 char * kwnames[] = {
34529 (char *) "self",(char *) "other", NULL
34530 };
34531
34532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) SWIG_fail;
34533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34534 if (!SWIG_IsOK(res1)) {
34535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_Matches" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34536 }
34537 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34538 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
34539 if (!SWIG_IsOK(res2)) {
34540 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
34541 }
34542 if (!argp2) {
34543 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
34544 }
34545 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
34546 {
34547 PyThreadState* __tstate = wxPyBeginAllowThreads();
34548 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
34549 wxPyEndAllowThreads(__tstate);
34550 if (PyErr_Occurred()) SWIG_fail;
34551 }
34552 {
34553 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34554 }
34555 return resultobj;
34556 fail:
34557 return NULL;
34558 }
34559
34560
34561 SWIGINTERN PyObject *_wrap_VideoMode_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34562 PyObject *resultobj = 0;
34563 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34564 int result;
34565 void *argp1 = 0 ;
34566 int res1 = 0 ;
34567 PyObject *swig_obj[1] ;
34568
34569 if (!args) SWIG_fail;
34570 swig_obj[0] = args;
34571 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34572 if (!SWIG_IsOK(res1)) {
34573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetWidth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34574 }
34575 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34576 {
34577 PyThreadState* __tstate = wxPyBeginAllowThreads();
34578 result = (int)((wxVideoMode const *)arg1)->GetWidth();
34579 wxPyEndAllowThreads(__tstate);
34580 if (PyErr_Occurred()) SWIG_fail;
34581 }
34582 resultobj = SWIG_From_int(static_cast< int >(result));
34583 return resultobj;
34584 fail:
34585 return NULL;
34586 }
34587
34588
34589 SWIGINTERN PyObject *_wrap_VideoMode_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34590 PyObject *resultobj = 0;
34591 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34592 int result;
34593 void *argp1 = 0 ;
34594 int res1 = 0 ;
34595 PyObject *swig_obj[1] ;
34596
34597 if (!args) SWIG_fail;
34598 swig_obj[0] = args;
34599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34600 if (!SWIG_IsOK(res1)) {
34601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetHeight" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34602 }
34603 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34604 {
34605 PyThreadState* __tstate = wxPyBeginAllowThreads();
34606 result = (int)((wxVideoMode const *)arg1)->GetHeight();
34607 wxPyEndAllowThreads(__tstate);
34608 if (PyErr_Occurred()) SWIG_fail;
34609 }
34610 resultobj = SWIG_From_int(static_cast< int >(result));
34611 return resultobj;
34612 fail:
34613 return NULL;
34614 }
34615
34616
34617 SWIGINTERN PyObject *_wrap_VideoMode_GetDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34618 PyObject *resultobj = 0;
34619 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34620 int result;
34621 void *argp1 = 0 ;
34622 int res1 = 0 ;
34623 PyObject *swig_obj[1] ;
34624
34625 if (!args) SWIG_fail;
34626 swig_obj[0] = args;
34627 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34628 if (!SWIG_IsOK(res1)) {
34629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetDepth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34630 }
34631 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34632 {
34633 PyThreadState* __tstate = wxPyBeginAllowThreads();
34634 result = (int)((wxVideoMode const *)arg1)->GetDepth();
34635 wxPyEndAllowThreads(__tstate);
34636 if (PyErr_Occurred()) SWIG_fail;
34637 }
34638 resultobj = SWIG_From_int(static_cast< int >(result));
34639 return resultobj;
34640 fail:
34641 return NULL;
34642 }
34643
34644
34645 SWIGINTERN PyObject *_wrap_VideoMode_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34646 PyObject *resultobj = 0;
34647 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34648 bool result;
34649 void *argp1 = 0 ;
34650 int res1 = 0 ;
34651 PyObject *swig_obj[1] ;
34652
34653 if (!args) SWIG_fail;
34654 swig_obj[0] = args;
34655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34656 if (!SWIG_IsOK(res1)) {
34657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_IsOk" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34658 }
34659 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34660 {
34661 PyThreadState* __tstate = wxPyBeginAllowThreads();
34662 result = (bool)((wxVideoMode const *)arg1)->IsOk();
34663 wxPyEndAllowThreads(__tstate);
34664 if (PyErr_Occurred()) SWIG_fail;
34665 }
34666 {
34667 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34668 }
34669 return resultobj;
34670 fail:
34671 return NULL;
34672 }
34673
34674
34675 SWIGINTERN PyObject *_wrap_VideoMode___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34676 PyObject *resultobj = 0;
34677 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34678 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
34679 bool result;
34680 void *argp1 = 0 ;
34681 int res1 = 0 ;
34682 void *argp2 = 0 ;
34683 int res2 = 0 ;
34684 PyObject * obj0 = 0 ;
34685 PyObject * obj1 = 0 ;
34686 char * kwnames[] = {
34687 (char *) "self",(char *) "other", NULL
34688 };
34689
34690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
34691 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34692 if (!SWIG_IsOK(res1)) {
34693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___eq__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34694 }
34695 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34696 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34697 if (!SWIG_IsOK(res2)) {
34698 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___eq__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
34699 }
34700 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
34701 {
34702 PyThreadState* __tstate = wxPyBeginAllowThreads();
34703 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
34704 wxPyEndAllowThreads(__tstate);
34705 if (PyErr_Occurred()) SWIG_fail;
34706 }
34707 {
34708 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34709 }
34710 return resultobj;
34711 fail:
34712 return NULL;
34713 }
34714
34715
34716 SWIGINTERN PyObject *_wrap_VideoMode___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34717 PyObject *resultobj = 0;
34718 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34719 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
34720 bool result;
34721 void *argp1 = 0 ;
34722 int res1 = 0 ;
34723 void *argp2 = 0 ;
34724 int res2 = 0 ;
34725 PyObject * obj0 = 0 ;
34726 PyObject * obj1 = 0 ;
34727 char * kwnames[] = {
34728 (char *) "self",(char *) "other", NULL
34729 };
34730
34731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
34732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34733 if (!SWIG_IsOK(res1)) {
34734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___ne__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34735 }
34736 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34737 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34738 if (!SWIG_IsOK(res2)) {
34739 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___ne__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
34740 }
34741 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
34742 {
34743 PyThreadState* __tstate = wxPyBeginAllowThreads();
34744 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
34745 wxPyEndAllowThreads(__tstate);
34746 if (PyErr_Occurred()) SWIG_fail;
34747 }
34748 {
34749 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34750 }
34751 return resultobj;
34752 fail:
34753 return NULL;
34754 }
34755
34756
34757 SWIGINTERN PyObject *_wrap_VideoMode_w_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34758 PyObject *resultobj = 0;
34759 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34760 int arg2 ;
34761 void *argp1 = 0 ;
34762 int res1 = 0 ;
34763 int val2 ;
34764 int ecode2 = 0 ;
34765 PyObject *swig_obj[2] ;
34766
34767 if (!SWIG_Python_UnpackTuple(args,"VideoMode_w_set",2,2,swig_obj)) SWIG_fail;
34768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34769 if (!SWIG_IsOK(res1)) {
34770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34771 }
34772 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34773 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
34774 if (!SWIG_IsOK(ecode2)) {
34775 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_w_set" "', expected argument " "2"" of type '" "int""'");
34776 }
34777 arg2 = static_cast< int >(val2);
34778 if (arg1) (arg1)->w = arg2;
34779
34780 resultobj = SWIG_Py_Void();
34781 return resultobj;
34782 fail:
34783 return NULL;
34784 }
34785
34786
34787 SWIGINTERN PyObject *_wrap_VideoMode_w_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34788 PyObject *resultobj = 0;
34789 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34790 int result;
34791 void *argp1 = 0 ;
34792 int res1 = 0 ;
34793 PyObject *swig_obj[1] ;
34794
34795 if (!args) SWIG_fail;
34796 swig_obj[0] = args;
34797 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34798 if (!SWIG_IsOK(res1)) {
34799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34800 }
34801 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34802 result = (int) ((arg1)->w);
34803 resultobj = SWIG_From_int(static_cast< int >(result));
34804 return resultobj;
34805 fail:
34806 return NULL;
34807 }
34808
34809
34810 SWIGINTERN PyObject *_wrap_VideoMode_h_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34811 PyObject *resultobj = 0;
34812 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34813 int arg2 ;
34814 void *argp1 = 0 ;
34815 int res1 = 0 ;
34816 int val2 ;
34817 int ecode2 = 0 ;
34818 PyObject *swig_obj[2] ;
34819
34820 if (!SWIG_Python_UnpackTuple(args,"VideoMode_h_set",2,2,swig_obj)) SWIG_fail;
34821 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34822 if (!SWIG_IsOK(res1)) {
34823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34824 }
34825 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34826 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
34827 if (!SWIG_IsOK(ecode2)) {
34828 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_h_set" "', expected argument " "2"" of type '" "int""'");
34829 }
34830 arg2 = static_cast< int >(val2);
34831 if (arg1) (arg1)->h = arg2;
34832
34833 resultobj = SWIG_Py_Void();
34834 return resultobj;
34835 fail:
34836 return NULL;
34837 }
34838
34839
34840 SWIGINTERN PyObject *_wrap_VideoMode_h_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34841 PyObject *resultobj = 0;
34842 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34843 int result;
34844 void *argp1 = 0 ;
34845 int res1 = 0 ;
34846 PyObject *swig_obj[1] ;
34847
34848 if (!args) SWIG_fail;
34849 swig_obj[0] = args;
34850 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34851 if (!SWIG_IsOK(res1)) {
34852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34853 }
34854 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34855 result = (int) ((arg1)->h);
34856 resultobj = SWIG_From_int(static_cast< int >(result));
34857 return resultobj;
34858 fail:
34859 return NULL;
34860 }
34861
34862
34863 SWIGINTERN PyObject *_wrap_VideoMode_bpp_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34864 PyObject *resultobj = 0;
34865 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34866 int arg2 ;
34867 void *argp1 = 0 ;
34868 int res1 = 0 ;
34869 int val2 ;
34870 int ecode2 = 0 ;
34871 PyObject *swig_obj[2] ;
34872
34873 if (!SWIG_Python_UnpackTuple(args,"VideoMode_bpp_set",2,2,swig_obj)) SWIG_fail;
34874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34875 if (!SWIG_IsOK(res1)) {
34876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34877 }
34878 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34879 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
34880 if (!SWIG_IsOK(ecode2)) {
34881 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_bpp_set" "', expected argument " "2"" of type '" "int""'");
34882 }
34883 arg2 = static_cast< int >(val2);
34884 if (arg1) (arg1)->bpp = arg2;
34885
34886 resultobj = SWIG_Py_Void();
34887 return resultobj;
34888 fail:
34889 return NULL;
34890 }
34891
34892
34893 SWIGINTERN PyObject *_wrap_VideoMode_bpp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34894 PyObject *resultobj = 0;
34895 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34896 int result;
34897 void *argp1 = 0 ;
34898 int res1 = 0 ;
34899 PyObject *swig_obj[1] ;
34900
34901 if (!args) SWIG_fail;
34902 swig_obj[0] = args;
34903 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34904 if (!SWIG_IsOK(res1)) {
34905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34906 }
34907 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34908 result = (int) ((arg1)->bpp);
34909 resultobj = SWIG_From_int(static_cast< int >(result));
34910 return resultobj;
34911 fail:
34912 return NULL;
34913 }
34914
34915
34916 SWIGINTERN PyObject *_wrap_VideoMode_refresh_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34917 PyObject *resultobj = 0;
34918 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34919 int arg2 ;
34920 void *argp1 = 0 ;
34921 int res1 = 0 ;
34922 int val2 ;
34923 int ecode2 = 0 ;
34924 PyObject *swig_obj[2] ;
34925
34926 if (!SWIG_Python_UnpackTuple(args,"VideoMode_refresh_set",2,2,swig_obj)) SWIG_fail;
34927 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34928 if (!SWIG_IsOK(res1)) {
34929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34930 }
34931 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34932 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
34933 if (!SWIG_IsOK(ecode2)) {
34934 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_refresh_set" "', expected argument " "2"" of type '" "int""'");
34935 }
34936 arg2 = static_cast< int >(val2);
34937 if (arg1) (arg1)->refresh = arg2;
34938
34939 resultobj = SWIG_Py_Void();
34940 return resultobj;
34941 fail:
34942 return NULL;
34943 }
34944
34945
34946 SWIGINTERN PyObject *_wrap_VideoMode_refresh_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34947 PyObject *resultobj = 0;
34948 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34949 int result;
34950 void *argp1 = 0 ;
34951 int res1 = 0 ;
34952 PyObject *swig_obj[1] ;
34953
34954 if (!args) SWIG_fail;
34955 swig_obj[0] = args;
34956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34957 if (!SWIG_IsOK(res1)) {
34958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34959 }
34960 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34961 result = (int) ((arg1)->refresh);
34962 resultobj = SWIG_From_int(static_cast< int >(result));
34963 return resultobj;
34964 fail:
34965 return NULL;
34966 }
34967
34968
34969 SWIGINTERN PyObject *VideoMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34970 PyObject *obj;
34971 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34972 SWIG_TypeNewClientData(SWIGTYPE_p_wxVideoMode, SWIG_NewClientData(obj));
34973 return SWIG_Py_Void();
34974 }
34975
34976 SWIGINTERN PyObject *VideoMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34977 return SWIG_Python_InitShadowInstance(args);
34978 }
34979
34980 SWIGINTERN int DefaultVideoMode_set(PyObject *) {
34981 SWIG_Error(SWIG_AttributeError,"Variable DefaultVideoMode is read-only.");
34982 return 1;
34983 }
34984
34985
34986 SWIGINTERN PyObject *DefaultVideoMode_get(void) {
34987 PyObject *pyobj = 0;
34988
34989 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0 );
34990 return pyobj;
34991 }
34992
34993
34994 SWIGINTERN PyObject *_wrap_new_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34995 PyObject *resultobj = 0;
34996 size_t arg1 = (size_t) 0 ;
34997 wxDisplay *result = 0 ;
34998 size_t val1 ;
34999 int ecode1 = 0 ;
35000 PyObject * obj0 = 0 ;
35001 char * kwnames[] = {
35002 (char *) "index", NULL
35003 };
35004
35005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) SWIG_fail;
35006 if (obj0) {
35007 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
35008 if (!SWIG_IsOK(ecode1)) {
35009 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Display" "', expected argument " "1"" of type '" "size_t""'");
35010 }
35011 arg1 = static_cast< size_t >(val1);
35012 }
35013 {
35014 PyThreadState* __tstate = wxPyBeginAllowThreads();
35015 result = (wxDisplay *)new wxDisplay(arg1);
35016 wxPyEndAllowThreads(__tstate);
35017 if (PyErr_Occurred()) SWIG_fail;
35018 }
35019 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplay, SWIG_POINTER_NEW | 0 );
35020 return resultobj;
35021 fail:
35022 return NULL;
35023 }
35024
35025
35026 SWIGINTERN PyObject *_wrap_delete_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35027 PyObject *resultobj = 0;
35028 wxDisplay *arg1 = (wxDisplay *) 0 ;
35029 void *argp1 = 0 ;
35030 int res1 = 0 ;
35031 PyObject *swig_obj[1] ;
35032
35033 if (!args) SWIG_fail;
35034 swig_obj[0] = args;
35035 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, SWIG_POINTER_DISOWN | 0 );
35036 if (!SWIG_IsOK(res1)) {
35037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Display" "', expected argument " "1"" of type '" "wxDisplay *""'");
35038 }
35039 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35040 {
35041 PyThreadState* __tstate = wxPyBeginAllowThreads();
35042 delete arg1;
35043
35044 wxPyEndAllowThreads(__tstate);
35045 if (PyErr_Occurred()) SWIG_fail;
35046 }
35047 resultobj = SWIG_Py_Void();
35048 return resultobj;
35049 fail:
35050 return NULL;
35051 }
35052
35053
35054 SWIGINTERN PyObject *_wrap_Display_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35055 PyObject *resultobj = 0;
35056 size_t result;
35057
35058 if (!SWIG_Python_UnpackTuple(args,"Display_GetCount",0,0,0)) SWIG_fail;
35059 {
35060 PyThreadState* __tstate = wxPyBeginAllowThreads();
35061 result = (size_t)wxDisplay::GetCount();
35062 wxPyEndAllowThreads(__tstate);
35063 if (PyErr_Occurred()) SWIG_fail;
35064 }
35065 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
35066 return resultobj;
35067 fail:
35068 return NULL;
35069 }
35070
35071
35072 SWIGINTERN PyObject *_wrap_Display_GetFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35073 PyObject *resultobj = 0;
35074 wxPoint *arg1 = 0 ;
35075 int result;
35076 wxPoint temp1 ;
35077 PyObject * obj0 = 0 ;
35078 char * kwnames[] = {
35079 (char *) "pt", NULL
35080 };
35081
35082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) SWIG_fail;
35083 {
35084 arg1 = &temp1;
35085 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
35086 }
35087 {
35088 PyThreadState* __tstate = wxPyBeginAllowThreads();
35089 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
35090 wxPyEndAllowThreads(__tstate);
35091 if (PyErr_Occurred()) SWIG_fail;
35092 }
35093 resultobj = SWIG_From_int(static_cast< int >(result));
35094 return resultobj;
35095 fail:
35096 return NULL;
35097 }
35098
35099
35100 SWIGINTERN PyObject *_wrap_Display_GetFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35101 PyObject *resultobj = 0;
35102 wxWindow *arg1 = (wxWindow *) 0 ;
35103 int result;
35104 void *argp1 = 0 ;
35105 int res1 = 0 ;
35106 PyObject * obj0 = 0 ;
35107 char * kwnames[] = {
35108 (char *) "window", NULL
35109 };
35110
35111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) SWIG_fail;
35112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35113 if (!SWIG_IsOK(res1)) {
35114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
35115 }
35116 arg1 = reinterpret_cast< wxWindow * >(argp1);
35117 {
35118 PyThreadState* __tstate = wxPyBeginAllowThreads();
35119 result = (int)wxDisplay::GetFromWindow(arg1);
35120 wxPyEndAllowThreads(__tstate);
35121 if (PyErr_Occurred()) SWIG_fail;
35122 }
35123 resultobj = SWIG_From_int(static_cast< int >(result));
35124 return resultobj;
35125 fail:
35126 return NULL;
35127 }
35128
35129
35130 SWIGINTERN PyObject *_wrap_Display_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35131 PyObject *resultobj = 0;
35132 wxDisplay *arg1 = (wxDisplay *) 0 ;
35133 bool result;
35134 void *argp1 = 0 ;
35135 int res1 = 0 ;
35136 PyObject *swig_obj[1] ;
35137
35138 if (!args) SWIG_fail;
35139 swig_obj[0] = args;
35140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35141 if (!SWIG_IsOK(res1)) {
35142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsOk" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35143 }
35144 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35145 {
35146 PyThreadState* __tstate = wxPyBeginAllowThreads();
35147 result = (bool)((wxDisplay const *)arg1)->IsOk();
35148 wxPyEndAllowThreads(__tstate);
35149 if (PyErr_Occurred()) SWIG_fail;
35150 }
35151 {
35152 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35153 }
35154 return resultobj;
35155 fail:
35156 return NULL;
35157 }
35158
35159
35160 SWIGINTERN PyObject *_wrap_Display_GetGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35161 PyObject *resultobj = 0;
35162 wxDisplay *arg1 = (wxDisplay *) 0 ;
35163 wxRect result;
35164 void *argp1 = 0 ;
35165 int res1 = 0 ;
35166 PyObject *swig_obj[1] ;
35167
35168 if (!args) SWIG_fail;
35169 swig_obj[0] = args;
35170 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35171 if (!SWIG_IsOK(res1)) {
35172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetGeometry" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35173 }
35174 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35175 {
35176 PyThreadState* __tstate = wxPyBeginAllowThreads();
35177 result = ((wxDisplay const *)arg1)->GetGeometry();
35178 wxPyEndAllowThreads(__tstate);
35179 if (PyErr_Occurred()) SWIG_fail;
35180 }
35181 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
35182 return resultobj;
35183 fail:
35184 return NULL;
35185 }
35186
35187
35188 SWIGINTERN PyObject *_wrap_Display_GetClientArea(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35189 PyObject *resultobj = 0;
35190 wxDisplay *arg1 = (wxDisplay *) 0 ;
35191 wxRect result;
35192 void *argp1 = 0 ;
35193 int res1 = 0 ;
35194 PyObject *swig_obj[1] ;
35195
35196 if (!args) SWIG_fail;
35197 swig_obj[0] = args;
35198 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35199 if (!SWIG_IsOK(res1)) {
35200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetClientArea" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35201 }
35202 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35203 {
35204 PyThreadState* __tstate = wxPyBeginAllowThreads();
35205 result = ((wxDisplay const *)arg1)->GetClientArea();
35206 wxPyEndAllowThreads(__tstate);
35207 if (PyErr_Occurred()) SWIG_fail;
35208 }
35209 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
35210 return resultobj;
35211 fail:
35212 return NULL;
35213 }
35214
35215
35216 SWIGINTERN PyObject *_wrap_Display_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35217 PyObject *resultobj = 0;
35218 wxDisplay *arg1 = (wxDisplay *) 0 ;
35219 wxString result;
35220 void *argp1 = 0 ;
35221 int res1 = 0 ;
35222 PyObject *swig_obj[1] ;
35223
35224 if (!args) SWIG_fail;
35225 swig_obj[0] = args;
35226 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35227 if (!SWIG_IsOK(res1)) {
35228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetName" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35229 }
35230 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35231 {
35232 PyThreadState* __tstate = wxPyBeginAllowThreads();
35233 result = ((wxDisplay const *)arg1)->GetName();
35234 wxPyEndAllowThreads(__tstate);
35235 if (PyErr_Occurred()) SWIG_fail;
35236 }
35237 {
35238 #if wxUSE_UNICODE
35239 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35240 #else
35241 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35242 #endif
35243 }
35244 return resultobj;
35245 fail:
35246 return NULL;
35247 }
35248
35249
35250 SWIGINTERN PyObject *_wrap_Display_IsPrimary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35251 PyObject *resultobj = 0;
35252 wxDisplay *arg1 = (wxDisplay *) 0 ;
35253 bool result;
35254 void *argp1 = 0 ;
35255 int res1 = 0 ;
35256 PyObject *swig_obj[1] ;
35257
35258 if (!args) SWIG_fail;
35259 swig_obj[0] = args;
35260 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35261 if (!SWIG_IsOK(res1)) {
35262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsPrimary" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35263 }
35264 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35265 {
35266 PyThreadState* __tstate = wxPyBeginAllowThreads();
35267 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
35268 wxPyEndAllowThreads(__tstate);
35269 if (PyErr_Occurred()) SWIG_fail;
35270 }
35271 {
35272 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35273 }
35274 return resultobj;
35275 fail:
35276 return NULL;
35277 }
35278
35279
35280 SWIGINTERN PyObject *_wrap_Display_GetModes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35281 PyObject *resultobj = 0;
35282 wxDisplay *arg1 = (wxDisplay *) 0 ;
35283 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
35284 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
35285 PyObject *result = 0 ;
35286 void *argp1 = 0 ;
35287 int res1 = 0 ;
35288 void *argp2 = 0 ;
35289 int res2 = 0 ;
35290 PyObject * obj0 = 0 ;
35291 PyObject * obj1 = 0 ;
35292 char * kwnames[] = {
35293 (char *) "self",(char *) "mode", NULL
35294 };
35295
35296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) SWIG_fail;
35297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35298 if (!SWIG_IsOK(res1)) {
35299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetModes" "', expected argument " "1"" of type '" "wxDisplay *""'");
35300 }
35301 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35302 if (obj1) {
35303 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
35304 if (!SWIG_IsOK(res2)) {
35305 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35306 }
35307 if (!argp2) {
35308 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35309 }
35310 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
35311 }
35312 {
35313 PyThreadState* __tstate = wxPyBeginAllowThreads();
35314 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
35315 wxPyEndAllowThreads(__tstate);
35316 if (PyErr_Occurred()) SWIG_fail;
35317 }
35318 resultobj = result;
35319 return resultobj;
35320 fail:
35321 return NULL;
35322 }
35323
35324
35325 SWIGINTERN PyObject *_wrap_Display_GetCurrentMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35326 PyObject *resultobj = 0;
35327 wxDisplay *arg1 = (wxDisplay *) 0 ;
35328 wxVideoMode result;
35329 void *argp1 = 0 ;
35330 int res1 = 0 ;
35331 PyObject *swig_obj[1] ;
35332
35333 if (!args) SWIG_fail;
35334 swig_obj[0] = args;
35335 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35336 if (!SWIG_IsOK(res1)) {
35337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetCurrentMode" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35338 }
35339 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35340 {
35341 PyThreadState* __tstate = wxPyBeginAllowThreads();
35342 result = wxDisplay_GetCurrentMode((wxDisplay const *)arg1);
35343 wxPyEndAllowThreads(__tstate);
35344 if (PyErr_Occurred()) SWIG_fail;
35345 }
35346 resultobj = SWIG_NewPointerObj((new wxVideoMode(static_cast< const wxVideoMode& >(result))), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_OWN | 0 );
35347 return resultobj;
35348 fail:
35349 return NULL;
35350 }
35351
35352
35353 SWIGINTERN PyObject *_wrap_Display_ChangeMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35354 PyObject *resultobj = 0;
35355 wxDisplay *arg1 = (wxDisplay *) 0 ;
35356 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
35357 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
35358 bool result;
35359 void *argp1 = 0 ;
35360 int res1 = 0 ;
35361 void *argp2 = 0 ;
35362 int res2 = 0 ;
35363 PyObject * obj0 = 0 ;
35364 PyObject * obj1 = 0 ;
35365 char * kwnames[] = {
35366 (char *) "self",(char *) "mode", NULL
35367 };
35368
35369 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) SWIG_fail;
35370 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35371 if (!SWIG_IsOK(res1)) {
35372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ChangeMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
35373 }
35374 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35375 if (obj1) {
35376 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
35377 if (!SWIG_IsOK(res2)) {
35378 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35379 }
35380 if (!argp2) {
35381 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35382 }
35383 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
35384 }
35385 {
35386 PyThreadState* __tstate = wxPyBeginAllowThreads();
35387 result = (bool)wxDisplay_ChangeMode(arg1,(wxVideoMode const &)*arg2);
35388 wxPyEndAllowThreads(__tstate);
35389 if (PyErr_Occurred()) SWIG_fail;
35390 }
35391 {
35392 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35393 }
35394 return resultobj;
35395 fail:
35396 return NULL;
35397 }
35398
35399
35400 SWIGINTERN PyObject *_wrap_Display_ResetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35401 PyObject *resultobj = 0;
35402 wxDisplay *arg1 = (wxDisplay *) 0 ;
35403 void *argp1 = 0 ;
35404 int res1 = 0 ;
35405 PyObject *swig_obj[1] ;
35406
35407 if (!args) SWIG_fail;
35408 swig_obj[0] = args;
35409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35410 if (!SWIG_IsOK(res1)) {
35411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ResetMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
35412 }
35413 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35414 {
35415 PyThreadState* __tstate = wxPyBeginAllowThreads();
35416 wxDisplay_ResetMode(arg1);
35417 wxPyEndAllowThreads(__tstate);
35418 if (PyErr_Occurred()) SWIG_fail;
35419 }
35420 resultobj = SWIG_Py_Void();
35421 return resultobj;
35422 fail:
35423 return NULL;
35424 }
35425
35426
35427 SWIGINTERN PyObject *Display_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35428 PyObject *obj;
35429 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35430 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplay, SWIG_NewClientData(obj));
35431 return SWIG_Py_Void();
35432 }
35433
35434 SWIGINTERN PyObject *Display_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35435 return SWIG_Python_InitShadowInstance(args);
35436 }
35437
35438 SWIGINTERN PyObject *_wrap_StandardPaths_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35439 PyObject *resultobj = 0;
35440 wxStandardPaths *result = 0 ;
35441
35442 if (!SWIG_Python_UnpackTuple(args,"StandardPaths_Get",0,0,0)) SWIG_fail;
35443 {
35444 PyThreadState* __tstate = wxPyBeginAllowThreads();
35445 result = (wxStandardPaths *)wxStandardPaths_Get();
35446 wxPyEndAllowThreads(__tstate);
35447 if (PyErr_Occurred()) SWIG_fail;
35448 }
35449 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35450 return resultobj;
35451 fail:
35452 return NULL;
35453 }
35454
35455
35456 SWIGINTERN PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35457 PyObject *resultobj = 0;
35458 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35459 wxString result;
35460 void *argp1 = 0 ;
35461 int res1 = 0 ;
35462 PyObject *swig_obj[1] ;
35463
35464 if (!args) SWIG_fail;
35465 swig_obj[0] = args;
35466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35467 if (!SWIG_IsOK(res1)) {
35468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35469 }
35470 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35471 {
35472 PyThreadState* __tstate = wxPyBeginAllowThreads();
35473 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
35474 wxPyEndAllowThreads(__tstate);
35475 if (PyErr_Occurred()) SWIG_fail;
35476 }
35477 {
35478 #if wxUSE_UNICODE
35479 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35480 #else
35481 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35482 #endif
35483 }
35484 return resultobj;
35485 fail:
35486 return NULL;
35487 }
35488
35489
35490 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35491 PyObject *resultobj = 0;
35492 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35493 wxString result;
35494 void *argp1 = 0 ;
35495 int res1 = 0 ;
35496 PyObject *swig_obj[1] ;
35497
35498 if (!args) SWIG_fail;
35499 swig_obj[0] = args;
35500 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35501 if (!SWIG_IsOK(res1)) {
35502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35503 }
35504 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35505 {
35506 PyThreadState* __tstate = wxPyBeginAllowThreads();
35507 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
35508 wxPyEndAllowThreads(__tstate);
35509 if (PyErr_Occurred()) SWIG_fail;
35510 }
35511 {
35512 #if wxUSE_UNICODE
35513 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35514 #else
35515 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35516 #endif
35517 }
35518 return resultobj;
35519 fail:
35520 return NULL;
35521 }
35522
35523
35524 SWIGINTERN PyObject *_wrap_StandardPaths_GetDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35525 PyObject *resultobj = 0;
35526 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35527 wxString result;
35528 void *argp1 = 0 ;
35529 int res1 = 0 ;
35530 PyObject *swig_obj[1] ;
35531
35532 if (!args) SWIG_fail;
35533 swig_obj[0] = args;
35534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35535 if (!SWIG_IsOK(res1)) {
35536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35537 }
35538 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35539 {
35540 PyThreadState* __tstate = wxPyBeginAllowThreads();
35541 result = ((wxStandardPaths const *)arg1)->GetDataDir();
35542 wxPyEndAllowThreads(__tstate);
35543 if (PyErr_Occurred()) SWIG_fail;
35544 }
35545 {
35546 #if wxUSE_UNICODE
35547 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35548 #else
35549 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35550 #endif
35551 }
35552 return resultobj;
35553 fail:
35554 return NULL;
35555 }
35556
35557
35558 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35559 PyObject *resultobj = 0;
35560 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35561 wxString result;
35562 void *argp1 = 0 ;
35563 int res1 = 0 ;
35564 PyObject *swig_obj[1] ;
35565
35566 if (!args) SWIG_fail;
35567 swig_obj[0] = args;
35568 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35569 if (!SWIG_IsOK(res1)) {
35570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35571 }
35572 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35573 {
35574 PyThreadState* __tstate = wxPyBeginAllowThreads();
35575 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
35576 wxPyEndAllowThreads(__tstate);
35577 if (PyErr_Occurred()) SWIG_fail;
35578 }
35579 {
35580 #if wxUSE_UNICODE
35581 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35582 #else
35583 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35584 #endif
35585 }
35586 return resultobj;
35587 fail:
35588 return NULL;
35589 }
35590
35591
35592 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35593 PyObject *resultobj = 0;
35594 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35595 wxString result;
35596 void *argp1 = 0 ;
35597 int res1 = 0 ;
35598 PyObject *swig_obj[1] ;
35599
35600 if (!args) SWIG_fail;
35601 swig_obj[0] = args;
35602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35603 if (!SWIG_IsOK(res1)) {
35604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35605 }
35606 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35607 {
35608 PyThreadState* __tstate = wxPyBeginAllowThreads();
35609 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
35610 wxPyEndAllowThreads(__tstate);
35611 if (PyErr_Occurred()) SWIG_fail;
35612 }
35613 {
35614 #if wxUSE_UNICODE
35615 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35616 #else
35617 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35618 #endif
35619 }
35620 return resultobj;
35621 fail:
35622 return NULL;
35623 }
35624
35625
35626 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35627 PyObject *resultobj = 0;
35628 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35629 wxString result;
35630 void *argp1 = 0 ;
35631 int res1 = 0 ;
35632 PyObject *swig_obj[1] ;
35633
35634 if (!args) SWIG_fail;
35635 swig_obj[0] = args;
35636 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35637 if (!SWIG_IsOK(res1)) {
35638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35639 }
35640 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35641 {
35642 PyThreadState* __tstate = wxPyBeginAllowThreads();
35643 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
35644 wxPyEndAllowThreads(__tstate);
35645 if (PyErr_Occurred()) SWIG_fail;
35646 }
35647 {
35648 #if wxUSE_UNICODE
35649 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35650 #else
35651 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35652 #endif
35653 }
35654 return resultobj;
35655 fail:
35656 return NULL;
35657 }
35658
35659
35660 SWIGINTERN PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35661 PyObject *resultobj = 0;
35662 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35663 wxString result;
35664 void *argp1 = 0 ;
35665 int res1 = 0 ;
35666 PyObject *swig_obj[1] ;
35667
35668 if (!args) SWIG_fail;
35669 swig_obj[0] = args;
35670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35671 if (!SWIG_IsOK(res1)) {
35672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetPluginsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35673 }
35674 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35675 {
35676 PyThreadState* __tstate = wxPyBeginAllowThreads();
35677 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
35678 wxPyEndAllowThreads(__tstate);
35679 if (PyErr_Occurred()) SWIG_fail;
35680 }
35681 {
35682 #if wxUSE_UNICODE
35683 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35684 #else
35685 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35686 #endif
35687 }
35688 return resultobj;
35689 fail:
35690 return NULL;
35691 }
35692
35693
35694 SWIGINTERN PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35695 PyObject *resultobj = 0;
35696 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35697 wxString *arg2 = 0 ;
35698 void *argp1 = 0 ;
35699 int res1 = 0 ;
35700 bool temp2 = false ;
35701 PyObject * obj0 = 0 ;
35702 PyObject * obj1 = 0 ;
35703 char * kwnames[] = {
35704 (char *) "self",(char *) "prefix", NULL
35705 };
35706
35707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) SWIG_fail;
35708 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35709 if (!SWIG_IsOK(res1)) {
35710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_SetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths *""'");
35711 }
35712 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35713 {
35714 arg2 = wxString_in_helper(obj1);
35715 if (arg2 == NULL) SWIG_fail;
35716 temp2 = true;
35717 }
35718 {
35719 PyThreadState* __tstate = wxPyBeginAllowThreads();
35720 wxStandardPaths_SetInstallPrefix(arg1,(wxString const &)*arg2);
35721 wxPyEndAllowThreads(__tstate);
35722 if (PyErr_Occurred()) SWIG_fail;
35723 }
35724 resultobj = SWIG_Py_Void();
35725 {
35726 if (temp2)
35727 delete arg2;
35728 }
35729 return resultobj;
35730 fail:
35731 {
35732 if (temp2)
35733 delete arg2;
35734 }
35735 return NULL;
35736 }
35737
35738
35739 SWIGINTERN PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35740 PyObject *resultobj = 0;
35741 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35742 wxString result;
35743 void *argp1 = 0 ;
35744 int res1 = 0 ;
35745 PyObject *swig_obj[1] ;
35746
35747 if (!args) SWIG_fail;
35748 swig_obj[0] = args;
35749 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35750 if (!SWIG_IsOK(res1)) {
35751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths *""'");
35752 }
35753 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35754 {
35755 PyThreadState* __tstate = wxPyBeginAllowThreads();
35756 result = wxStandardPaths_GetInstallPrefix(arg1);
35757 wxPyEndAllowThreads(__tstate);
35758 if (PyErr_Occurred()) SWIG_fail;
35759 }
35760 {
35761 #if wxUSE_UNICODE
35762 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35763 #else
35764 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35765 #endif
35766 }
35767 return resultobj;
35768 fail:
35769 return NULL;
35770 }
35771
35772
35773 SWIGINTERN PyObject *StandardPaths_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35774 PyObject *obj;
35775 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35776 SWIG_TypeNewClientData(SWIGTYPE_p_wxStandardPaths, SWIG_NewClientData(obj));
35777 return SWIG_Py_Void();
35778 }
35779
35780 static PyMethodDef SwigMethods[] = {
35781 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
35782 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
35783 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
35784 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
35785 { (char *)"SystemSettings_GetScreenType", (PyCFunction)_wrap_SystemSettings_GetScreenType, METH_NOARGS, NULL},
35786 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
35787 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
35788 { (char *)"new_SystemOptions", (PyCFunction)_wrap_new_SystemOptions, METH_NOARGS, NULL},
35789 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
35790 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
35791 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
35792 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
35793 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
35794 { (char *)"SystemOptions_IsFalse", (PyCFunction) _wrap_SystemOptions_IsFalse, METH_VARARGS | METH_KEYWORDS, NULL},
35795 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
35796 { (char *)"SystemOptions_swiginit", SystemOptions_swiginit, METH_VARARGS, NULL},
35797 { (char *)"NewId", (PyCFunction)_wrap_NewId, METH_NOARGS, NULL},
35798 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
35799 { (char *)"GetCurrentId", (PyCFunction)_wrap_GetCurrentId, METH_NOARGS, NULL},
35800 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
35801 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
35802 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
35803 { (char *)"Bell", (PyCFunction)_wrap_Bell, METH_NOARGS, NULL},
35804 { (char *)"EndBusyCursor", (PyCFunction)_wrap_EndBusyCursor, METH_NOARGS, NULL},
35805 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
35806 { (char *)"IsBusy", (PyCFunction)_wrap_IsBusy, METH_NOARGS, NULL},
35807 { (char *)"Now", (PyCFunction)_wrap_Now, METH_NOARGS, NULL},
35808 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
35809 { (char *)"StartTimer", (PyCFunction)_wrap_StartTimer, METH_NOARGS, NULL},
35810 { (char *)"GetOsVersion", (PyCFunction)_wrap_GetOsVersion, METH_NOARGS, NULL},
35811 { (char *)"GetOsDescription", (PyCFunction)_wrap_GetOsDescription, METH_NOARGS, NULL},
35812 { (char *)"GetFreeMemory", (PyCFunction)_wrap_GetFreeMemory, METH_NOARGS, NULL},
35813 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
35814 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
35815 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
35816 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
35817 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
35818 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
35819 { (char *)"GetEmailAddress", (PyCFunction)_wrap_GetEmailAddress, METH_NOARGS, NULL},
35820 { (char *)"GetHostName", (PyCFunction)_wrap_GetHostName, METH_NOARGS, NULL},
35821 { (char *)"GetFullHostName", (PyCFunction)_wrap_GetFullHostName, METH_NOARGS, NULL},
35822 { (char *)"GetUserId", (PyCFunction)_wrap_GetUserId, METH_NOARGS, NULL},
35823 { (char *)"GetUserName", (PyCFunction)_wrap_GetUserName, METH_NOARGS, NULL},
35824 { (char *)"GetHomeDir", (PyCFunction)_wrap_GetHomeDir, METH_NOARGS, NULL},
35825 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
35826 { (char *)"GetProcessId", (PyCFunction)_wrap_GetProcessId, METH_NOARGS, NULL},
35827 { (char *)"Trap", (PyCFunction)_wrap_Trap, METH_NOARGS, NULL},
35828 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
35829 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
35830 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
35831 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
35832 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
35833 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
35834 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
35835 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
35836 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
35837 { (char *)"ColourDisplay", (PyCFunction)_wrap_ColourDisplay, METH_NOARGS, NULL},
35838 { (char *)"DisplayDepth", (PyCFunction)_wrap_DisplayDepth, METH_NOARGS, NULL},
35839 { (char *)"GetDisplayDepth", (PyCFunction)_wrap_GetDisplayDepth, METH_NOARGS, NULL},
35840 { (char *)"DisplaySize", (PyCFunction)_wrap_DisplaySize, METH_NOARGS, NULL},
35841 { (char *)"GetDisplaySize", (PyCFunction)_wrap_GetDisplaySize, METH_NOARGS, NULL},
35842 { (char *)"DisplaySizeMM", (PyCFunction)_wrap_DisplaySizeMM, METH_NOARGS, NULL},
35843 { (char *)"GetDisplaySizeMM", (PyCFunction)_wrap_GetDisplaySizeMM, METH_NOARGS, NULL},
35844 { (char *)"ClientDisplayRect", (PyCFunction)_wrap_ClientDisplayRect, METH_NOARGS, NULL},
35845 { (char *)"GetClientDisplayRect", (PyCFunction)_wrap_GetClientDisplayRect, METH_NOARGS, NULL},
35846 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
35847 { (char *)"GetXDisplay", (PyCFunction)_wrap_GetXDisplay, METH_NOARGS, NULL},
35848 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
35849 { (char *)"GetMousePosition", (PyCFunction)_wrap_GetMousePosition, METH_NOARGS, NULL},
35850 { (char *)"FindWindowAtPointer", (PyCFunction)_wrap_FindWindowAtPointer, METH_NOARGS, NULL},
35851 { (char *)"GetActiveWindow", (PyCFunction)_wrap_GetActiveWindow, METH_NOARGS, NULL},
35852 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
35853 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
35854 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
35855 { (char *)"LaunchDefaultBrowser", (PyCFunction) _wrap_LaunchDefaultBrowser, METH_VARARGS | METH_KEYWORDS, NULL},
35856 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
35857 { (char *)"new_MouseState", (PyCFunction)_wrap_new_MouseState, METH_NOARGS, NULL},
35858 { (char *)"delete_MouseState", (PyCFunction)_wrap_delete_MouseState, METH_O, NULL},
35859 { (char *)"MouseState_GetX", (PyCFunction)_wrap_MouseState_GetX, METH_O, NULL},
35860 { (char *)"MouseState_GetY", (PyCFunction)_wrap_MouseState_GetY, METH_O, NULL},
35861 { (char *)"MouseState_LeftDown", (PyCFunction)_wrap_MouseState_LeftDown, METH_O, NULL},
35862 { (char *)"MouseState_MiddleDown", (PyCFunction)_wrap_MouseState_MiddleDown, METH_O, NULL},
35863 { (char *)"MouseState_RightDown", (PyCFunction)_wrap_MouseState_RightDown, METH_O, NULL},
35864 { (char *)"MouseState_ControlDown", (PyCFunction)_wrap_MouseState_ControlDown, METH_O, NULL},
35865 { (char *)"MouseState_ShiftDown", (PyCFunction)_wrap_MouseState_ShiftDown, METH_O, NULL},
35866 { (char *)"MouseState_AltDown", (PyCFunction)_wrap_MouseState_AltDown, METH_O, NULL},
35867 { (char *)"MouseState_MetaDown", (PyCFunction)_wrap_MouseState_MetaDown, METH_O, NULL},
35868 { (char *)"MouseState_CmdDown", (PyCFunction)_wrap_MouseState_CmdDown, METH_O, NULL},
35869 { (char *)"MouseState_SetX", (PyCFunction) _wrap_MouseState_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
35870 { (char *)"MouseState_SetY", (PyCFunction) _wrap_MouseState_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
35871 { (char *)"MouseState_SetLeftDown", (PyCFunction) _wrap_MouseState_SetLeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
35872 { (char *)"MouseState_SetMiddleDown", (PyCFunction) _wrap_MouseState_SetMiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
35873 { (char *)"MouseState_SetRightDown", (PyCFunction) _wrap_MouseState_SetRightDown, METH_VARARGS | METH_KEYWORDS, NULL},
35874 { (char *)"MouseState_SetControlDown", (PyCFunction) _wrap_MouseState_SetControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
35875 { (char *)"MouseState_SetShiftDown", (PyCFunction) _wrap_MouseState_SetShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
35876 { (char *)"MouseState_SetAltDown", (PyCFunction) _wrap_MouseState_SetAltDown, METH_VARARGS | METH_KEYWORDS, NULL},
35877 { (char *)"MouseState_SetMetaDown", (PyCFunction) _wrap_MouseState_SetMetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
35878 { (char *)"MouseState_swigregister", MouseState_swigregister, METH_VARARGS, NULL},
35879 { (char *)"MouseState_swiginit", MouseState_swiginit, METH_VARARGS, NULL},
35880 { (char *)"GetMouseState", (PyCFunction)_wrap_GetMouseState, METH_NOARGS, NULL},
35881 { (char *)"WakeUpMainThread", (PyCFunction)_wrap_WakeUpMainThread, METH_NOARGS, NULL},
35882 { (char *)"MutexGuiEnter", (PyCFunction)_wrap_MutexGuiEnter, METH_NOARGS, NULL},
35883 { (char *)"MutexGuiLeave", (PyCFunction)_wrap_MutexGuiLeave, METH_NOARGS, NULL},
35884 { (char *)"new_MutexGuiLocker", (PyCFunction)_wrap_new_MutexGuiLocker, METH_NOARGS, NULL},
35885 { (char *)"delete_MutexGuiLocker", (PyCFunction)_wrap_delete_MutexGuiLocker, METH_O, NULL},
35886 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
35887 { (char *)"MutexGuiLocker_swiginit", MutexGuiLocker_swiginit, METH_VARARGS, NULL},
35888 { (char *)"Thread_IsMain", (PyCFunction)_wrap_Thread_IsMain, METH_NOARGS, NULL},
35889 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
35890 { (char *)"delete_ToolTip", (PyCFunction)_wrap_delete_ToolTip, METH_O, NULL},
35891 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
35892 { (char *)"ToolTip_GetTip", (PyCFunction)_wrap_ToolTip_GetTip, METH_O, NULL},
35893 { (char *)"ToolTip_GetWindow", (PyCFunction)_wrap_ToolTip_GetWindow, METH_O, NULL},
35894 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
35895 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
35896 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
35897 { (char *)"ToolTip_swiginit", ToolTip_swiginit, METH_VARARGS, NULL},
35898 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
35899 { (char *)"delete_Caret", (PyCFunction)_wrap_delete_Caret, METH_O, NULL},
35900 { (char *)"Caret_Destroy", (PyCFunction)_wrap_Caret_Destroy, METH_O, NULL},
35901 { (char *)"Caret_IsOk", (PyCFunction)_wrap_Caret_IsOk, METH_O, NULL},
35902 { (char *)"Caret_IsVisible", (PyCFunction)_wrap_Caret_IsVisible, METH_O, NULL},
35903 { (char *)"Caret_GetPosition", (PyCFunction)_wrap_Caret_GetPosition, METH_O, NULL},
35904 { (char *)"Caret_GetPositionTuple", (PyCFunction)_wrap_Caret_GetPositionTuple, METH_O, NULL},
35905 { (char *)"Caret_GetSize", (PyCFunction)_wrap_Caret_GetSize, METH_O, NULL},
35906 { (char *)"Caret_GetSizeTuple", (PyCFunction)_wrap_Caret_GetSizeTuple, METH_O, NULL},
35907 { (char *)"Caret_GetWindow", (PyCFunction)_wrap_Caret_GetWindow, METH_O, NULL},
35908 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
35909 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
35910 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
35911 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
35912 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
35913 { (char *)"Caret_Hide", (PyCFunction)_wrap_Caret_Hide, METH_O, NULL},
35914 { (char *)"Caret_GetBlinkTime", (PyCFunction)_wrap_Caret_GetBlinkTime, METH_NOARGS, NULL},
35915 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
35916 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
35917 { (char *)"Caret_swiginit", Caret_swiginit, METH_VARARGS, NULL},
35918 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
35919 { (char *)"delete_BusyCursor", (PyCFunction)_wrap_delete_BusyCursor, METH_O, NULL},
35920 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
35921 { (char *)"BusyCursor_swiginit", BusyCursor_swiginit, METH_VARARGS, NULL},
35922 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
35923 { (char *)"delete_WindowDisabler", (PyCFunction)_wrap_delete_WindowDisabler, METH_O, NULL},
35924 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
35925 { (char *)"WindowDisabler_swiginit", WindowDisabler_swiginit, METH_VARARGS, NULL},
35926 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
35927 { (char *)"delete_BusyInfo", (PyCFunction)_wrap_delete_BusyInfo, METH_O, NULL},
35928 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
35929 { (char *)"BusyInfo_swiginit", BusyInfo_swiginit, METH_VARARGS, NULL},
35930 { (char *)"new_StopWatch", (PyCFunction)_wrap_new_StopWatch, METH_NOARGS, NULL},
35931 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
35932 { (char *)"StopWatch_Pause", (PyCFunction)_wrap_StopWatch_Pause, METH_O, NULL},
35933 { (char *)"StopWatch_Resume", (PyCFunction)_wrap_StopWatch_Resume, METH_O, NULL},
35934 { (char *)"StopWatch_Time", (PyCFunction)_wrap_StopWatch_Time, METH_O, NULL},
35935 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
35936 { (char *)"StopWatch_swiginit", StopWatch_swiginit, METH_VARARGS, NULL},
35937 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
35938 { (char *)"delete_FileHistory", (PyCFunction)_wrap_delete_FileHistory, METH_O, NULL},
35939 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
35940 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
35941 { (char *)"FileHistory_GetMaxFiles", (PyCFunction)_wrap_FileHistory_GetMaxFiles, METH_O, NULL},
35942 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
35943 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
35944 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
35945 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
35946 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction)_wrap_FileHistory_AddFilesToMenu, METH_O, NULL},
35947 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
35948 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
35949 { (char *)"FileHistory_GetCount", (PyCFunction)_wrap_FileHistory_GetCount, METH_O, NULL},
35950 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
35951 { (char *)"FileHistory_swiginit", FileHistory_swiginit, METH_VARARGS, NULL},
35952 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
35953 { (char *)"new_PreSingleInstanceChecker", (PyCFunction)_wrap_new_PreSingleInstanceChecker, METH_NOARGS, NULL},
35954 { (char *)"delete_SingleInstanceChecker", (PyCFunction)_wrap_delete_SingleInstanceChecker, METH_O, NULL},
35955 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
35956 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction)_wrap_SingleInstanceChecker_IsAnotherRunning, METH_O, NULL},
35957 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
35958 { (char *)"SingleInstanceChecker_swiginit", SingleInstanceChecker_swiginit, METH_VARARGS, NULL},
35959 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
35960 { (char *)"delete_TipProvider", (PyCFunction)_wrap_delete_TipProvider, METH_O, NULL},
35961 { (char *)"TipProvider_GetTip", (PyCFunction)_wrap_TipProvider_GetTip, METH_O, NULL},
35962 { (char *)"TipProvider_GetCurrentTip", (PyCFunction)_wrap_TipProvider_GetCurrentTip, METH_O, NULL},
35963 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
35964 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
35965 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
35966 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
35967 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
35968 { (char *)"PyTipProvider_swiginit", PyTipProvider_swiginit, METH_VARARGS, NULL},
35969 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
35970 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
35971 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
35972 { (char *)"delete_Timer", (PyCFunction)_wrap_delete_Timer, METH_O, NULL},
35973 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
35974 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
35975 { (char *)"Timer_GetOwner", (PyCFunction)_wrap_Timer_GetOwner, METH_O, NULL},
35976 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
35977 { (char *)"Timer_Stop", (PyCFunction)_wrap_Timer_Stop, METH_O, NULL},
35978 { (char *)"Timer_Notify", (PyCFunction)_wrap_Timer_Notify, METH_O, NULL},
35979 { (char *)"Timer_IsRunning", (PyCFunction)_wrap_Timer_IsRunning, METH_O, NULL},
35980 { (char *)"Timer_GetInterval", (PyCFunction)_wrap_Timer_GetInterval, METH_O, NULL},
35981 { (char *)"Timer_GetId", (PyCFunction)_wrap_Timer_GetId, METH_O, NULL},
35982 { (char *)"Timer_IsOneShot", (PyCFunction)_wrap_Timer_IsOneShot, METH_O, NULL},
35983 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
35984 { (char *)"Timer_swiginit", Timer_swiginit, METH_VARARGS, NULL},
35985 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
35986 { (char *)"TimerEvent_GetInterval", (PyCFunction)_wrap_TimerEvent_GetInterval, METH_O, NULL},
35987 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
35988 { (char *)"TimerEvent_swiginit", TimerEvent_swiginit, METH_VARARGS, NULL},
35989 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
35990 { (char *)"delete_TimerRunner", (PyCFunction)_wrap_delete_TimerRunner, METH_O, NULL},
35991 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
35992 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
35993 { (char *)"TimerRunner_swiginit", TimerRunner_swiginit, METH_VARARGS, NULL},
35994 { (char *)"new_Log", (PyCFunction)_wrap_new_Log, METH_NOARGS, NULL},
35995 { (char *)"delete_Log", (PyCFunction)_wrap_delete_Log, METH_O, NULL},
35996 { (char *)"Log_IsEnabled", (PyCFunction)_wrap_Log_IsEnabled, METH_NOARGS, NULL},
35997 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
35998 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
35999 { (char *)"Log_Flush", (PyCFunction)_wrap_Log_Flush, METH_O, NULL},
36000 { (char *)"Log_FlushActive", (PyCFunction)_wrap_Log_FlushActive, METH_NOARGS, NULL},
36001 { (char *)"Log_GetActiveTarget", (PyCFunction)_wrap_Log_GetActiveTarget, METH_NOARGS, NULL},
36002 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
36003 { (char *)"Log_Suspend", (PyCFunction)_wrap_Log_Suspend, METH_NOARGS, NULL},
36004 { (char *)"Log_Resume", (PyCFunction)_wrap_Log_Resume, METH_NOARGS, NULL},
36005 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
36006 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
36007 { (char *)"Log_DontCreateOnDemand", (PyCFunction)_wrap_Log_DontCreateOnDemand, METH_NOARGS, NULL},
36008 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
36009 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
36010 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
36011 { (char *)"Log_ClearTraceMasks", (PyCFunction)_wrap_Log_ClearTraceMasks, METH_NOARGS, NULL},
36012 { (char *)"Log_GetTraceMasks", (PyCFunction)_wrap_Log_GetTraceMasks, METH_NOARGS, NULL},
36013 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
36014 { (char *)"Log_GetVerbose", (PyCFunction)_wrap_Log_GetVerbose, METH_NOARGS, NULL},
36015 { (char *)"Log_GetTraceMask", (PyCFunction)_wrap_Log_GetTraceMask, METH_NOARGS, NULL},
36016 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
36017 { (char *)"Log_GetLogLevel", (PyCFunction)_wrap_Log_GetLogLevel, METH_NOARGS, NULL},
36018 { (char *)"Log_GetTimestamp", (PyCFunction)_wrap_Log_GetTimestamp, METH_NOARGS, NULL},
36019 { (char *)"Log_TimeStamp", (PyCFunction)_wrap_Log_TimeStamp, METH_NOARGS, NULL},
36020 { (char *)"Log_Destroy", (PyCFunction)_wrap_Log_Destroy, METH_O, NULL},
36021 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
36022 { (char *)"Log_swiginit", Log_swiginit, METH_VARARGS, NULL},
36023 { (char *)"new_LogStderr", (PyCFunction)_wrap_new_LogStderr, METH_NOARGS, NULL},
36024 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
36025 { (char *)"LogStderr_swiginit", LogStderr_swiginit, METH_VARARGS, NULL},
36026 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
36027 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
36028 { (char *)"LogTextCtrl_swiginit", LogTextCtrl_swiginit, METH_VARARGS, NULL},
36029 { (char *)"new_LogGui", (PyCFunction)_wrap_new_LogGui, METH_NOARGS, NULL},
36030 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
36031 { (char *)"LogGui_swiginit", LogGui_swiginit, METH_VARARGS, NULL},
36032 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
36033 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
36034 { (char *)"LogWindow_GetFrame", (PyCFunction)_wrap_LogWindow_GetFrame, METH_O, NULL},
36035 { (char *)"LogWindow_GetOldLog", (PyCFunction)_wrap_LogWindow_GetOldLog, METH_O, NULL},
36036 { (char *)"LogWindow_IsPassingMessages", (PyCFunction)_wrap_LogWindow_IsPassingMessages, METH_O, NULL},
36037 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
36038 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
36039 { (char *)"LogWindow_swiginit", LogWindow_swiginit, METH_VARARGS, NULL},
36040 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
36041 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
36042 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
36043 { (char *)"LogChain_IsPassingMessages", (PyCFunction)_wrap_LogChain_IsPassingMessages, METH_O, NULL},
36044 { (char *)"LogChain_GetOldLog", (PyCFunction)_wrap_LogChain_GetOldLog, METH_O, NULL},
36045 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
36046 { (char *)"LogChain_swiginit", LogChain_swiginit, METH_VARARGS, NULL},
36047 { (char *)"new_LogBuffer", (PyCFunction)_wrap_new_LogBuffer, METH_NOARGS, NULL},
36048 { (char *)"LogBuffer_GetBuffer", (PyCFunction)_wrap_LogBuffer_GetBuffer, METH_O, NULL},
36049 { (char *)"LogBuffer_swigregister", LogBuffer_swigregister, METH_VARARGS, NULL},
36050 { (char *)"LogBuffer_swiginit", LogBuffer_swiginit, METH_VARARGS, NULL},
36051 { (char *)"SysErrorCode", (PyCFunction)_wrap_SysErrorCode, METH_NOARGS, NULL},
36052 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
36053 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
36054 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
36055 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
36056 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
36057 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36058 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
36059 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
36060 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
36061 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
36062 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
36063 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
36064 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
36065 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
36066 { (char *)"new_LogNull", (PyCFunction)_wrap_new_LogNull, METH_NOARGS, NULL},
36067 { (char *)"delete_LogNull", (PyCFunction)_wrap_delete_LogNull, METH_O, NULL},
36068 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
36069 { (char *)"LogNull_swiginit", LogNull_swiginit, METH_VARARGS, NULL},
36070 { (char *)"new_PyLog", (PyCFunction)_wrap_new_PyLog, METH_NOARGS, NULL},
36071 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36072 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
36073 { (char *)"PyLog_swiginit", PyLog_swiginit, METH_VARARGS, NULL},
36074 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
36075 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
36076 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
36077 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
36078 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36079 { (char *)"Process_OnTerminate", (PyCFunction) _wrap_Process_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
36080 { (char *)"Process_Redirect", (PyCFunction)_wrap_Process_Redirect, METH_O, NULL},
36081 { (char *)"Process_IsRedirected", (PyCFunction)_wrap_Process_IsRedirected, METH_O, NULL},
36082 { (char *)"Process_Detach", (PyCFunction)_wrap_Process_Detach, METH_O, NULL},
36083 { (char *)"Process_GetInputStream", (PyCFunction)_wrap_Process_GetInputStream, METH_O, NULL},
36084 { (char *)"Process_GetErrorStream", (PyCFunction)_wrap_Process_GetErrorStream, METH_O, NULL},
36085 { (char *)"Process_GetOutputStream", (PyCFunction)_wrap_Process_GetOutputStream, METH_O, NULL},
36086 { (char *)"Process_CloseOutput", (PyCFunction)_wrap_Process_CloseOutput, METH_O, NULL},
36087 { (char *)"Process_IsInputOpened", (PyCFunction)_wrap_Process_IsInputOpened, METH_O, NULL},
36088 { (char *)"Process_IsInputAvailable", (PyCFunction)_wrap_Process_IsInputAvailable, METH_O, NULL},
36089 { (char *)"Process_IsErrorAvailable", (PyCFunction)_wrap_Process_IsErrorAvailable, METH_O, NULL},
36090 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
36091 { (char *)"Process_swiginit", Process_swiginit, METH_VARARGS, NULL},
36092 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
36093 { (char *)"ProcessEvent_GetPid", (PyCFunction)_wrap_ProcessEvent_GetPid, METH_O, NULL},
36094 { (char *)"ProcessEvent_GetExitCode", (PyCFunction)_wrap_ProcessEvent_GetExitCode, METH_O, NULL},
36095 { (char *)"ProcessEvent_m_pid_set", _wrap_ProcessEvent_m_pid_set, METH_VARARGS, NULL},
36096 { (char *)"ProcessEvent_m_pid_get", (PyCFunction)_wrap_ProcessEvent_m_pid_get, METH_O, NULL},
36097 { (char *)"ProcessEvent_m_exitcode_set", _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS, NULL},
36098 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction)_wrap_ProcessEvent_m_exitcode_get, METH_O, NULL},
36099 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
36100 { (char *)"ProcessEvent_swiginit", ProcessEvent_swiginit, METH_VARARGS, NULL},
36101 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
36102 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
36103 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
36104 { (char *)"delete_Joystick", (PyCFunction)_wrap_delete_Joystick, METH_O, NULL},
36105 { (char *)"Joystick_GetPosition", (PyCFunction)_wrap_Joystick_GetPosition, METH_O, NULL},
36106 { (char *)"Joystick_GetZPosition", (PyCFunction)_wrap_Joystick_GetZPosition, METH_O, NULL},
36107 { (char *)"Joystick_GetButtonState", (PyCFunction)_wrap_Joystick_GetButtonState, METH_O, NULL},
36108 { (char *)"Joystick_GetPOVPosition", (PyCFunction)_wrap_Joystick_GetPOVPosition, METH_O, NULL},
36109 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction)_wrap_Joystick_GetPOVCTSPosition, METH_O, NULL},
36110 { (char *)"Joystick_GetRudderPosition", (PyCFunction)_wrap_Joystick_GetRudderPosition, METH_O, NULL},
36111 { (char *)"Joystick_GetUPosition", (PyCFunction)_wrap_Joystick_GetUPosition, METH_O, NULL},
36112 { (char *)"Joystick_GetVPosition", (PyCFunction)_wrap_Joystick_GetVPosition, METH_O, NULL},
36113 { (char *)"Joystick_GetMovementThreshold", (PyCFunction)_wrap_Joystick_GetMovementThreshold, METH_O, NULL},
36114 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
36115 { (char *)"Joystick_IsOk", (PyCFunction)_wrap_Joystick_IsOk, METH_O, NULL},
36116 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction)_wrap_Joystick_GetNumberJoysticks, METH_O, NULL},
36117 { (char *)"Joystick_GetManufacturerId", (PyCFunction)_wrap_Joystick_GetManufacturerId, METH_O, NULL},
36118 { (char *)"Joystick_GetProductId", (PyCFunction)_wrap_Joystick_GetProductId, METH_O, NULL},
36119 { (char *)"Joystick_GetProductName", (PyCFunction)_wrap_Joystick_GetProductName, METH_O, NULL},
36120 { (char *)"Joystick_GetXMin", (PyCFunction)_wrap_Joystick_GetXMin, METH_O, NULL},
36121 { (char *)"Joystick_GetYMin", (PyCFunction)_wrap_Joystick_GetYMin, METH_O, NULL},
36122 { (char *)"Joystick_GetZMin", (PyCFunction)_wrap_Joystick_GetZMin, METH_O, NULL},
36123 { (char *)"Joystick_GetXMax", (PyCFunction)_wrap_Joystick_GetXMax, METH_O, NULL},
36124 { (char *)"Joystick_GetYMax", (PyCFunction)_wrap_Joystick_GetYMax, METH_O, NULL},
36125 { (char *)"Joystick_GetZMax", (PyCFunction)_wrap_Joystick_GetZMax, METH_O, NULL},
36126 { (char *)"Joystick_GetNumberButtons", (PyCFunction)_wrap_Joystick_GetNumberButtons, METH_O, NULL},
36127 { (char *)"Joystick_GetNumberAxes", (PyCFunction)_wrap_Joystick_GetNumberAxes, METH_O, NULL},
36128 { (char *)"Joystick_GetMaxButtons", (PyCFunction)_wrap_Joystick_GetMaxButtons, METH_O, NULL},
36129 { (char *)"Joystick_GetMaxAxes", (PyCFunction)_wrap_Joystick_GetMaxAxes, METH_O, NULL},
36130 { (char *)"Joystick_GetPollingMin", (PyCFunction)_wrap_Joystick_GetPollingMin, METH_O, NULL},
36131 { (char *)"Joystick_GetPollingMax", (PyCFunction)_wrap_Joystick_GetPollingMax, METH_O, NULL},
36132 { (char *)"Joystick_GetRudderMin", (PyCFunction)_wrap_Joystick_GetRudderMin, METH_O, NULL},
36133 { (char *)"Joystick_GetRudderMax", (PyCFunction)_wrap_Joystick_GetRudderMax, METH_O, NULL},
36134 { (char *)"Joystick_GetUMin", (PyCFunction)_wrap_Joystick_GetUMin, METH_O, NULL},
36135 { (char *)"Joystick_GetUMax", (PyCFunction)_wrap_Joystick_GetUMax, METH_O, NULL},
36136 { (char *)"Joystick_GetVMin", (PyCFunction)_wrap_Joystick_GetVMin, METH_O, NULL},
36137 { (char *)"Joystick_GetVMax", (PyCFunction)_wrap_Joystick_GetVMax, METH_O, NULL},
36138 { (char *)"Joystick_HasRudder", (PyCFunction)_wrap_Joystick_HasRudder, METH_O, NULL},
36139 { (char *)"Joystick_HasZ", (PyCFunction)_wrap_Joystick_HasZ, METH_O, NULL},
36140 { (char *)"Joystick_HasU", (PyCFunction)_wrap_Joystick_HasU, METH_O, NULL},
36141 { (char *)"Joystick_HasV", (PyCFunction)_wrap_Joystick_HasV, METH_O, NULL},
36142 { (char *)"Joystick_HasPOV", (PyCFunction)_wrap_Joystick_HasPOV, METH_O, NULL},
36143 { (char *)"Joystick_HasPOV4Dir", (PyCFunction)_wrap_Joystick_HasPOV4Dir, METH_O, NULL},
36144 { (char *)"Joystick_HasPOVCTS", (PyCFunction)_wrap_Joystick_HasPOVCTS, METH_O, NULL},
36145 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
36146 { (char *)"Joystick_ReleaseCapture", (PyCFunction)_wrap_Joystick_ReleaseCapture, METH_O, NULL},
36147 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
36148 { (char *)"Joystick_swiginit", Joystick_swiginit, METH_VARARGS, NULL},
36149 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
36150 { (char *)"JoystickEvent_GetPosition", (PyCFunction)_wrap_JoystickEvent_GetPosition, METH_O, NULL},
36151 { (char *)"JoystickEvent_GetZPosition", (PyCFunction)_wrap_JoystickEvent_GetZPosition, METH_O, NULL},
36152 { (char *)"JoystickEvent_GetButtonState", (PyCFunction)_wrap_JoystickEvent_GetButtonState, METH_O, NULL},
36153 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction)_wrap_JoystickEvent_GetButtonChange, METH_O, NULL},
36154 { (char *)"JoystickEvent_GetJoystick", (PyCFunction)_wrap_JoystickEvent_GetJoystick, METH_O, NULL},
36155 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
36156 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
36157 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
36158 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
36159 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
36160 { (char *)"JoystickEvent_IsButton", (PyCFunction)_wrap_JoystickEvent_IsButton, METH_O, NULL},
36161 { (char *)"JoystickEvent_IsMove", (PyCFunction)_wrap_JoystickEvent_IsMove, METH_O, NULL},
36162 { (char *)"JoystickEvent_IsZMove", (PyCFunction)_wrap_JoystickEvent_IsZMove, METH_O, NULL},
36163 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
36164 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
36165 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
36166 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
36167 { (char *)"JoystickEvent_swiginit", JoystickEvent_swiginit, METH_VARARGS, NULL},
36168 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
36169 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
36170 { (char *)"delete_Sound", (PyCFunction)_wrap_delete_Sound, METH_O, NULL},
36171 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
36172 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
36173 { (char *)"Sound_IsOk", (PyCFunction)_wrap_Sound_IsOk, METH_O, NULL},
36174 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
36175 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
36176 { (char *)"Sound_Stop", (PyCFunction)_wrap_Sound_Stop, METH_NOARGS, NULL},
36177 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
36178 { (char *)"Sound_swiginit", Sound_swiginit, METH_VARARGS, NULL},
36179 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36180 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
36181 { (char *)"new_NullFileTypeInfo", (PyCFunction)_wrap_new_NullFileTypeInfo, METH_NOARGS, NULL},
36182 { (char *)"FileTypeInfo_IsValid", (PyCFunction)_wrap_FileTypeInfo_IsValid, METH_O, NULL},
36183 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
36184 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
36185 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction)_wrap_FileTypeInfo_GetMimeType, METH_O, NULL},
36186 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction)_wrap_FileTypeInfo_GetOpenCommand, METH_O, NULL},
36187 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction)_wrap_FileTypeInfo_GetPrintCommand, METH_O, NULL},
36188 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction)_wrap_FileTypeInfo_GetShortDesc, METH_O, NULL},
36189 { (char *)"FileTypeInfo_GetDescription", (PyCFunction)_wrap_FileTypeInfo_GetDescription, METH_O, NULL},
36190 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction)_wrap_FileTypeInfo_GetExtensions, METH_O, NULL},
36191 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction)_wrap_FileTypeInfo_GetExtensionsCount, METH_O, NULL},
36192 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction)_wrap_FileTypeInfo_GetIconFile, METH_O, NULL},
36193 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction)_wrap_FileTypeInfo_GetIconIndex, METH_O, NULL},
36194 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
36195 { (char *)"FileTypeInfo_swiginit", FileTypeInfo_swiginit, METH_VARARGS, NULL},
36196 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
36197 { (char *)"delete_FileType", (PyCFunction)_wrap_delete_FileType, METH_O, NULL},
36198 { (char *)"FileType_GetMimeType", (PyCFunction)_wrap_FileType_GetMimeType, METH_O, NULL},
36199 { (char *)"FileType_GetMimeTypes", (PyCFunction)_wrap_FileType_GetMimeTypes, METH_O, NULL},
36200 { (char *)"FileType_GetExtensions", (PyCFunction)_wrap_FileType_GetExtensions, METH_O, NULL},
36201 { (char *)"FileType_GetIcon", (PyCFunction)_wrap_FileType_GetIcon, METH_O, NULL},
36202 { (char *)"FileType_GetIconInfo", (PyCFunction)_wrap_FileType_GetIconInfo, METH_O, NULL},
36203 { (char *)"FileType_GetDescription", (PyCFunction)_wrap_FileType_GetDescription, METH_O, NULL},
36204 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
36205 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
36206 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
36207 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
36208 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
36209 { (char *)"FileType_Unassociate", (PyCFunction)_wrap_FileType_Unassociate, METH_O, NULL},
36210 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
36211 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
36212 { (char *)"FileType_swiginit", FileType_swiginit, METH_VARARGS, NULL},
36213 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
36214 { (char *)"new_MimeTypesManager", (PyCFunction)_wrap_new_MimeTypesManager, METH_NOARGS, NULL},
36215 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
36216 { (char *)"MimeTypesManager_ClearData", (PyCFunction)_wrap_MimeTypesManager_ClearData, METH_O, NULL},
36217 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
36218 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
36219 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
36220 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
36221 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction)_wrap_MimeTypesManager_EnumAllFileTypes, METH_O, NULL},
36222 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
36223 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
36224 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
36225 { (char *)"delete_MimeTypesManager", (PyCFunction)_wrap_delete_MimeTypesManager, METH_O, NULL},
36226 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
36227 { (char *)"MimeTypesManager_swiginit", MimeTypesManager_swiginit, METH_VARARGS, NULL},
36228 { (char *)"new_ArtProvider", (PyCFunction)_wrap_new_ArtProvider, METH_NOARGS, NULL},
36229 { (char *)"delete_ArtProvider", (PyCFunction)_wrap_delete_ArtProvider, METH_O, NULL},
36230 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36231 { (char *)"ArtProvider_PushProvider", (PyCFunction) _wrap_ArtProvider_PushProvider, METH_VARARGS | METH_KEYWORDS, NULL},
36232 { (char *)"ArtProvider_PopProvider", (PyCFunction)_wrap_ArtProvider_PopProvider, METH_NOARGS, NULL},
36233 { (char *)"ArtProvider_RemoveProvider", (PyCFunction) _wrap_ArtProvider_RemoveProvider, METH_VARARGS | METH_KEYWORDS, NULL},
36234 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
36235 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
36236 { (char *)"ArtProvider_GetSizeHint", (PyCFunction) _wrap_ArtProvider_GetSizeHint, METH_VARARGS | METH_KEYWORDS, NULL},
36237 { (char *)"ArtProvider_Destroy", (PyCFunction)_wrap_ArtProvider_Destroy, METH_O, NULL},
36238 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
36239 { (char *)"ArtProvider_swiginit", ArtProvider_swiginit, METH_VARARGS, NULL},
36240 { (char *)"delete_ConfigBase", (PyCFunction)_wrap_delete_ConfigBase, METH_O, NULL},
36241 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
36242 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
36243 { (char *)"ConfigBase_Create", (PyCFunction)_wrap_ConfigBase_Create, METH_NOARGS, NULL},
36244 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction)_wrap_ConfigBase_DontCreateOnDemand, METH_NOARGS, NULL},
36245 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
36246 { (char *)"ConfigBase_GetPath", (PyCFunction)_wrap_ConfigBase_GetPath, METH_O, NULL},
36247 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction)_wrap_ConfigBase_GetFirstGroup, METH_O, NULL},
36248 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
36249 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction)_wrap_ConfigBase_GetFirstEntry, METH_O, NULL},
36250 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
36251 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
36252 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
36253 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
36254 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
36255 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
36256 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
36257 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
36258 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
36259 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
36260 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
36261 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
36262 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
36263 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
36264 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
36265 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
36266 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
36267 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
36268 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
36269 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
36270 { (char *)"ConfigBase_DeleteAll", (PyCFunction)_wrap_ConfigBase_DeleteAll, METH_O, NULL},
36271 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
36272 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction)_wrap_ConfigBase_IsExpandingEnvVars, METH_O, NULL},
36273 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
36274 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction)_wrap_ConfigBase_IsRecordingDefaults, METH_O, NULL},
36275 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
36276 { (char *)"ConfigBase_GetAppName", (PyCFunction)_wrap_ConfigBase_GetAppName, METH_O, NULL},
36277 { (char *)"ConfigBase_GetVendorName", (PyCFunction)_wrap_ConfigBase_GetVendorName, METH_O, NULL},
36278 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
36279 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
36280 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
36281 { (char *)"ConfigBase_GetStyle", (PyCFunction)_wrap_ConfigBase_GetStyle, METH_O, NULL},
36282 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
36283 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
36284 { (char *)"delete_Config", (PyCFunction)_wrap_delete_Config, METH_O, NULL},
36285 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
36286 { (char *)"Config_swiginit", Config_swiginit, METH_VARARGS, NULL},
36287 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
36288 { (char *)"delete_FileConfig", (PyCFunction)_wrap_delete_FileConfig, METH_O, NULL},
36289 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
36290 { (char *)"FileConfig_swiginit", FileConfig_swiginit, METH_VARARGS, NULL},
36291 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
36292 { (char *)"delete_ConfigPathChanger", (PyCFunction)_wrap_delete_ConfigPathChanger, METH_O, NULL},
36293 { (char *)"ConfigPathChanger_Name", (PyCFunction)_wrap_ConfigPathChanger_Name, METH_O, NULL},
36294 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
36295 { (char *)"ConfigPathChanger_swiginit", ConfigPathChanger_swiginit, METH_VARARGS, NULL},
36296 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
36297 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
36298 { (char *)"DateTime_GetCountry", (PyCFunction)_wrap_DateTime_GetCountry, METH_NOARGS, NULL},
36299 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
36300 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
36301 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
36302 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36303 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
36304 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
36305 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
36306 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36307 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
36308 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
36309 { (char *)"DateTime_GetAmPmStrings", (PyCFunction)_wrap_DateTime_GetAmPmStrings, METH_NOARGS, NULL},
36310 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
36311 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
36312 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
36313 { (char *)"DateTime_Now", (PyCFunction)_wrap_DateTime_Now, METH_NOARGS, NULL},
36314 { (char *)"DateTime_UNow", (PyCFunction)_wrap_DateTime_UNow, METH_NOARGS, NULL},
36315 { (char *)"DateTime_Today", (PyCFunction)_wrap_DateTime_Today, METH_NOARGS, NULL},
36316 { (char *)"new_DateTime", (PyCFunction)_wrap_new_DateTime, METH_NOARGS, NULL},
36317 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
36318 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
36319 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
36320 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
36321 { (char *)"new_DateTimeFromDateTime", (PyCFunction) _wrap_new_DateTimeFromDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
36322 { (char *)"delete_DateTime", (PyCFunction)_wrap_delete_DateTime, METH_O, NULL},
36323 { (char *)"DateTime_SetToCurrent", (PyCFunction)_wrap_DateTime_SetToCurrent, METH_O, NULL},
36324 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
36325 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
36326 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
36327 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
36328 { (char *)"DateTime_ResetTime", (PyCFunction)_wrap_DateTime_ResetTime, METH_O, NULL},
36329 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
36330 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36331 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
36332 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
36333 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
36334 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
36335 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
36336 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
36337 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
36338 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36339 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36340 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36341 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36342 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36343 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36344 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36345 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
36346 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
36347 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
36348 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
36349 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
36350 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
36351 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
36352 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction)_wrap_DateTime_GetJulianDayNumber, METH_O, NULL},
36353 { (char *)"DateTime_GetJDN", (PyCFunction)_wrap_DateTime_GetJDN, METH_O, NULL},
36354 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction)_wrap_DateTime_GetModifiedJulianDayNumber, METH_O, NULL},
36355 { (char *)"DateTime_GetMJD", (PyCFunction)_wrap_DateTime_GetMJD, METH_O, NULL},
36356 { (char *)"DateTime_GetRataDie", (PyCFunction)_wrap_DateTime_GetRataDie, METH_O, NULL},
36357 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
36358 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
36359 { (char *)"DateTime_FromTimezone", (PyCFunction) _wrap_DateTime_FromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
36360 { (char *)"DateTime_MakeFromTimezone", (PyCFunction) _wrap_DateTime_MakeFromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
36361 { (char *)"DateTime_ToUTC", (PyCFunction) _wrap_DateTime_ToUTC, METH_VARARGS | METH_KEYWORDS, NULL},
36362 { (char *)"DateTime_MakeUTC", (PyCFunction) _wrap_DateTime_MakeUTC, METH_VARARGS | METH_KEYWORDS, NULL},
36363 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
36364 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
36365 { (char *)"DateTime_FromUTC", (PyCFunction) _wrap_DateTime_FromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
36366 { (char *)"DateTime_MakeFromUTC", (PyCFunction) _wrap_DateTime_MakeFromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
36367 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
36368 { (char *)"DateTime_IsValid", (PyCFunction)_wrap_DateTime_IsValid, METH_O, NULL},
36369 { (char *)"DateTime_GetTicks", (PyCFunction)_wrap_DateTime_GetTicks, METH_O, NULL},
36370 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
36371 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36372 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
36373 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36374 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
36375 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
36376 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
36377 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
36378 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
36379 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
36380 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36381 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
36382 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
36383 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
36384 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
36385 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
36386 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
36387 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
36388 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
36389 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
36390 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
36391 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
36392 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
36393 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
36394 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
36395 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
36396 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
36397 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
36398 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
36399 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
36400 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
36401 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
36402 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
36403 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
36404 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
36405 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
36406 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36407 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
36408 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
36409 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
36410 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
36411 { (char *)"DateTime_FormatDate", (PyCFunction)_wrap_DateTime_FormatDate, METH_O, NULL},
36412 { (char *)"DateTime_FormatTime", (PyCFunction)_wrap_DateTime_FormatTime, METH_O, NULL},
36413 { (char *)"DateTime_FormatISODate", (PyCFunction)_wrap_DateTime_FormatISODate, METH_O, NULL},
36414 { (char *)"DateTime_FormatISOTime", (PyCFunction)_wrap_DateTime_FormatISOTime, METH_O, NULL},
36415 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
36416 { (char *)"DateTime_swiginit", DateTime_swiginit, METH_VARARGS, NULL},
36417 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
36418 { (char *)"TimeSpan_Second", (PyCFunction)_wrap_TimeSpan_Second, METH_NOARGS, NULL},
36419 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
36420 { (char *)"TimeSpan_Minute", (PyCFunction)_wrap_TimeSpan_Minute, METH_NOARGS, NULL},
36421 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
36422 { (char *)"TimeSpan_Hour", (PyCFunction)_wrap_TimeSpan_Hour, METH_NOARGS, NULL},
36423 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
36424 { (char *)"TimeSpan_Day", (PyCFunction)_wrap_TimeSpan_Day, METH_NOARGS, NULL},
36425 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
36426 { (char *)"TimeSpan_Week", (PyCFunction)_wrap_TimeSpan_Week, METH_NOARGS, NULL},
36427 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
36428 { (char *)"delete_TimeSpan", (PyCFunction)_wrap_delete_TimeSpan, METH_O, NULL},
36429 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
36430 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
36431 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
36432 { (char *)"TimeSpan_Neg", (PyCFunction)_wrap_TimeSpan_Neg, METH_O, NULL},
36433 { (char *)"TimeSpan_Abs", (PyCFunction)_wrap_TimeSpan_Abs, METH_O, NULL},
36434 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
36435 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
36436 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
36437 { (char *)"TimeSpan___neg__", (PyCFunction)_wrap_TimeSpan___neg__, METH_O, NULL},
36438 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
36439 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
36440 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
36441 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
36442 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
36443 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
36444 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
36445 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
36446 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
36447 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
36448 { (char *)"TimeSpan_IsNull", (PyCFunction)_wrap_TimeSpan_IsNull, METH_O, NULL},
36449 { (char *)"TimeSpan_IsPositive", (PyCFunction)_wrap_TimeSpan_IsPositive, METH_O, NULL},
36450 { (char *)"TimeSpan_IsNegative", (PyCFunction)_wrap_TimeSpan_IsNegative, METH_O, NULL},
36451 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
36452 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
36453 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
36454 { (char *)"TimeSpan_GetWeeks", (PyCFunction)_wrap_TimeSpan_GetWeeks, METH_O, NULL},
36455 { (char *)"TimeSpan_GetDays", (PyCFunction)_wrap_TimeSpan_GetDays, METH_O, NULL},
36456 { (char *)"TimeSpan_GetHours", (PyCFunction)_wrap_TimeSpan_GetHours, METH_O, NULL},
36457 { (char *)"TimeSpan_GetMinutes", (PyCFunction)_wrap_TimeSpan_GetMinutes, METH_O, NULL},
36458 { (char *)"TimeSpan_GetSeconds", (PyCFunction)_wrap_TimeSpan_GetSeconds, METH_O, NULL},
36459 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction)_wrap_TimeSpan_GetMilliseconds, METH_O, NULL},
36460 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
36461 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
36462 { (char *)"TimeSpan_swiginit", TimeSpan_swiginit, METH_VARARGS, NULL},
36463 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
36464 { (char *)"delete_DateSpan", (PyCFunction)_wrap_delete_DateSpan, METH_O, NULL},
36465 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
36466 { (char *)"DateSpan_Day", (PyCFunction)_wrap_DateSpan_Day, METH_NOARGS, NULL},
36467 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
36468 { (char *)"DateSpan_Week", (PyCFunction)_wrap_DateSpan_Week, METH_NOARGS, NULL},
36469 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
36470 { (char *)"DateSpan_Month", (PyCFunction)_wrap_DateSpan_Month, METH_NOARGS, NULL},
36471 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
36472 { (char *)"DateSpan_Year", (PyCFunction)_wrap_DateSpan_Year, METH_NOARGS, NULL},
36473 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
36474 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
36475 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
36476 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
36477 { (char *)"DateSpan_GetYears", (PyCFunction)_wrap_DateSpan_GetYears, METH_O, NULL},
36478 { (char *)"DateSpan_GetMonths", (PyCFunction)_wrap_DateSpan_GetMonths, METH_O, NULL},
36479 { (char *)"DateSpan_GetWeeks", (PyCFunction)_wrap_DateSpan_GetWeeks, METH_O, NULL},
36480 { (char *)"DateSpan_GetDays", (PyCFunction)_wrap_DateSpan_GetDays, METH_O, NULL},
36481 { (char *)"DateSpan_GetTotalDays", (PyCFunction)_wrap_DateSpan_GetTotalDays, METH_O, NULL},
36482 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
36483 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
36484 { (char *)"DateSpan_Neg", (PyCFunction)_wrap_DateSpan_Neg, METH_O, NULL},
36485 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
36486 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
36487 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
36488 { (char *)"DateSpan___neg__", (PyCFunction)_wrap_DateSpan___neg__, METH_O, NULL},
36489 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
36490 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
36491 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
36492 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
36493 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
36494 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
36495 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
36496 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
36497 { (char *)"DateSpan_swiginit", DateSpan_swiginit, METH_VARARGS, NULL},
36498 { (char *)"GetLocalTime", (PyCFunction)_wrap_GetLocalTime, METH_NOARGS, NULL},
36499 { (char *)"GetUTCTime", (PyCFunction)_wrap_GetUTCTime, METH_NOARGS, NULL},
36500 { (char *)"GetCurrentTime", (PyCFunction)_wrap_GetCurrentTime, METH_NOARGS, NULL},
36501 { (char *)"GetLocalTimeMillis", (PyCFunction)_wrap_GetLocalTimeMillis, METH_NOARGS, NULL},
36502 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36503 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36504 { (char *)"delete_DataFormat", (PyCFunction)_wrap_delete_DataFormat, METH_O, NULL},
36505 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
36506 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
36507 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
36508 { (char *)"DataFormat_GetType", (PyCFunction)_wrap_DataFormat_GetType, METH_O, NULL},
36509 { (char *)"DataFormat_GetId", (PyCFunction)_wrap_DataFormat_GetId, METH_O, NULL},
36510 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
36511 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
36512 { (char *)"DataFormat_swiginit", DataFormat_swiginit, METH_VARARGS, NULL},
36513 { (char *)"delete_DataObject", (PyCFunction)_wrap_delete_DataObject, METH_O, NULL},
36514 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36515 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
36516 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
36517 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
36518 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
36519 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
36520 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
36521 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
36522 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
36523 { (char *)"DataObjectSimple_GetFormat", (PyCFunction)_wrap_DataObjectSimple_GetFormat, METH_O, NULL},
36524 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36525 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction)_wrap_DataObjectSimple_GetDataSize, METH_O, NULL},
36526 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction)_wrap_DataObjectSimple_GetDataHere, METH_O, NULL},
36527 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
36528 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
36529 { (char *)"DataObjectSimple_swiginit", DataObjectSimple_swiginit, METH_VARARGS, NULL},
36530 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
36531 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36532 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
36533 { (char *)"PyDataObjectSimple_swiginit", PyDataObjectSimple_swiginit, METH_VARARGS, NULL},
36534 { (char *)"new_DataObjectComposite", (PyCFunction)_wrap_new_DataObjectComposite, METH_NOARGS, NULL},
36535 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
36536 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
36537 { (char *)"DataObjectComposite_swiginit", DataObjectComposite_swiginit, METH_VARARGS, NULL},
36538 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
36539 { (char *)"TextDataObject_GetTextLength", (PyCFunction)_wrap_TextDataObject_GetTextLength, METH_O, NULL},
36540 { (char *)"TextDataObject_GetText", (PyCFunction)_wrap_TextDataObject_GetText, METH_O, NULL},
36541 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
36542 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
36543 { (char *)"TextDataObject_swiginit", TextDataObject_swiginit, METH_VARARGS, NULL},
36544 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
36545 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36546 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
36547 { (char *)"PyTextDataObject_swiginit", PyTextDataObject_swiginit, METH_VARARGS, NULL},
36548 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
36549 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction)_wrap_BitmapDataObject_GetBitmap, METH_O, NULL},
36550 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
36551 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
36552 { (char *)"BitmapDataObject_swiginit", BitmapDataObject_swiginit, METH_VARARGS, NULL},
36553 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
36554 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36555 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
36556 { (char *)"PyBitmapDataObject_swiginit", PyBitmapDataObject_swiginit, METH_VARARGS, NULL},
36557 { (char *)"new_FileDataObject", (PyCFunction)_wrap_new_FileDataObject, METH_NOARGS, NULL},
36558 { (char *)"FileDataObject_GetFilenames", (PyCFunction)_wrap_FileDataObject_GetFilenames, METH_O, NULL},
36559 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
36560 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
36561 { (char *)"FileDataObject_swiginit", FileDataObject_swiginit, METH_VARARGS, NULL},
36562 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
36563 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
36564 { (char *)"CustomDataObject_GetSize", (PyCFunction)_wrap_CustomDataObject_GetSize, METH_O, NULL},
36565 { (char *)"CustomDataObject_GetData", (PyCFunction)_wrap_CustomDataObject_GetData, METH_O, NULL},
36566 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
36567 { (char *)"CustomDataObject_swiginit", CustomDataObject_swiginit, METH_VARARGS, NULL},
36568 { (char *)"new_URLDataObject", (PyCFunction)_wrap_new_URLDataObject, METH_NOARGS, NULL},
36569 { (char *)"URLDataObject_GetURL", (PyCFunction)_wrap_URLDataObject_GetURL, METH_O, NULL},
36570 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
36571 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
36572 { (char *)"URLDataObject_swiginit", URLDataObject_swiginit, METH_VARARGS, NULL},
36573 { (char *)"new_MetafileDataObject", (PyCFunction)_wrap_new_MetafileDataObject, METH_NOARGS, NULL},
36574 { (char *)"MetafileDataObject_SetMetafile", (PyCFunction) _wrap_MetafileDataObject_SetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
36575 { (char *)"MetafileDataObject_GetMetafile", (PyCFunction)_wrap_MetafileDataObject_GetMetafile, METH_O, NULL},
36576 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
36577 { (char *)"MetafileDataObject_swiginit", MetafileDataObject_swiginit, METH_VARARGS, NULL},
36578 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
36579 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
36580 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36581 { (char *)"delete_DropSource", (PyCFunction)_wrap_delete_DropSource, METH_O, NULL},
36582 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
36583 { (char *)"DropSource_GetDataObject", (PyCFunction)_wrap_DropSource_GetDataObject, METH_O, NULL},
36584 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
36585 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
36586 { (char *)"DropSource_GiveFeedback", (PyCFunction) _wrap_DropSource_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
36587 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
36588 { (char *)"DropSource_swiginit", DropSource_swiginit, METH_VARARGS, NULL},
36589 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
36590 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36591 { (char *)"delete_DropTarget", (PyCFunction)_wrap_delete_DropTarget, METH_O, NULL},
36592 { (char *)"DropTarget_GetDataObject", (PyCFunction)_wrap_DropTarget_GetDataObject, METH_O, NULL},
36593 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
36594 { (char *)"DropTarget_OnEnter", (PyCFunction) _wrap_DropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
36595 { (char *)"DropTarget_OnDragOver", (PyCFunction) _wrap_DropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
36596 { (char *)"DropTarget_OnLeave", (PyCFunction)_wrap_DropTarget_OnLeave, METH_O, NULL},
36597 { (char *)"DropTarget_OnDrop", (PyCFunction) _wrap_DropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
36598 { (char *)"DropTarget_GetData", (PyCFunction)_wrap_DropTarget_GetData, METH_O, NULL},
36599 { (char *)"DropTarget_SetDefaultAction", (PyCFunction) _wrap_DropTarget_SetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
36600 { (char *)"DropTarget_GetDefaultAction", (PyCFunction)_wrap_DropTarget_GetDefaultAction, METH_O, NULL},
36601 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
36602 { (char *)"DropTarget_swiginit", DropTarget_swiginit, METH_VARARGS, NULL},
36603 { (char *)"new_TextDropTarget", (PyCFunction)_wrap_new_TextDropTarget, METH_NOARGS, NULL},
36604 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36605 { (char *)"TextDropTarget_OnDropText", (PyCFunction) _wrap_TextDropTarget_OnDropText, METH_VARARGS | METH_KEYWORDS, NULL},
36606 { (char *)"TextDropTarget_OnEnter", (PyCFunction) _wrap_TextDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
36607 { (char *)"TextDropTarget_OnDragOver", (PyCFunction) _wrap_TextDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
36608 { (char *)"TextDropTarget_OnLeave", (PyCFunction)_wrap_TextDropTarget_OnLeave, METH_O, NULL},
36609 { (char *)"TextDropTarget_OnDrop", (PyCFunction) _wrap_TextDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
36610 { (char *)"TextDropTarget_OnData", (PyCFunction) _wrap_TextDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
36611 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
36612 { (char *)"TextDropTarget_swiginit", TextDropTarget_swiginit, METH_VARARGS, NULL},
36613 { (char *)"new_FileDropTarget", (PyCFunction)_wrap_new_FileDropTarget, METH_NOARGS, NULL},
36614 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36615 { (char *)"FileDropTarget_OnDropFiles", (PyCFunction) _wrap_FileDropTarget_OnDropFiles, METH_VARARGS | METH_KEYWORDS, NULL},
36616 { (char *)"FileDropTarget_OnEnter", (PyCFunction) _wrap_FileDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
36617 { (char *)"FileDropTarget_OnDragOver", (PyCFunction) _wrap_FileDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
36618 { (char *)"FileDropTarget_OnLeave", (PyCFunction)_wrap_FileDropTarget_OnLeave, METH_O, NULL},
36619 { (char *)"FileDropTarget_OnDrop", (PyCFunction) _wrap_FileDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
36620 { (char *)"FileDropTarget_OnData", (PyCFunction) _wrap_FileDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
36621 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
36622 { (char *)"FileDropTarget_swiginit", FileDropTarget_swiginit, METH_VARARGS, NULL},
36623 { (char *)"new_Clipboard", (PyCFunction)_wrap_new_Clipboard, METH_NOARGS, NULL},
36624 { (char *)"delete_Clipboard", (PyCFunction)_wrap_delete_Clipboard, METH_O, NULL},
36625 { (char *)"Clipboard_Open", (PyCFunction)_wrap_Clipboard_Open, METH_O, NULL},
36626 { (char *)"Clipboard_Close", (PyCFunction)_wrap_Clipboard_Close, METH_O, NULL},
36627 { (char *)"Clipboard_IsOpened", (PyCFunction)_wrap_Clipboard_IsOpened, METH_O, NULL},
36628 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
36629 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
36630 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
36631 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
36632 { (char *)"Clipboard_Clear", (PyCFunction)_wrap_Clipboard_Clear, METH_O, NULL},
36633 { (char *)"Clipboard_Flush", (PyCFunction)_wrap_Clipboard_Flush, METH_O, NULL},
36634 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
36635 { (char *)"Clipboard_Get", (PyCFunction)_wrap_Clipboard_Get, METH_NOARGS, NULL},
36636 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
36637 { (char *)"Clipboard_swiginit", Clipboard_swiginit, METH_VARARGS, NULL},
36638 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
36639 { (char *)"delete_ClipboardLocker", (PyCFunction)_wrap_delete_ClipboardLocker, METH_O, NULL},
36640 { (char *)"ClipboardLocker___nonzero__", (PyCFunction)_wrap_ClipboardLocker___nonzero__, METH_O, NULL},
36641 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
36642 { (char *)"ClipboardLocker_swiginit", ClipboardLocker_swiginit, METH_VARARGS, NULL},
36643 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
36644 { (char *)"delete_VideoMode", (PyCFunction)_wrap_delete_VideoMode, METH_O, NULL},
36645 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
36646 { (char *)"VideoMode_GetWidth", (PyCFunction)_wrap_VideoMode_GetWidth, METH_O, NULL},
36647 { (char *)"VideoMode_GetHeight", (PyCFunction)_wrap_VideoMode_GetHeight, METH_O, NULL},
36648 { (char *)"VideoMode_GetDepth", (PyCFunction)_wrap_VideoMode_GetDepth, METH_O, NULL},
36649 { (char *)"VideoMode_IsOk", (PyCFunction)_wrap_VideoMode_IsOk, METH_O, NULL},
36650 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
36651 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
36652 { (char *)"VideoMode_w_set", _wrap_VideoMode_w_set, METH_VARARGS, NULL},
36653 { (char *)"VideoMode_w_get", (PyCFunction)_wrap_VideoMode_w_get, METH_O, NULL},
36654 { (char *)"VideoMode_h_set", _wrap_VideoMode_h_set, METH_VARARGS, NULL},
36655 { (char *)"VideoMode_h_get", (PyCFunction)_wrap_VideoMode_h_get, METH_O, NULL},
36656 { (char *)"VideoMode_bpp_set", _wrap_VideoMode_bpp_set, METH_VARARGS, NULL},
36657 { (char *)"VideoMode_bpp_get", (PyCFunction)_wrap_VideoMode_bpp_get, METH_O, NULL},
36658 { (char *)"VideoMode_refresh_set", _wrap_VideoMode_refresh_set, METH_VARARGS, NULL},
36659 { (char *)"VideoMode_refresh_get", (PyCFunction)_wrap_VideoMode_refresh_get, METH_O, NULL},
36660 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
36661 { (char *)"VideoMode_swiginit", VideoMode_swiginit, METH_VARARGS, NULL},
36662 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
36663 { (char *)"delete_Display", (PyCFunction)_wrap_delete_Display, METH_O, NULL},
36664 { (char *)"Display_GetCount", (PyCFunction)_wrap_Display_GetCount, METH_NOARGS, NULL},
36665 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
36666 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
36667 { (char *)"Display_IsOk", (PyCFunction)_wrap_Display_IsOk, METH_O, NULL},
36668 { (char *)"Display_GetGeometry", (PyCFunction)_wrap_Display_GetGeometry, METH_O, NULL},
36669 { (char *)"Display_GetClientArea", (PyCFunction)_wrap_Display_GetClientArea, METH_O, NULL},
36670 { (char *)"Display_GetName", (PyCFunction)_wrap_Display_GetName, METH_O, NULL},
36671 { (char *)"Display_IsPrimary", (PyCFunction)_wrap_Display_IsPrimary, METH_O, NULL},
36672 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
36673 { (char *)"Display_GetCurrentMode", (PyCFunction)_wrap_Display_GetCurrentMode, METH_O, NULL},
36674 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
36675 { (char *)"Display_ResetMode", (PyCFunction)_wrap_Display_ResetMode, METH_O, NULL},
36676 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
36677 { (char *)"Display_swiginit", Display_swiginit, METH_VARARGS, NULL},
36678 { (char *)"StandardPaths_Get", (PyCFunction)_wrap_StandardPaths_Get, METH_NOARGS, NULL},
36679 { (char *)"StandardPaths_GetConfigDir", (PyCFunction)_wrap_StandardPaths_GetConfigDir, METH_O, NULL},
36680 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction)_wrap_StandardPaths_GetUserConfigDir, METH_O, NULL},
36681 { (char *)"StandardPaths_GetDataDir", (PyCFunction)_wrap_StandardPaths_GetDataDir, METH_O, NULL},
36682 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetLocalDataDir, METH_O, NULL},
36683 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction)_wrap_StandardPaths_GetUserDataDir, METH_O, NULL},
36684 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetUserLocalDataDir, METH_O, NULL},
36685 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction)_wrap_StandardPaths_GetPluginsDir, METH_O, NULL},
36686 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
36687 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction)_wrap_StandardPaths_GetInstallPrefix, METH_O, NULL},
36688 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
36689 { NULL, NULL, 0, NULL }
36690 };
36691
36692
36693 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
36694
36695 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
36696 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
36697 }
36698 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
36699 return (void *)((wxEvent *) ((wxMenuEvent *) x));
36700 }
36701 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
36702 return (void *)((wxEvent *) ((wxCloseEvent *) x));
36703 }
36704 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
36705 return (void *)((wxEvent *) ((wxMouseEvent *) x));
36706 }
36707 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
36708 return (void *)((wxEvent *) ((wxEraseEvent *) x));
36709 }
36710 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
36711 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
36712 }
36713 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
36714 return (void *)((wxEvent *) ((wxTimerEvent *) x));
36715 }
36716 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
36717 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
36718 }
36719 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
36720 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
36721 }
36722 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
36723 return (void *)((wxEvent *) ((wxPyEvent *) x));
36724 }
36725 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
36726 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
36727 }
36728 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
36729 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
36730 }
36731 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
36732 return (void *)((wxEvent *) ((wxIdleEvent *) x));
36733 }
36734 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
36735 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
36736 }
36737 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
36738 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
36739 }
36740 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
36741 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
36742 }
36743 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
36744 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
36745 }
36746 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
36747 return (void *)((wxEvent *) ((wxActivateEvent *) x));
36748 }
36749 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
36750 return (void *)((wxEvent *) ((wxSizeEvent *) x));
36751 }
36752 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
36753 return (void *)((wxEvent *) ((wxMoveEvent *) x));
36754 }
36755 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
36756 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
36757 }
36758 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
36759 return (void *)((wxEvent *) ((wxPaintEvent *) x));
36760 }
36761 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
36762 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
36763 }
36764 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
36765 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
36766 }
36767 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
36768 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
36769 }
36770 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
36771 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
36772 }
36773 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
36774 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
36775 }
36776 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
36777 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
36778 }
36779 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
36780 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
36781 }
36782 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
36783 return (void *)((wxEvent *) ((wxFocusEvent *) x));
36784 }
36785 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
36786 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
36787 }
36788 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
36789 return (void *)((wxEvent *) ((wxProcessEvent *) x));
36790 }
36791 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
36792 return (void *)((wxEvent *) ((wxShowEvent *) x));
36793 }
36794 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
36795 return (void *)((wxEvent *) ((wxCommandEvent *) x));
36796 }
36797 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
36798 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
36799 }
36800 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
36801 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
36802 }
36803 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
36804 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
36805 }
36806 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
36807 return (void *)((wxEvent *) ((wxKeyEvent *) x));
36808 }
36809 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
36810 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
36811 }
36812 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
36813 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
36814 }
36815 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
36816 return (void *)((wxConfigBase *) ((wxConfig *) x));
36817 }
36818 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
36819 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
36820 }
36821 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
36822 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
36823 }
36824 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
36825 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
36826 }
36827 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
36828 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
36829 }
36830 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
36831 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
36832 }
36833 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
36834 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
36835 }
36836 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
36837 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
36838 }
36839 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
36840 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
36841 }
36842 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
36843 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
36844 }
36845 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
36846 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
36847 }
36848 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
36849 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
36850 }
36851 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
36852 return (void *)((wxDataObject *) ((wxURLDataObject *) x));
36853 }
36854 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
36855 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
36856 }
36857 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
36858 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
36859 }
36860 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
36861 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
36862 }
36863 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
36864 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
36865 }
36866 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
36867 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
36868 }
36869 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
36870 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
36871 }
36872 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
36873 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
36874 }
36875 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
36876 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
36877 }
36878 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
36879 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
36880 }
36881 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
36882 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
36883 }
36884 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
36885 return (void *)((wxEvtHandler *) ((wxWindow *) x));
36886 }
36887 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
36888 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
36889 }
36890 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
36891 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
36892 }
36893 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
36894 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
36895 }
36896 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
36897 return (void *)((wxEvtHandler *) ((wxValidator *) x));
36898 }
36899 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
36900 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
36901 }
36902 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
36903 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
36904 }
36905 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
36906 return (void *)((wxEvtHandler *) ((wxMenu *) x));
36907 }
36908 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
36909 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
36910 }
36911 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
36912 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
36913 }
36914 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
36915 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
36916 }
36917 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
36918 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
36919 }
36920 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
36921 return (void *)((wxObject *) ((wxSizerItem *) x));
36922 }
36923 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
36924 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
36925 }
36926 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
36927 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
36928 }
36929 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
36930 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
36931 }
36932 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
36933 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
36934 }
36935 static void *_p_wxSizerTo_p_wxObject(void *x) {
36936 return (void *)((wxObject *) ((wxSizer *) x));
36937 }
36938 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
36939 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
36940 }
36941 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
36942 return (void *)((wxObject *) ((wxFileHistory *) x));
36943 }
36944 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
36945 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
36946 }
36947 static void *_p_wxEventTo_p_wxObject(void *x) {
36948 return (void *)((wxObject *) ((wxEvent *) x));
36949 }
36950 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
36951 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
36952 }
36953 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
36954 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
36955 }
36956 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
36957 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
36958 }
36959 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
36960 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
36961 }
36962 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
36963 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
36964 }
36965 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
36966 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
36967 }
36968 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
36969 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
36970 }
36971 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
36972 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
36973 }
36974 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
36975 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
36976 }
36977 static void *_p_wxControlTo_p_wxObject(void *x) {
36978 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
36979 }
36980 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
36981 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
36982 }
36983 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
36984 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
36985 }
36986 static void *_p_wxFSFileTo_p_wxObject(void *x) {
36987 return (void *)((wxObject *) ((wxFSFile *) x));
36988 }
36989 static void *_p_wxClipboardTo_p_wxObject(void *x) {
36990 return (void *)((wxObject *) ((wxClipboard *) x));
36991 }
36992 static void *_p_wxPySizerTo_p_wxObject(void *x) {
36993 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
36994 }
36995 static void *_p_wxPyEventTo_p_wxObject(void *x) {
36996 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
36997 }
36998 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
36999 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
37000 }
37001 static void *_p_wxShowEventTo_p_wxObject(void *x) {
37002 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
37003 }
37004 static void *_p_wxToolTipTo_p_wxObject(void *x) {
37005 return (void *)((wxObject *) ((wxToolTip *) x));
37006 }
37007 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
37008 return (void *)((wxObject *) ((wxMenuItem *) x));
37009 }
37010 static void *_p_wxDateEventTo_p_wxObject(void *x) {
37011 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
37012 }
37013 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
37014 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
37015 }
37016 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
37017 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
37018 }
37019 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
37020 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
37021 }
37022 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
37023 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
37024 }
37025 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
37026 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
37027 }
37028 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
37029 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
37030 }
37031 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
37032 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
37033 }
37034 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
37035 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
37036 }
37037 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
37038 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
37039 }
37040 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
37041 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
37042 }
37043 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
37044 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
37045 }
37046 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
37047 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
37048 }
37049 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
37050 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
37051 }
37052 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
37053 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
37054 }
37055 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
37056 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
37057 }
37058 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
37059 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
37060 }
37061 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
37062 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
37063 }
37064 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
37065 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
37066 }
37067 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
37068 return (void *)((wxObject *) ((wxImageHandler *) x));
37069 }
37070 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
37071 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
37072 }
37073 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
37074 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
37075 }
37076 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
37077 return (void *)((wxObject *) ((wxEvtHandler *) x));
37078 }
37079 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
37080 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
37081 }
37082 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
37083 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
37084 }
37085 static void *_p_wxImageTo_p_wxObject(void *x) {
37086 return (void *)((wxObject *) ((wxImage *) x));
37087 }
37088 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
37089 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
37090 }
37091 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
37092 return (void *)((wxObject *) ((wxSystemOptions *) x));
37093 }
37094 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
37095 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
37096 }
37097 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
37098 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
37099 }
37100 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
37101 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
37102 }
37103 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
37104 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
37105 }
37106 static void *_p_wxWindowTo_p_wxObject(void *x) {
37107 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
37108 }
37109 static void *_p_wxMenuTo_p_wxObject(void *x) {
37110 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
37111 }
37112 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
37113 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
37114 }
37115 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
37116 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
37117 }
37118 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
37119 return (void *)((wxObject *) ((wxFileSystem *) x));
37120 }
37121 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
37122 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
37123 }
37124 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
37125 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
37126 }
37127 static void *_p_wxPyAppTo_p_wxObject(void *x) {
37128 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
37129 }
37130 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
37131 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
37132 }
37133 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
37134 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
37135 }
37136 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
37137 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
37138 }
37139 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
37140 return (void *)((wxObject *) ((wxBusyInfo *) x));
37141 }
37142 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
37143 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
37144 }
37145 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
37146 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
37147 }
37148 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
37149 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
37150 }
37151 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
37152 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
37153 }
37154 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
37155 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
37156 }
37157 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
37158 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
37159 }
37160 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
37161 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
37162 }
37163 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
37164 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
37165 }
37166 static void *_p_wxValidatorTo_p_wxObject(void *x) {
37167 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
37168 }
37169 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
37170 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
37171 }
37172 static void *_p_wxLogBufferTo_p_wxLog(void *x) {
37173 return (void *)((wxLog *) ((wxLogBuffer *) x));
37174 }
37175 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
37176 return (void *)((wxLog *) ((wxLogStderr *) x));
37177 }
37178 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
37179 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
37180 }
37181 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
37182 return (void *)((wxLog *) ((wxLogWindow *) x));
37183 }
37184 static void *_p_wxLogChainTo_p_wxLog(void *x) {
37185 return (void *)((wxLog *) ((wxLogChain *) x));
37186 }
37187 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
37188 return (void *)((wxLog *) ((wxLogGui *) x));
37189 }
37190 static void *_p_wxPyLogTo_p_wxLog(void *x) {
37191 return (void *)((wxLog *) ((wxPyLog *) x));
37192 }
37193 static void *_p_wxControlTo_p_wxWindow(void *x) {
37194 return (void *)((wxWindow *) ((wxControl *) x));
37195 }
37196 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
37197 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
37198 }
37199 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
37200 return (void *)((wxWindow *) ((wxMenuBar *) x));
37201 }
37202 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
37203 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
37204 }
37205 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
37206 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
37207 }
37208 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
37209 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};
37210 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
37211 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
37212 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
37213 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxLogLevel *", 0, 0, (void*)0, 0};
37214 static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
37215 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
37216 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
37217 static swig_type_info _swigt__p_wxBitmapDataObject = {"_p_wxBitmapDataObject", "wxBitmapDataObject *", 0, 0, (void*)0, 0};
37218 static swig_type_info _swigt__p_wxBusyCursor = {"_p_wxBusyCursor", "wxBusyCursor *", 0, 0, (void*)0, 0};
37219 static swig_type_info _swigt__p_wxBusyInfo = {"_p_wxBusyInfo", "wxBusyInfo *", 0, 0, (void*)0, 0};
37220 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
37221 static swig_type_info _swigt__p_wxChar = {"_p_wxChar", "wxChar *", 0, 0, (void*)0, 0};
37222 static swig_type_info _swigt__p_wxClipboard = {"_p_wxClipboard", "wxClipboard *", 0, 0, (void*)0, 0};
37223 static swig_type_info _swigt__p_wxClipboardLocker = {"_p_wxClipboardLocker", "wxClipboardLocker *", 0, 0, (void*)0, 0};
37224 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
37225 static swig_type_info _swigt__p_wxConfig = {"_p_wxConfig", "wxConfig *", 0, 0, (void*)0, 0};
37226 static swig_type_info _swigt__p_wxConfigBase = {"_p_wxConfigBase", "wxConfigBase *", 0, 0, (void*)0, 0};
37227 static swig_type_info _swigt__p_wxConfigPathChanger = {"_p_wxConfigPathChanger", "wxConfigPathChanger *", 0, 0, (void*)0, 0};
37228 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
37229 static swig_type_info _swigt__p_wxCustomDataObject = {"_p_wxCustomDataObject", "wxCustomDataObject *", 0, 0, (void*)0, 0};
37230 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
37231 static swig_type_info _swigt__p_wxDataFormat = {"_p_wxDataFormat", "wxDataFormat *", 0, 0, (void*)0, 0};
37232 static swig_type_info _swigt__p_wxDataObject = {"_p_wxDataObject", "wxDataObject *", 0, 0, (void*)0, 0};
37233 static swig_type_info _swigt__p_wxDataObjectComposite = {"_p_wxDataObjectComposite", "wxDataObjectComposite *", 0, 0, (void*)0, 0};
37234 static swig_type_info _swigt__p_wxDataObjectSimple = {"_p_wxDataObjectSimple", "wxDataObjectSimple *", 0, 0, (void*)0, 0};
37235 static swig_type_info _swigt__p_wxDateSpan = {"_p_wxDateSpan", "wxDateSpan *", 0, 0, (void*)0, 0};
37236 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
37237 static swig_type_info _swigt__p_wxDateTime__TimeZone = {"_p_wxDateTime__TimeZone", "wxDateTime::TimeZone *", 0, 0, (void*)0, 0};
37238 static swig_type_info _swigt__p_wxDisplay = {"_p_wxDisplay", "wxDisplay *", 0, 0, (void*)0, 0};
37239 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
37240 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
37241 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0, 0};
37242 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0, 0};
37243 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0, 0};
37244 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0, 0};
37245 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0, 0};
37246 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0, 0};
37247 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0, 0};
37248 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0, 0};
37249 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0, 0};
37250 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", 0, 0, 0, 0, 0};
37251 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0, 0};
37252 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0};
37253 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0};
37254 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0, 0};
37255 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0, 0};
37256 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0, 0};
37257 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0, 0};
37258 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0, 0};
37259 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0, 0};
37260 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0, 0};
37261 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0, 0};
37262 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0};
37263 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0};
37264 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0};
37265 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0};
37266 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0};
37267 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0, 0};
37268 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0, 0};
37269 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0, 0};
37270 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0, 0};
37271 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", 0, 0, 0, 0, 0};
37272 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0, 0};
37273 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0};
37274 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0};
37275 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", 0, 0, 0, 0, 0};
37276 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0, 0};
37277 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
37278 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", 0, 0, 0, 0, 0};
37279 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0, 0};
37280 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0, 0};
37281 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0, 0};
37282 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0, 0};
37283 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0, 0};
37284 static swig_type_info _swigt__p_wxFileConfig = {"_p_wxFileConfig", "wxFileConfig *", 0, 0, (void*)0, 0};
37285 static swig_type_info _swigt__p_wxFileDataObject = {"_p_wxFileDataObject", "wxFileDataObject *", 0, 0, (void*)0, 0};
37286 static swig_type_info _swigt__p_wxFileHistory = {"_p_wxFileHistory", "wxFileHistory *", 0, 0, (void*)0, 0};
37287 static swig_type_info _swigt__p_wxFileType = {"_p_wxFileType", "wxFileType *", 0, 0, (void*)0, 0};
37288 static swig_type_info _swigt__p_wxFileTypeInfo = {"_p_wxFileTypeInfo", "wxFileTypeInfo *", 0, 0, (void*)0, 0};
37289 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
37290 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
37291 static swig_type_info _swigt__p_wxIcon = {"_p_wxIcon", "wxIcon *", 0, 0, (void*)0, 0};
37292 static swig_type_info _swigt__p_wxJoystick = {"_p_wxJoystick", "wxJoystick *", 0, 0, (void*)0, 0};
37293 static swig_type_info _swigt__p_wxJoystickEvent = {"_p_wxJoystickEvent", "wxJoystickEvent *", 0, 0, (void*)0, 0};
37294 static swig_type_info _swigt__p_wxKillError = {"_p_wxKillError", "enum wxKillError *|wxKillError *", 0, 0, (void*)0, 0};
37295 static swig_type_info _swigt__p_wxLog = {"_p_wxLog", "wxLog *", 0, 0, (void*)0, 0};
37296 static swig_type_info _swigt__p_wxLogBuffer = {"_p_wxLogBuffer", "wxLogBuffer *", 0, 0, (void*)0, 0};
37297 static swig_type_info _swigt__p_wxLogChain = {"_p_wxLogChain", "wxLogChain *", 0, 0, (void*)0, 0};
37298 static swig_type_info _swigt__p_wxLogGui = {"_p_wxLogGui", "wxLogGui *", 0, 0, (void*)0, 0};
37299 static swig_type_info _swigt__p_wxLogNull = {"_p_wxLogNull", "wxLogNull *", 0, 0, (void*)0, 0};
37300 static swig_type_info _swigt__p_wxLogStderr = {"_p_wxLogStderr", "wxLogStderr *", 0, 0, (void*)0, 0};
37301 static swig_type_info _swigt__p_wxLogTextCtrl = {"_p_wxLogTextCtrl", "wxLogTextCtrl *", 0, 0, (void*)0, 0};
37302 static swig_type_info _swigt__p_wxLogWindow = {"_p_wxLogWindow", "wxLogWindow *", 0, 0, (void*)0, 0};
37303 static swig_type_info _swigt__p_wxMemorySize = {"_p_wxMemorySize", "wxMemorySize *", 0, 0, (void*)0, 0};
37304 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
37305 static swig_type_info _swigt__p_wxMetafile = {"_p_wxMetafile", "wxMetafile *", 0, 0, (void*)0, 0};
37306 static swig_type_info _swigt__p_wxMetafileDataObject = {"_p_wxMetafileDataObject", "wxMetafileDataObject *", 0, 0, (void*)0, 0};
37307 static swig_type_info _swigt__p_wxMimeTypesManager = {"_p_wxMimeTypesManager", "wxMimeTypesManager *", 0, 0, (void*)0, 0};
37308 static swig_type_info _swigt__p_wxMouseState = {"_p_wxMouseState", "wxMouseState *", 0, 0, (void*)0, 0};
37309 static swig_type_info _swigt__p_wxMutexGuiLocker = {"_p_wxMutexGuiLocker", "wxMutexGuiLocker *", 0, 0, (void*)0, 0};
37310 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
37311 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0, 0};
37312 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0, 0};
37313 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0, 0};
37314 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0};
37315 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0};
37316 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0, 0};
37317 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0, 0};
37318 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0, 0};
37319 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0, 0};
37320 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0, 0};
37321 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0, 0};
37322 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0, 0};
37323 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0, 0};
37324 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0, 0};
37325 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0, 0};
37326 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0, 0};
37327 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0, 0};
37328 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0, 0};
37329 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0, 0};
37330 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0, 0};
37331 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0, 0};
37332 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0, 0};
37333 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0, 0};
37334 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0, 0};
37335 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0, 0};
37336 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0, 0};
37337 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0};
37338 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0, 0};
37339 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", 0, 0, 0, 0, 0};
37340 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0, 0};
37341 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
37342 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
37343 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
37344 static swig_type_info _swigt__p_wxProcessEvent = {"_p_wxProcessEvent", "wxProcessEvent *", 0, 0, (void*)0, 0};
37345 static swig_type_info _swigt__p_wxPyArtProvider = {"_p_wxPyArtProvider", "wxPyArtProvider *", 0, 0, (void*)0, 0};
37346 static swig_type_info _swigt__p_wxPyBitmapDataObject = {"_p_wxPyBitmapDataObject", "wxPyBitmapDataObject *", 0, 0, (void*)0, 0};
37347 static swig_type_info _swigt__p_wxPyDataObjectSimple = {"_p_wxPyDataObjectSimple", "wxPyDataObjectSimple *", 0, 0, (void*)0, 0};
37348 static swig_type_info _swigt__p_wxPyDropSource = {"_p_wxPyDropSource", "wxPyDropSource *", 0, 0, (void*)0, 0};
37349 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
37350 static swig_type_info _swigt__p_wxPyFileDropTarget = {"_p_wxPyFileDropTarget", "wxPyFileDropTarget *", 0, 0, (void*)0, 0};
37351 static swig_type_info _swigt__p_wxPyLog = {"_p_wxPyLog", "wxPyLog *", 0, 0, (void*)0, 0};
37352 static swig_type_info _swigt__p_wxPyProcess = {"_p_wxPyProcess", "wxPyProcess *", 0, 0, (void*)0, 0};
37353 static swig_type_info _swigt__p_wxPyTextDataObject = {"_p_wxPyTextDataObject", "wxPyTextDataObject *", 0, 0, (void*)0, 0};
37354 static swig_type_info _swigt__p_wxPyTextDropTarget = {"_p_wxPyTextDropTarget", "wxPyTextDropTarget *", 0, 0, (void*)0, 0};
37355 static swig_type_info _swigt__p_wxPyTimer = {"_p_wxPyTimer", "wxPyTimer *", 0, 0, (void*)0, 0};
37356 static swig_type_info _swigt__p_wxPyTipProvider = {"_p_wxPyTipProvider", "wxPyTipProvider *", 0, 0, (void*)0, 0};
37357 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
37358 static swig_type_info _swigt__p_wxSingleInstanceChecker = {"_p_wxSingleInstanceChecker", "wxSingleInstanceChecker *", 0, 0, (void*)0, 0};
37359 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
37360 static swig_type_info _swigt__p_wxSound = {"_p_wxSound", "wxSound *", 0, 0, (void*)0, 0};
37361 static swig_type_info _swigt__p_wxStandardPaths = {"_p_wxStandardPaths", "wxStandardPaths *", 0, 0, (void*)0, 0};
37362 static swig_type_info _swigt__p_wxStopWatch = {"_p_wxStopWatch", "wxStopWatch *", 0, 0, (void*)0, 0};
37363 static swig_type_info _swigt__p_wxString = {"_p_wxString", "wxString *", 0, 0, (void*)0, 0};
37364 static swig_type_info _swigt__p_wxSystemOptions = {"_p_wxSystemOptions", "wxSystemOptions *", 0, 0, (void*)0, 0};
37365 static swig_type_info _swigt__p_wxSystemSettings = {"_p_wxSystemSettings", "wxSystemSettings *", 0, 0, (void*)0, 0};
37366 static swig_type_info _swigt__p_wxTextCtrl = {"_p_wxTextCtrl", "wxTextCtrl *", 0, 0, (void*)0, 0};
37367 static swig_type_info _swigt__p_wxTextDataObject = {"_p_wxTextDataObject", "wxTextDataObject *", 0, 0, (void*)0, 0};
37368 static swig_type_info _swigt__p_wxTimeSpan = {"_p_wxTimeSpan", "wxTimeSpan *", 0, 0, (void*)0, 0};
37369 static swig_type_info _swigt__p_wxTimer = {"_p_wxTimer", "wxTimer *", 0, 0, (void*)0, 0};
37370 static swig_type_info _swigt__p_wxTimerEvent = {"_p_wxTimerEvent", "wxTimerEvent *", 0, 0, (void*)0, 0};
37371 static swig_type_info _swigt__p_wxTimerRunner = {"_p_wxTimerRunner", "wxTimerRunner *", 0, 0, (void*)0, 0};
37372 static swig_type_info _swigt__p_wxTipProvider = {"_p_wxTipProvider", "wxTipProvider *", 0, 0, (void*)0, 0};
37373 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
37374 static swig_type_info _swigt__p_wxURLDataObject = {"_p_wxURLDataObject", "wxURLDataObject *", 0, 0, (void*)0, 0};
37375 static swig_type_info _swigt__p_wxVideoMode = {"_p_wxVideoMode", "wxVideoMode *", 0, 0, (void*)0, 0};
37376 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
37377 static swig_type_info _swigt__p_wxWindowDisabler = {"_p_wxWindowDisabler", "wxWindowDisabler *", 0, 0, (void*)0, 0};
37378
37379 static swig_type_info *swig_type_initial[] = {
37380 &_swigt__p_char,
37381 &_swigt__p_form_ops_t,
37382 &_swigt__p_int,
37383 &_swigt__p_unsigned_char,
37384 &_swigt__p_unsigned_int,
37385 &_swigt__p_unsigned_long,
37386 &_swigt__p_void,
37387 &_swigt__p_wxANIHandler,
37388 &_swigt__p_wxAcceleratorTable,
37389 &_swigt__p_wxActivateEvent,
37390 &_swigt__p_wxArrayString,
37391 &_swigt__p_wxBMPHandler,
37392 &_swigt__p_wxBitmap,
37393 &_swigt__p_wxBitmapDataObject,
37394 &_swigt__p_wxBoxSizer,
37395 &_swigt__p_wxBusyCursor,
37396 &_swigt__p_wxBusyInfo,
37397 &_swigt__p_wxCURHandler,
37398 &_swigt__p_wxCaret,
37399 &_swigt__p_wxChar,
37400 &_swigt__p_wxChildFocusEvent,
37401 &_swigt__p_wxClipboard,
37402 &_swigt__p_wxClipboardLocker,
37403 &_swigt__p_wxCloseEvent,
37404 &_swigt__p_wxColour,
37405 &_swigt__p_wxCommandEvent,
37406 &_swigt__p_wxConfig,
37407 &_swigt__p_wxConfigBase,
37408 &_swigt__p_wxConfigPathChanger,
37409 &_swigt__p_wxContextMenuEvent,
37410 &_swigt__p_wxControl,
37411 &_swigt__p_wxControlWithItems,
37412 &_swigt__p_wxCursor,
37413 &_swigt__p_wxCustomDataObject,
37414 &_swigt__p_wxDC,
37415 &_swigt__p_wxDataFormat,
37416 &_swigt__p_wxDataObject,
37417 &_swigt__p_wxDataObjectComposite,
37418 &_swigt__p_wxDataObjectSimple,
37419 &_swigt__p_wxDateEvent,
37420 &_swigt__p_wxDateSpan,
37421 &_swigt__p_wxDateTime,
37422 &_swigt__p_wxDateTime__TimeZone,
37423 &_swigt__p_wxDisplay,
37424 &_swigt__p_wxDisplayChangedEvent,
37425 &_swigt__p_wxDropFilesEvent,
37426 &_swigt__p_wxDuplexMode,
37427 &_swigt__p_wxEraseEvent,
37428 &_swigt__p_wxEvent,
37429 &_swigt__p_wxEvtHandler,
37430 &_swigt__p_wxFSFile,
37431 &_swigt__p_wxFileConfig,
37432 &_swigt__p_wxFileDataObject,
37433 &_swigt__p_wxFileHistory,
37434 &_swigt__p_wxFileSystem,
37435 &_swigt__p_wxFileType,
37436 &_swigt__p_wxFileTypeInfo,
37437 &_swigt__p_wxFlexGridSizer,
37438 &_swigt__p_wxFocusEvent,
37439 &_swigt__p_wxFont,
37440 &_swigt__p_wxFrame,
37441 &_swigt__p_wxGBSizerItem,
37442 &_swigt__p_wxGIFHandler,
37443 &_swigt__p_wxGridBagSizer,
37444 &_swigt__p_wxGridSizer,
37445 &_swigt__p_wxICOHandler,
37446 &_swigt__p_wxIcon,
37447 &_swigt__p_wxIconizeEvent,
37448 &_swigt__p_wxIdleEvent,
37449 &_swigt__p_wxImage,
37450 &_swigt__p_wxImageHandler,
37451 &_swigt__p_wxIndividualLayoutConstraint,
37452 &_swigt__p_wxInitDialogEvent,
37453 &_swigt__p_wxJPEGHandler,
37454 &_swigt__p_wxJoystick,
37455 &_swigt__p_wxJoystickEvent,
37456 &_swigt__p_wxKeyEvent,
37457 &_swigt__p_wxKillError,
37458 &_swigt__p_wxLayoutConstraints,
37459 &_swigt__p_wxLog,
37460 &_swigt__p_wxLogBuffer,
37461 &_swigt__p_wxLogChain,
37462 &_swigt__p_wxLogGui,
37463 &_swigt__p_wxLogNull,
37464 &_swigt__p_wxLogStderr,
37465 &_swigt__p_wxLogTextCtrl,
37466 &_swigt__p_wxLogWindow,
37467 &_swigt__p_wxMaximizeEvent,
37468 &_swigt__p_wxMemorySize,
37469 &_swigt__p_wxMenu,
37470 &_swigt__p_wxMenuBar,
37471 &_swigt__p_wxMenuEvent,
37472 &_swigt__p_wxMenuItem,
37473 &_swigt__p_wxMetafile,
37474 &_swigt__p_wxMetafileDataObject,
37475 &_swigt__p_wxMimeTypesManager,
37476 &_swigt__p_wxMouseCaptureChangedEvent,
37477 &_swigt__p_wxMouseEvent,
37478 &_swigt__p_wxMouseState,
37479 &_swigt__p_wxMoveEvent,
37480 &_swigt__p_wxMutexGuiLocker,
37481 &_swigt__p_wxNavigationKeyEvent,
37482 &_swigt__p_wxNcPaintEvent,
37483 &_swigt__p_wxNotifyEvent,
37484 &_swigt__p_wxObject,
37485 &_swigt__p_wxOutputStream,
37486 &_swigt__p_wxPCXHandler,
37487 &_swigt__p_wxPNGHandler,
37488 &_swigt__p_wxPNMHandler,
37489 &_swigt__p_wxPaintEvent,
37490 &_swigt__p_wxPaletteChangedEvent,
37491 &_swigt__p_wxPaperSize,
37492 &_swigt__p_wxPoint,
37493 &_swigt__p_wxProcessEvent,
37494 &_swigt__p_wxPyApp,
37495 &_swigt__p_wxPyArtProvider,
37496 &_swigt__p_wxPyBitmapDataObject,
37497 &_swigt__p_wxPyCommandEvent,
37498 &_swigt__p_wxPyDataObjectSimple,
37499 &_swigt__p_wxPyDropSource,
37500 &_swigt__p_wxPyDropTarget,
37501 &_swigt__p_wxPyEvent,
37502 &_swigt__p_wxPyFileDropTarget,
37503 &_swigt__p_wxPyImageHandler,
37504 &_swigt__p_wxPyLog,
37505 &_swigt__p_wxPyProcess,
37506 &_swigt__p_wxPySizer,
37507 &_swigt__p_wxPyTextDataObject,
37508 &_swigt__p_wxPyTextDropTarget,
37509 &_swigt__p_wxPyTimer,
37510 &_swigt__p_wxPyTipProvider,
37511 &_swigt__p_wxPyValidator,
37512 &_swigt__p_wxQueryNewPaletteEvent,
37513 &_swigt__p_wxRect,
37514 &_swigt__p_wxScrollEvent,
37515 &_swigt__p_wxScrollWinEvent,
37516 &_swigt__p_wxSetCursorEvent,
37517 &_swigt__p_wxShowEvent,
37518 &_swigt__p_wxSingleInstanceChecker,
37519 &_swigt__p_wxSize,
37520 &_swigt__p_wxSizeEvent,
37521 &_swigt__p_wxSizer,
37522 &_swigt__p_wxSizerItem,
37523 &_swigt__p_wxSound,
37524 &_swigt__p_wxStandardPaths,
37525 &_swigt__p_wxStaticBoxSizer,
37526 &_swigt__p_wxStdDialogButtonSizer,
37527 &_swigt__p_wxStopWatch,
37528 &_swigt__p_wxString,
37529 &_swigt__p_wxSysColourChangedEvent,
37530 &_swigt__p_wxSystemOptions,
37531 &_swigt__p_wxSystemSettings,
37532 &_swigt__p_wxTIFFHandler,
37533 &_swigt__p_wxTextCtrl,
37534 &_swigt__p_wxTextDataObject,
37535 &_swigt__p_wxTimeSpan,
37536 &_swigt__p_wxTimer,
37537 &_swigt__p_wxTimerEvent,
37538 &_swigt__p_wxTimerRunner,
37539 &_swigt__p_wxTipProvider,
37540 &_swigt__p_wxToolTip,
37541 &_swigt__p_wxURLDataObject,
37542 &_swigt__p_wxUpdateUIEvent,
37543 &_swigt__p_wxValidator,
37544 &_swigt__p_wxVideoMode,
37545 &_swigt__p_wxWindow,
37546 &_swigt__p_wxWindowCreateEvent,
37547 &_swigt__p_wxWindowDestroyEvent,
37548 &_swigt__p_wxWindowDisabler,
37549 &_swigt__p_wxXPMHandler,
37550 };
37551
37552 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
37553 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
37554 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
37555 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
37556 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
37557 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
37558 static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
37559 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
37560 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
37561 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}};
37562 static swig_cast_info _swigc__p_wxBusyCursor[] = { {&_swigt__p_wxBusyCursor, 0, 0, 0},{0, 0, 0, 0}};
37563 static swig_cast_info _swigc__p_wxBusyInfo[] = { {&_swigt__p_wxBusyInfo, 0, 0, 0},{0, 0, 0, 0}};
37564 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
37565 static swig_cast_info _swigc__p_wxChar[] = { {&_swigt__p_wxChar, 0, 0, 0},{0, 0, 0, 0}};
37566 static swig_cast_info _swigc__p_wxClipboard[] = { {&_swigt__p_wxClipboard, 0, 0, 0},{0, 0, 0, 0}};
37567 static swig_cast_info _swigc__p_wxClipboardLocker[] = { {&_swigt__p_wxClipboardLocker, 0, 0, 0},{0, 0, 0, 0}};
37568 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
37569 static swig_cast_info _swigc__p_wxConfig[] = { {&_swigt__p_wxConfig, 0, 0, 0},{0, 0, 0, 0}};
37570 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}};
37571 static swig_cast_info _swigc__p_wxConfigPathChanger[] = { {&_swigt__p_wxConfigPathChanger, 0, 0, 0},{0, 0, 0, 0}};
37572 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
37573 static swig_cast_info _swigc__p_wxCustomDataObject[] = { {&_swigt__p_wxCustomDataObject, 0, 0, 0},{0, 0, 0, 0}};
37574 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
37575 static swig_cast_info _swigc__p_wxDataFormat[] = { {&_swigt__p_wxDataFormat, 0, 0, 0},{0, 0, 0, 0}};
37576 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}};
37577 static swig_cast_info _swigc__p_wxDataObjectComposite[] = { {&_swigt__p_wxDataObjectComposite, 0, 0, 0},{0, 0, 0, 0}};
37578 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}};
37579 static swig_cast_info _swigc__p_wxDateSpan[] = { {&_swigt__p_wxDateSpan, 0, 0, 0},{0, 0, 0, 0}};
37580 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
37581 static swig_cast_info _swigc__p_wxDateTime__TimeZone[] = { {&_swigt__p_wxDateTime__TimeZone, 0, 0, 0},{0, 0, 0, 0}};
37582 static swig_cast_info _swigc__p_wxDisplay[] = { {&_swigt__p_wxDisplay, 0, 0, 0},{0, 0, 0, 0}};
37583 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
37584 static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
37585 static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
37586 static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
37587 static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
37588 static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
37589 static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
37590 static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
37591 static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
37592 static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
37593 static swig_cast_info _swigc__p_wxNotifyEvent[] = {{&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
37594 static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
37595 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
37596 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
37597 static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
37598 static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
37599 static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
37600 static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
37601 static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
37602 static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
37603 static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
37604 static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
37605 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
37606 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
37607 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
37608 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
37609 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
37610 static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
37611 static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
37612 static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
37613 static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
37614 static swig_cast_info _swigc__p_wxCommandEvent[] = {{&_swigt__p_wxCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
37615 static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
37616 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
37617 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
37618 static swig_cast_info _swigc__p_wxKeyEvent[] = {{&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
37619 static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
37620 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}};
37621 static swig_cast_info _swigc__p_wxControl[] = {{&_swigt__p_wxControl, 0, 0, 0},{0, 0, 0, 0}};
37622 static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
37623 static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
37624 static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
37625 static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};
37626 static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
37627 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}};
37628 static swig_cast_info _swigc__p_wxFileConfig[] = { {&_swigt__p_wxFileConfig, 0, 0, 0},{0, 0, 0, 0}};
37629 static swig_cast_info _swigc__p_wxFileDataObject[] = { {&_swigt__p_wxFileDataObject, 0, 0, 0},{0, 0, 0, 0}};
37630 static swig_cast_info _swigc__p_wxFileHistory[] = { {&_swigt__p_wxFileHistory, 0, 0, 0},{0, 0, 0, 0}};
37631 static swig_cast_info _swigc__p_wxFileType[] = { {&_swigt__p_wxFileType, 0, 0, 0},{0, 0, 0, 0}};
37632 static swig_cast_info _swigc__p_wxFileTypeInfo[] = { {&_swigt__p_wxFileTypeInfo, 0, 0, 0},{0, 0, 0, 0}};
37633 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
37634 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
37635 static swig_cast_info _swigc__p_wxIcon[] = { {&_swigt__p_wxIcon, 0, 0, 0},{0, 0, 0, 0}};
37636 static swig_cast_info _swigc__p_wxJoystick[] = { {&_swigt__p_wxJoystick, 0, 0, 0},{0, 0, 0, 0}};
37637 static swig_cast_info _swigc__p_wxJoystickEvent[] = { {&_swigt__p_wxJoystickEvent, 0, 0, 0},{0, 0, 0, 0}};
37638 static swig_cast_info _swigc__p_wxKillError[] = { {&_swigt__p_wxKillError, 0, 0, 0},{0, 0, 0, 0}};
37639 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}};
37640 static swig_cast_info _swigc__p_wxLogBuffer[] = { {&_swigt__p_wxLogBuffer, 0, 0, 0},{0, 0, 0, 0}};
37641 static swig_cast_info _swigc__p_wxLogChain[] = { {&_swigt__p_wxLogChain, 0, 0, 0},{0, 0, 0, 0}};
37642 static swig_cast_info _swigc__p_wxLogGui[] = { {&_swigt__p_wxLogGui, 0, 0, 0},{0, 0, 0, 0}};
37643 static swig_cast_info _swigc__p_wxLogNull[] = { {&_swigt__p_wxLogNull, 0, 0, 0},{0, 0, 0, 0}};
37644 static swig_cast_info _swigc__p_wxLogStderr[] = { {&_swigt__p_wxLogStderr, 0, 0, 0},{0, 0, 0, 0}};
37645 static swig_cast_info _swigc__p_wxLogTextCtrl[] = { {&_swigt__p_wxLogTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
37646 static swig_cast_info _swigc__p_wxLogWindow[] = { {&_swigt__p_wxLogWindow, 0, 0, 0},{0, 0, 0, 0}};
37647 static swig_cast_info _swigc__p_wxMemorySize[] = { {&_swigt__p_wxMemorySize, 0, 0, 0},{0, 0, 0, 0}};
37648 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
37649 static swig_cast_info _swigc__p_wxMetafile[] = { {&_swigt__p_wxMetafile, 0, 0, 0},{0, 0, 0, 0}};
37650 static swig_cast_info _swigc__p_wxMetafileDataObject[] = { {&_swigt__p_wxMetafileDataObject, 0, 0, 0},{0, 0, 0, 0}};
37651 static swig_cast_info _swigc__p_wxMimeTypesManager[] = { {&_swigt__p_wxMimeTypesManager, 0, 0, 0},{0, 0, 0, 0}};
37652 static swig_cast_info _swigc__p_wxMouseState[] = { {&_swigt__p_wxMouseState, 0, 0, 0},{0, 0, 0, 0}};
37653 static swig_cast_info _swigc__p_wxMutexGuiLocker[] = { {&_swigt__p_wxMutexGuiLocker, 0, 0, 0},{0, 0, 0, 0}};
37654 static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
37655 static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
37656 static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
37657 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
37658 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
37659 static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
37660 static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
37661 static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
37662 static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
37663 static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
37664 static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
37665 static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
37666 static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
37667 static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
37668 static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
37669 static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
37670 static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
37671 static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
37672 static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
37673 static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
37674 static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
37675 static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
37676 static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
37677 static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
37678 static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
37679 static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
37680 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
37681 static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
37682 static swig_cast_info _swigc__p_wxImage[] = {{&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
37683 static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
37684 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}};
37685 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
37686 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
37687 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
37688 static swig_cast_info _swigc__p_wxProcessEvent[] = { {&_swigt__p_wxProcessEvent, 0, 0, 0},{0, 0, 0, 0}};
37689 static swig_cast_info _swigc__p_wxPyArtProvider[] = { {&_swigt__p_wxPyArtProvider, 0, 0, 0},{0, 0, 0, 0}};
37690 static swig_cast_info _swigc__p_wxPyBitmapDataObject[] = { {&_swigt__p_wxPyBitmapDataObject, 0, 0, 0},{0, 0, 0, 0}};
37691 static swig_cast_info _swigc__p_wxPyDataObjectSimple[] = { {&_swigt__p_wxPyDataObjectSimple, 0, 0, 0},{0, 0, 0, 0}};
37692 static swig_cast_info _swigc__p_wxPyDropSource[] = { {&_swigt__p_wxPyDropSource, 0, 0, 0},{0, 0, 0, 0}};
37693 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}};
37694 static swig_cast_info _swigc__p_wxPyFileDropTarget[] = { {&_swigt__p_wxPyFileDropTarget, 0, 0, 0},{0, 0, 0, 0}};
37695 static swig_cast_info _swigc__p_wxPyLog[] = { {&_swigt__p_wxPyLog, 0, 0, 0},{0, 0, 0, 0}};
37696 static swig_cast_info _swigc__p_wxPyProcess[] = { {&_swigt__p_wxPyProcess, 0, 0, 0},{0, 0, 0, 0}};
37697 static swig_cast_info _swigc__p_wxPyTextDataObject[] = { {&_swigt__p_wxPyTextDataObject, 0, 0, 0},{0, 0, 0, 0}};
37698 static swig_cast_info _swigc__p_wxPyTextDropTarget[] = { {&_swigt__p_wxPyTextDropTarget, 0, 0, 0},{0, 0, 0, 0}};
37699 static swig_cast_info _swigc__p_wxPyTimer[] = { {&_swigt__p_wxPyTimer, 0, 0, 0},{0, 0, 0, 0}};
37700 static swig_cast_info _swigc__p_wxPyTipProvider[] = { {&_swigt__p_wxPyTipProvider, 0, 0, 0},{0, 0, 0, 0}};
37701 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
37702 static swig_cast_info _swigc__p_wxSingleInstanceChecker[] = { {&_swigt__p_wxSingleInstanceChecker, 0, 0, 0},{0, 0, 0, 0}};
37703 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
37704 static swig_cast_info _swigc__p_wxSound[] = { {&_swigt__p_wxSound, 0, 0, 0},{0, 0, 0, 0}};
37705 static swig_cast_info _swigc__p_wxStandardPaths[] = { {&_swigt__p_wxStandardPaths, 0, 0, 0},{0, 0, 0, 0}};
37706 static swig_cast_info _swigc__p_wxStopWatch[] = { {&_swigt__p_wxStopWatch, 0, 0, 0},{0, 0, 0, 0}};
37707 static swig_cast_info _swigc__p_wxString[] = { {&_swigt__p_wxString, 0, 0, 0},{0, 0, 0, 0}};
37708 static swig_cast_info _swigc__p_wxSystemOptions[] = { {&_swigt__p_wxSystemOptions, 0, 0, 0},{0, 0, 0, 0}};
37709 static swig_cast_info _swigc__p_wxSystemSettings[] = { {&_swigt__p_wxSystemSettings, 0, 0, 0},{0, 0, 0, 0}};
37710 static swig_cast_info _swigc__p_wxTextCtrl[] = { {&_swigt__p_wxTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
37711 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}};
37712 static swig_cast_info _swigc__p_wxTimeSpan[] = { {&_swigt__p_wxTimeSpan, 0, 0, 0},{0, 0, 0, 0}};
37713 static swig_cast_info _swigc__p_wxTimer[] = { {&_swigt__p_wxTimer, 0, 0, 0},{0, 0, 0, 0}};
37714 static swig_cast_info _swigc__p_wxTimerEvent[] = { {&_swigt__p_wxTimerEvent, 0, 0, 0},{0, 0, 0, 0}};
37715 static swig_cast_info _swigc__p_wxTimerRunner[] = { {&_swigt__p_wxTimerRunner, 0, 0, 0},{0, 0, 0, 0}};
37716 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}};
37717 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
37718 static swig_cast_info _swigc__p_wxURLDataObject[] = { {&_swigt__p_wxURLDataObject, 0, 0, 0},{0, 0, 0, 0}};
37719 static swig_cast_info _swigc__p_wxVideoMode[] = { {&_swigt__p_wxVideoMode, 0, 0, 0},{0, 0, 0, 0}};
37720 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}};
37721 static swig_cast_info _swigc__p_wxWindowDisabler[] = { {&_swigt__p_wxWindowDisabler, 0, 0, 0},{0, 0, 0, 0}};
37722
37723 static swig_cast_info *swig_cast_initial[] = {
37724 _swigc__p_char,
37725 _swigc__p_form_ops_t,
37726 _swigc__p_int,
37727 _swigc__p_unsigned_char,
37728 _swigc__p_unsigned_int,
37729 _swigc__p_unsigned_long,
37730 _swigc__p_void,
37731 _swigc__p_wxANIHandler,
37732 _swigc__p_wxAcceleratorTable,
37733 _swigc__p_wxActivateEvent,
37734 _swigc__p_wxArrayString,
37735 _swigc__p_wxBMPHandler,
37736 _swigc__p_wxBitmap,
37737 _swigc__p_wxBitmapDataObject,
37738 _swigc__p_wxBoxSizer,
37739 _swigc__p_wxBusyCursor,
37740 _swigc__p_wxBusyInfo,
37741 _swigc__p_wxCURHandler,
37742 _swigc__p_wxCaret,
37743 _swigc__p_wxChar,
37744 _swigc__p_wxChildFocusEvent,
37745 _swigc__p_wxClipboard,
37746 _swigc__p_wxClipboardLocker,
37747 _swigc__p_wxCloseEvent,
37748 _swigc__p_wxColour,
37749 _swigc__p_wxCommandEvent,
37750 _swigc__p_wxConfig,
37751 _swigc__p_wxConfigBase,
37752 _swigc__p_wxConfigPathChanger,
37753 _swigc__p_wxContextMenuEvent,
37754 _swigc__p_wxControl,
37755 _swigc__p_wxControlWithItems,
37756 _swigc__p_wxCursor,
37757 _swigc__p_wxCustomDataObject,
37758 _swigc__p_wxDC,
37759 _swigc__p_wxDataFormat,
37760 _swigc__p_wxDataObject,
37761 _swigc__p_wxDataObjectComposite,
37762 _swigc__p_wxDataObjectSimple,
37763 _swigc__p_wxDateEvent,
37764 _swigc__p_wxDateSpan,
37765 _swigc__p_wxDateTime,
37766 _swigc__p_wxDateTime__TimeZone,
37767 _swigc__p_wxDisplay,
37768 _swigc__p_wxDisplayChangedEvent,
37769 _swigc__p_wxDropFilesEvent,
37770 _swigc__p_wxDuplexMode,
37771 _swigc__p_wxEraseEvent,
37772 _swigc__p_wxEvent,
37773 _swigc__p_wxEvtHandler,
37774 _swigc__p_wxFSFile,
37775 _swigc__p_wxFileConfig,
37776 _swigc__p_wxFileDataObject,
37777 _swigc__p_wxFileHistory,
37778 _swigc__p_wxFileSystem,
37779 _swigc__p_wxFileType,
37780 _swigc__p_wxFileTypeInfo,
37781 _swigc__p_wxFlexGridSizer,
37782 _swigc__p_wxFocusEvent,
37783 _swigc__p_wxFont,
37784 _swigc__p_wxFrame,
37785 _swigc__p_wxGBSizerItem,
37786 _swigc__p_wxGIFHandler,
37787 _swigc__p_wxGridBagSizer,
37788 _swigc__p_wxGridSizer,
37789 _swigc__p_wxICOHandler,
37790 _swigc__p_wxIcon,
37791 _swigc__p_wxIconizeEvent,
37792 _swigc__p_wxIdleEvent,
37793 _swigc__p_wxImage,
37794 _swigc__p_wxImageHandler,
37795 _swigc__p_wxIndividualLayoutConstraint,
37796 _swigc__p_wxInitDialogEvent,
37797 _swigc__p_wxJPEGHandler,
37798 _swigc__p_wxJoystick,
37799 _swigc__p_wxJoystickEvent,
37800 _swigc__p_wxKeyEvent,
37801 _swigc__p_wxKillError,
37802 _swigc__p_wxLayoutConstraints,
37803 _swigc__p_wxLog,
37804 _swigc__p_wxLogBuffer,
37805 _swigc__p_wxLogChain,
37806 _swigc__p_wxLogGui,
37807 _swigc__p_wxLogNull,
37808 _swigc__p_wxLogStderr,
37809 _swigc__p_wxLogTextCtrl,
37810 _swigc__p_wxLogWindow,
37811 _swigc__p_wxMaximizeEvent,
37812 _swigc__p_wxMemorySize,
37813 _swigc__p_wxMenu,
37814 _swigc__p_wxMenuBar,
37815 _swigc__p_wxMenuEvent,
37816 _swigc__p_wxMenuItem,
37817 _swigc__p_wxMetafile,
37818 _swigc__p_wxMetafileDataObject,
37819 _swigc__p_wxMimeTypesManager,
37820 _swigc__p_wxMouseCaptureChangedEvent,
37821 _swigc__p_wxMouseEvent,
37822 _swigc__p_wxMouseState,
37823 _swigc__p_wxMoveEvent,
37824 _swigc__p_wxMutexGuiLocker,
37825 _swigc__p_wxNavigationKeyEvent,
37826 _swigc__p_wxNcPaintEvent,
37827 _swigc__p_wxNotifyEvent,
37828 _swigc__p_wxObject,
37829 _swigc__p_wxOutputStream,
37830 _swigc__p_wxPCXHandler,
37831 _swigc__p_wxPNGHandler,
37832 _swigc__p_wxPNMHandler,
37833 _swigc__p_wxPaintEvent,
37834 _swigc__p_wxPaletteChangedEvent,
37835 _swigc__p_wxPaperSize,
37836 _swigc__p_wxPoint,
37837 _swigc__p_wxProcessEvent,
37838 _swigc__p_wxPyApp,
37839 _swigc__p_wxPyArtProvider,
37840 _swigc__p_wxPyBitmapDataObject,
37841 _swigc__p_wxPyCommandEvent,
37842 _swigc__p_wxPyDataObjectSimple,
37843 _swigc__p_wxPyDropSource,
37844 _swigc__p_wxPyDropTarget,
37845 _swigc__p_wxPyEvent,
37846 _swigc__p_wxPyFileDropTarget,
37847 _swigc__p_wxPyImageHandler,
37848 _swigc__p_wxPyLog,
37849 _swigc__p_wxPyProcess,
37850 _swigc__p_wxPySizer,
37851 _swigc__p_wxPyTextDataObject,
37852 _swigc__p_wxPyTextDropTarget,
37853 _swigc__p_wxPyTimer,
37854 _swigc__p_wxPyTipProvider,
37855 _swigc__p_wxPyValidator,
37856 _swigc__p_wxQueryNewPaletteEvent,
37857 _swigc__p_wxRect,
37858 _swigc__p_wxScrollEvent,
37859 _swigc__p_wxScrollWinEvent,
37860 _swigc__p_wxSetCursorEvent,
37861 _swigc__p_wxShowEvent,
37862 _swigc__p_wxSingleInstanceChecker,
37863 _swigc__p_wxSize,
37864 _swigc__p_wxSizeEvent,
37865 _swigc__p_wxSizer,
37866 _swigc__p_wxSizerItem,
37867 _swigc__p_wxSound,
37868 _swigc__p_wxStandardPaths,
37869 _swigc__p_wxStaticBoxSizer,
37870 _swigc__p_wxStdDialogButtonSizer,
37871 _swigc__p_wxStopWatch,
37872 _swigc__p_wxString,
37873 _swigc__p_wxSysColourChangedEvent,
37874 _swigc__p_wxSystemOptions,
37875 _swigc__p_wxSystemSettings,
37876 _swigc__p_wxTIFFHandler,
37877 _swigc__p_wxTextCtrl,
37878 _swigc__p_wxTextDataObject,
37879 _swigc__p_wxTimeSpan,
37880 _swigc__p_wxTimer,
37881 _swigc__p_wxTimerEvent,
37882 _swigc__p_wxTimerRunner,
37883 _swigc__p_wxTipProvider,
37884 _swigc__p_wxToolTip,
37885 _swigc__p_wxURLDataObject,
37886 _swigc__p_wxUpdateUIEvent,
37887 _swigc__p_wxValidator,
37888 _swigc__p_wxVideoMode,
37889 _swigc__p_wxWindow,
37890 _swigc__p_wxWindowCreateEvent,
37891 _swigc__p_wxWindowDestroyEvent,
37892 _swigc__p_wxWindowDisabler,
37893 _swigc__p_wxXPMHandler,
37894 };
37895
37896
37897 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
37898
37899 static swig_const_info swig_const_table[] = {
37900 {0, 0, 0, 0.0, 0, 0}};
37901
37902 #ifdef __cplusplus
37903 }
37904 #endif
37905 /* -----------------------------------------------------------------------------
37906 * Type initialization:
37907 * This problem is tough by the requirement that no dynamic
37908 * memory is used. Also, since swig_type_info structures store pointers to
37909 * swig_cast_info structures and swig_cast_info structures store pointers back
37910 * to swig_type_info structures, we need some lookup code at initialization.
37911 * The idea is that swig generates all the structures that are needed.
37912 * The runtime then collects these partially filled structures.
37913 * The SWIG_InitializeModule function takes these initial arrays out of
37914 * swig_module, and does all the lookup, filling in the swig_module.types
37915 * array with the correct data and linking the correct swig_cast_info
37916 * structures together.
37917 *
37918 * The generated swig_type_info structures are assigned staticly to an initial
37919 * array. We just loop though that array, and handle each type individually.
37920 * First we lookup if this type has been already loaded, and if so, use the
37921 * loaded structure instead of the generated one. Then we have to fill in the
37922 * cast linked list. The cast data is initially stored in something like a
37923 * two-dimensional array. Each row corresponds to a type (there are the same
37924 * number of rows as there are in the swig_type_initial array). Each entry in
37925 * a column is one of the swig_cast_info structures for that type.
37926 * The cast_initial array is actually an array of arrays, because each row has
37927 * a variable number of columns. So to actually build the cast linked list,
37928 * we find the array of casts associated with the type, and loop through it
37929 * adding the casts to the list. The one last trick we need to do is making
37930 * sure the type pointer in the swig_cast_info struct is correct.
37931 *
37932 * First off, we lookup the cast->type name to see if it is already loaded.
37933 * There are three cases to handle:
37934 * 1) If the cast->type has already been loaded AND the type we are adding
37935 * casting info to has not been loaded (it is in this module), THEN we
37936 * replace the cast->type pointer with the type pointer that has already
37937 * been loaded.
37938 * 2) If BOTH types (the one we are adding casting info to, and the
37939 * cast->type) are loaded, THEN the cast info has already been loaded by
37940 * the previous module so we just ignore it.
37941 * 3) Finally, if cast->type has not already been loaded, then we add that
37942 * swig_cast_info to the linked list (because the cast->type) pointer will
37943 * be correct.
37944 * ----------------------------------------------------------------------------- */
37945
37946 #ifdef __cplusplus
37947 extern "C" {
37948 #if 0
37949 } /* c-mode */
37950 #endif
37951 #endif
37952
37953 #if 0
37954 #define SWIGRUNTIME_DEBUG
37955 #endif
37956
37957 SWIGRUNTIME void
37958 SWIG_InitializeModule(void *clientdata) {
37959 size_t i;
37960 swig_module_info *module_head;
37961 static int init_run = 0;
37962
37963 clientdata = clientdata;
37964
37965 if (init_run) return;
37966 init_run = 1;
37967
37968 /* Initialize the swig_module */
37969 swig_module.type_initial = swig_type_initial;
37970 swig_module.cast_initial = swig_cast_initial;
37971
37972 /* Try and load any already created modules */
37973 module_head = SWIG_GetModule(clientdata);
37974 if (module_head) {
37975 swig_module.next = module_head->next;
37976 module_head->next = &swig_module;
37977 } else {
37978 /* This is the first module loaded */
37979 swig_module.next = &swig_module;
37980 SWIG_SetModule(clientdata, &swig_module);
37981 }
37982
37983 /* Now work on filling in swig_module.types */
37984 #ifdef SWIGRUNTIME_DEBUG
37985 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
37986 #endif
37987 for (i = 0; i < swig_module.size; ++i) {
37988 swig_type_info *type = 0;
37989 swig_type_info *ret;
37990 swig_cast_info *cast;
37991
37992 #ifdef SWIGRUNTIME_DEBUG
37993 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
37994 #endif
37995
37996 /* if there is another module already loaded */
37997 if (swig_module.next != &swig_module) {
37998 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
37999 }
38000 if (type) {
38001 /* Overwrite clientdata field */
38002 #ifdef SWIGRUNTIME_DEBUG
38003 printf("SWIG_InitializeModule: found type %s\n", type->name);
38004 #endif
38005 if (swig_module.type_initial[i]->clientdata) {
38006 type->clientdata = swig_module.type_initial[i]->clientdata;
38007 #ifdef SWIGRUNTIME_DEBUG
38008 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
38009 #endif
38010 }
38011 } else {
38012 type = swig_module.type_initial[i];
38013 }
38014
38015 /* Insert casting types */
38016 cast = swig_module.cast_initial[i];
38017 while (cast->type) {
38018 /* Don't need to add information already in the list */
38019 ret = 0;
38020 #ifdef SWIGRUNTIME_DEBUG
38021 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
38022 #endif
38023 if (swig_module.next != &swig_module) {
38024 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
38025 #ifdef SWIGRUNTIME_DEBUG
38026 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
38027 #endif
38028 }
38029 if (ret) {
38030 if (type == swig_module.type_initial[i]) {
38031 #ifdef SWIGRUNTIME_DEBUG
38032 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
38033 #endif
38034 cast->type = ret;
38035 ret = 0;
38036 } else {
38037 /* Check for casting already in the list */
38038 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
38039 #ifdef SWIGRUNTIME_DEBUG
38040 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
38041 #endif
38042 if (!ocast) ret = 0;
38043 }
38044 }
38045
38046 if (!ret) {
38047 #ifdef SWIGRUNTIME_DEBUG
38048 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
38049 #endif
38050 if (type->cast) {
38051 type->cast->prev = cast;
38052 cast->next = type->cast;
38053 }
38054 type->cast = cast;
38055 }
38056 cast++;
38057 }
38058 /* Set entry in modules->types array equal to the type */
38059 swig_module.types[i] = type;
38060 }
38061 swig_module.types[i] = 0;
38062
38063 #ifdef SWIGRUNTIME_DEBUG
38064 printf("**** SWIG_InitializeModule: Cast List ******\n");
38065 for (i = 0; i < swig_module.size; ++i) {
38066 int j = 0;
38067 swig_cast_info *cast = swig_module.cast_initial[i];
38068 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
38069 while (cast->type) {
38070 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
38071 cast++;
38072 ++j;
38073 }
38074 printf("---- Total casts: %d\n",j);
38075 }
38076 printf("**** SWIG_InitializeModule: Cast List ******\n");
38077 #endif
38078 }
38079
38080 /* This function will propagate the clientdata field of type to
38081 * any new swig_type_info structures that have been added into the list
38082 * of equivalent types. It is like calling
38083 * SWIG_TypeClientData(type, clientdata) a second time.
38084 */
38085 SWIGRUNTIME void
38086 SWIG_PropagateClientData(void) {
38087 size_t i;
38088 swig_cast_info *equiv;
38089 static int init_run = 0;
38090
38091 if (init_run) return;
38092 init_run = 1;
38093
38094 for (i = 0; i < swig_module.size; i++) {
38095 if (swig_module.types[i]->clientdata) {
38096 equiv = swig_module.types[i]->cast;
38097 while (equiv) {
38098 if (!equiv->converter) {
38099 if (equiv->type && !equiv->type->clientdata)
38100 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
38101 }
38102 equiv = equiv->next;
38103 }
38104 }
38105 }
38106 }
38107
38108 #ifdef __cplusplus
38109 #if 0
38110 {
38111 /* c-mode */
38112 #endif
38113 }
38114 #endif
38115
38116
38117
38118 #ifdef __cplusplus
38119 extern "C" {
38120 #endif
38121
38122 /* Python-specific SWIG API */
38123 #define SWIG_newvarlink() SWIG_Python_newvarlink()
38124 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
38125 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
38126
38127 /* -----------------------------------------------------------------------------
38128 * global variable support code.
38129 * ----------------------------------------------------------------------------- */
38130
38131 typedef struct swig_globalvar {
38132 char *name; /* Name of global variable */
38133 PyObject *(*get_attr)(void); /* Return the current value */
38134 int (*set_attr)(PyObject *); /* Set the value */
38135 struct swig_globalvar *next;
38136 } swig_globalvar;
38137
38138 typedef struct swig_varlinkobject {
38139 PyObject_HEAD
38140 swig_globalvar *vars;
38141 } swig_varlinkobject;
38142
38143 SWIGINTERN PyObject *
38144 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
38145 return PyString_FromString("<Swig global variables>");
38146 }
38147
38148 SWIGINTERN PyObject *
38149 swig_varlink_str(swig_varlinkobject *v) {
38150 PyObject *str = PyString_FromString("(");
38151 swig_globalvar *var;
38152 for (var = v->vars; var; var=var->next) {
38153 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
38154 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
38155 }
38156 PyString_ConcatAndDel(&str,PyString_FromString(")"));
38157 return str;
38158 }
38159
38160 SWIGINTERN int
38161 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
38162 PyObject *str = swig_varlink_str(v);
38163 fprintf(fp,"Swig global variables ");
38164 fprintf(fp,"%s\n", PyString_AsString(str));
38165 Py_DECREF(str);
38166 return 0;
38167 }
38168
38169 SWIGINTERN void
38170 swig_varlink_dealloc(swig_varlinkobject *v) {
38171 swig_globalvar *var = v->vars;
38172 while (var) {
38173 swig_globalvar *n = var->next;
38174 free(var->name);
38175 free(var);
38176 var = n;
38177 }
38178 }
38179
38180 SWIGINTERN PyObject *
38181 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
38182 PyObject *res = NULL;
38183 swig_globalvar *var = v->vars;
38184 while (var) {
38185 if (strcmp(var->name,n) == 0) {
38186 res = (*var->get_attr)();
38187 break;
38188 }
38189 var = var->next;
38190 }
38191 if (res == NULL && !PyErr_Occurred()) {
38192 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
38193 }
38194 return res;
38195 }
38196
38197 SWIGINTERN int
38198 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
38199 int res = 1;
38200 swig_globalvar *var = v->vars;
38201 while (var) {
38202 if (strcmp(var->name,n) == 0) {
38203 res = (*var->set_attr)(p);
38204 break;
38205 }
38206 var = var->next;
38207 }
38208 if (res == 1 && !PyErr_Occurred()) {
38209 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
38210 }
38211 return res;
38212 }
38213
38214 SWIGINTERN PyTypeObject*
38215 swig_varlink_type(void) {
38216 static char varlink__doc__[] = "Swig var link object";
38217 static PyTypeObject varlink_type;
38218 static int type_init = 0;
38219 if (!type_init) {
38220 const PyTypeObject tmp
38221 = {
38222 PyObject_HEAD_INIT(NULL)
38223 0, /* Number of items in variable part (ob_size) */
38224 (char *)"swigvarlink", /* Type name (tp_name) */
38225 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
38226 0, /* Itemsize (tp_itemsize) */
38227 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
38228 (printfunc) swig_varlink_print, /* Print (tp_print) */
38229 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
38230 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
38231 0, /* tp_compare */
38232 (reprfunc) swig_varlink_repr, /* tp_repr */
38233 0, /* tp_as_number */
38234 0, /* tp_as_sequence */
38235 0, /* tp_as_mapping */
38236 0, /* tp_hash */
38237 0, /* tp_call */
38238 (reprfunc)swig_varlink_str, /* tp_str */
38239 0, /* tp_getattro */
38240 0, /* tp_setattro */
38241 0, /* tp_as_buffer */
38242 0, /* tp_flags */
38243 varlink__doc__, /* tp_doc */
38244 0, /* tp_traverse */
38245 0, /* tp_clear */
38246 0, /* tp_richcompare */
38247 0, /* tp_weaklistoffset */
38248 #if PY_VERSION_HEX >= 0x02020000
38249 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
38250 #endif
38251 #if PY_VERSION_HEX >= 0x02030000
38252 0, /* tp_del */
38253 #endif
38254 #ifdef COUNT_ALLOCS
38255 0,0,0,0 /* tp_alloc -> tp_next */
38256 #endif
38257 };
38258 varlink_type = tmp;
38259 varlink_type.ob_type = &PyType_Type;
38260 type_init = 1;
38261 }
38262 return &varlink_type;
38263 }
38264
38265 /* Create a variable linking object for use later */
38266 SWIGINTERN PyObject *
38267 SWIG_Python_newvarlink(void) {
38268 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
38269 if (result) {
38270 result->vars = 0;
38271 }
38272 return ((PyObject*) result);
38273 }
38274
38275 SWIGINTERN void
38276 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
38277 swig_varlinkobject *v = (swig_varlinkobject *) p;
38278 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
38279 if (gv) {
38280 size_t size = strlen(name)+1;
38281 gv->name = (char *)malloc(size);
38282 if (gv->name) {
38283 strncpy(gv->name,name,size);
38284 gv->get_attr = get_attr;
38285 gv->set_attr = set_attr;
38286 gv->next = v->vars;
38287 }
38288 }
38289 v->vars = gv;
38290 }
38291
38292 SWIGINTERN PyObject *
38293 SWIG_globals() {
38294 static PyObject *_SWIG_globals = 0;
38295 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
38296 return _SWIG_globals;
38297 }
38298
38299 /* -----------------------------------------------------------------------------
38300 * constants/methods manipulation
38301 * ----------------------------------------------------------------------------- */
38302
38303 /* Install Constants */
38304 SWIGINTERN void
38305 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
38306 PyObject *obj = 0;
38307 size_t i;
38308 for (i = 0; constants[i].type; ++i) {
38309 switch(constants[i].type) {
38310 case SWIG_PY_POINTER:
38311 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
38312 break;
38313 case SWIG_PY_BINARY:
38314 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
38315 break;
38316 default:
38317 obj = 0;
38318 break;
38319 }
38320 if (obj) {
38321 PyDict_SetItemString(d, constants[i].name, obj);
38322 Py_DECREF(obj);
38323 }
38324 }
38325 }
38326
38327 /* -----------------------------------------------------------------------------*/
38328 /* Fix SwigMethods to carry the callback ptrs when needed */
38329 /* -----------------------------------------------------------------------------*/
38330
38331 SWIGINTERN void
38332 SWIG_Python_FixMethods(PyMethodDef *methods,
38333 swig_const_info *const_table,
38334 swig_type_info **types,
38335 swig_type_info **types_initial) {
38336 size_t i;
38337 for (i = 0; methods[i].ml_name; ++i) {
38338 char *c = methods[i].ml_doc;
38339 if (c && (c = strstr(c, "swig_ptr: "))) {
38340 int j;
38341 swig_const_info *ci = 0;
38342 char *name = c + 10;
38343 for (j = 0; const_table[j].type; ++j) {
38344 if (strncmp(const_table[j].name, name,
38345 strlen(const_table[j].name)) == 0) {
38346 ci = &(const_table[j]);
38347 break;
38348 }
38349 }
38350 if (ci) {
38351 size_t shift = (ci->ptype) - types;
38352 swig_type_info *ty = types_initial[shift];
38353 size_t ldoc = (c - methods[i].ml_doc);
38354 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
38355 char *ndoc = (char*)malloc(ldoc + lptr + 10);
38356 if (ndoc) {
38357 char *buff = ndoc;
38358 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
38359 if (ptr) {
38360 strncpy(buff, methods[i].ml_doc, ldoc);
38361 buff += ldoc;
38362 strncpy(buff, "swig_ptr: ", 10);
38363 buff += 10;
38364 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
38365 methods[i].ml_doc = ndoc;
38366 }
38367 }
38368 }
38369 }
38370 }
38371 }
38372
38373 #ifdef __cplusplus
38374 }
38375 #endif
38376
38377 /* -----------------------------------------------------------------------------*
38378 * Partial Init method
38379 * -----------------------------------------------------------------------------*/
38380
38381 #ifdef __cplusplus
38382 extern "C"
38383 #endif
38384 SWIGEXPORT void SWIG_init(void) {
38385 PyObject *m, *d;
38386
38387 /* Fix SwigMethods to carry the callback ptrs when needed */
38388 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
38389
38390 m = Py_InitModule((char *) SWIG_name, SwigMethods);
38391 d = PyModule_GetDict(m);
38392
38393 SWIG_InitializeModule(0);
38394 SWIG_InstallConstants(d,swig_const_table);
38395
38396
38397 SWIG_Python_SetConstant(d, "SYS_OEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_OEM_FIXED_FONT)));
38398 SWIG_Python_SetConstant(d, "SYS_ANSI_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_FIXED_FONT)));
38399 SWIG_Python_SetConstant(d, "SYS_ANSI_VAR_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_VAR_FONT)));
38400 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FONT)));
38401 SWIG_Python_SetConstant(d, "SYS_DEVICE_DEFAULT_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEVICE_DEFAULT_FONT)));
38402 SWIG_Python_SetConstant(d, "SYS_DEFAULT_PALETTE",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_PALETTE)));
38403 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FIXED_FONT)));
38404 SWIG_Python_SetConstant(d, "SYS_DEFAULT_GUI_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_GUI_FONT)));
38405 SWIG_Python_SetConstant(d, "SYS_ICONTITLE_FONT",SWIG_From_int(static_cast< int >(wxSYS_ICONTITLE_FONT)));
38406 SWIG_Python_SetConstant(d, "SYS_COLOUR_SCROLLBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_SCROLLBAR)));
38407 SWIG_Python_SetConstant(d, "SYS_COLOUR_BACKGROUND",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BACKGROUND)));
38408 SWIG_Python_SetConstant(d, "SYS_COLOUR_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_DESKTOP)));
38409 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVECAPTION)));
38410 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTION)));
38411 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENU",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENU)));
38412 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOW)));
38413 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWFRAME",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWFRAME)));
38414 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUTEXT)));
38415 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWTEXT)));
38416 SWIG_Python_SetConstant(d, "SYS_COLOUR_CAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_CAPTIONTEXT)));
38417 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVEBORDER)));
38418 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVEBORDER)));
38419 SWIG_Python_SetConstant(d, "SYS_COLOUR_APPWORKSPACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_APPWORKSPACE)));
38420 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHT)));
38421 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHTTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHTTEXT)));
38422 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNFACE)));
38423 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DFACE)));
38424 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNSHADOW)));
38425 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DSHADOW)));
38426 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRAYTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRAYTEXT)));
38427 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNTEXT)));
38428 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
38429 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHIGHLIGHT)));
38430 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHILIGHT)));
38431 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHIGHLIGHT)));
38432 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHILIGHT)));
38433 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DDKSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DDKSHADOW)));
38434 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DLIGHT)));
38435 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOTEXT)));
38436 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOBK",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOBK)));
38437 SWIG_Python_SetConstant(d, "SYS_COLOUR_LISTBOX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_LISTBOX)));
38438 SWIG_Python_SetConstant(d, "SYS_COLOUR_HOTLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HOTLIGHT)));
38439 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
38440 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTINACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
38441 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUHILIGHT)));
38442 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUBAR)));
38443 SWIG_Python_SetConstant(d, "SYS_COLOUR_MAX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MAX)));
38444 SWIG_Python_SetConstant(d, "SYS_MOUSE_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_MOUSE_BUTTONS)));
38445 SWIG_Python_SetConstant(d, "SYS_BORDER_X",SWIG_From_int(static_cast< int >(wxSYS_BORDER_X)));
38446 SWIG_Python_SetConstant(d, "SYS_BORDER_Y",SWIG_From_int(static_cast< int >(wxSYS_BORDER_Y)));
38447 SWIG_Python_SetConstant(d, "SYS_CURSOR_X",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_X)));
38448 SWIG_Python_SetConstant(d, "SYS_CURSOR_Y",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_Y)));
38449 SWIG_Python_SetConstant(d, "SYS_DCLICK_X",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_X)));
38450 SWIG_Python_SetConstant(d, "SYS_DCLICK_Y",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_Y)));
38451 SWIG_Python_SetConstant(d, "SYS_DRAG_X",SWIG_From_int(static_cast< int >(wxSYS_DRAG_X)));
38452 SWIG_Python_SetConstant(d, "SYS_DRAG_Y",SWIG_From_int(static_cast< int >(wxSYS_DRAG_Y)));
38453 SWIG_Python_SetConstant(d, "SYS_EDGE_X",SWIG_From_int(static_cast< int >(wxSYS_EDGE_X)));
38454 SWIG_Python_SetConstant(d, "SYS_EDGE_Y",SWIG_From_int(static_cast< int >(wxSYS_EDGE_Y)));
38455 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_X)));
38456 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_Y)));
38457 SWIG_Python_SetConstant(d, "SYS_HTHUMB_X",SWIG_From_int(static_cast< int >(wxSYS_HTHUMB_X)));
38458 SWIG_Python_SetConstant(d, "SYS_ICON_X",SWIG_From_int(static_cast< int >(wxSYS_ICON_X)));
38459 SWIG_Python_SetConstant(d, "SYS_ICON_Y",SWIG_From_int(static_cast< int >(wxSYS_ICON_Y)));
38460 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_X",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_X)));
38461 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_Y",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_Y)));
38462 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_X",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_X)));
38463 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_Y",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_Y)));
38464 SWIG_Python_SetConstant(d, "SYS_SCREEN_X",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_X)));
38465 SWIG_Python_SetConstant(d, "SYS_SCREEN_Y",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_Y)));
38466 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_X",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_X)));
38467 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_Y",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_Y)));
38468 SWIG_Python_SetConstant(d, "SYS_SMALLICON_X",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_X)));
38469 SWIG_Python_SetConstant(d, "SYS_SMALLICON_Y",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_Y)));
38470 SWIG_Python_SetConstant(d, "SYS_HSCROLL_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_Y)));
38471 SWIG_Python_SetConstant(d, "SYS_VSCROLL_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_X)));
38472 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_X)));
38473 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_Y)));
38474 SWIG_Python_SetConstant(d, "SYS_VTHUMB_Y",SWIG_From_int(static_cast< int >(wxSYS_VTHUMB_Y)));
38475 SWIG_Python_SetConstant(d, "SYS_CAPTION_Y",SWIG_From_int(static_cast< int >(wxSYS_CAPTION_Y)));
38476 SWIG_Python_SetConstant(d, "SYS_MENU_Y",SWIG_From_int(static_cast< int >(wxSYS_MENU_Y)));
38477 SWIG_Python_SetConstant(d, "SYS_NETWORK_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_NETWORK_PRESENT)));
38478 SWIG_Python_SetConstant(d, "SYS_PENWINDOWS_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_PENWINDOWS_PRESENT)));
38479 SWIG_Python_SetConstant(d, "SYS_SHOW_SOUNDS",SWIG_From_int(static_cast< int >(wxSYS_SHOW_SOUNDS)));
38480 SWIG_Python_SetConstant(d, "SYS_SWAP_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_SWAP_BUTTONS)));
38481 SWIG_Python_SetConstant(d, "SYS_CAN_DRAW_FRAME_DECORATIONS",SWIG_From_int(static_cast< int >(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
38482 SWIG_Python_SetConstant(d, "SYS_CAN_ICONIZE_FRAME",SWIG_From_int(static_cast< int >(wxSYS_CAN_ICONIZE_FRAME)));
38483 SWIG_Python_SetConstant(d, "SYS_TABLET_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_TABLET_PRESENT)));
38484 SWIG_Python_SetConstant(d, "SYS_SCREEN_NONE",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_NONE)));
38485 SWIG_Python_SetConstant(d, "SYS_SCREEN_TINY",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_TINY)));
38486 SWIG_Python_SetConstant(d, "SYS_SCREEN_PDA",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_PDA)));
38487 SWIG_Python_SetConstant(d, "SYS_SCREEN_SMALL",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_SMALL)));
38488 SWIG_Python_SetConstant(d, "SYS_SCREEN_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_DESKTOP)));
38489 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
38490 SWIG_addvarlink(SWIG_globals(),(char*)"WINDOW_DEFAULT_VARIANT",WINDOW_DEFAULT_VARIANT_get, WINDOW_DEFAULT_VARIANT_set);
38491 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorPromptStr",FileSelectorPromptStr_get, FileSelectorPromptStr_set);
38492 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorDefaultWildcardStr",FileSelectorDefaultWildcardStr_get, FileSelectorDefaultWildcardStr_set);
38493 SWIG_addvarlink(SWIG_globals(),(char*)"DirSelectorPromptStr",DirSelectorPromptStr_get, DirSelectorPromptStr_set);
38494 SWIG_Python_SetConstant(d, "SHUTDOWN_POWEROFF",SWIG_From_int(static_cast< int >(wxSHUTDOWN_POWEROFF)));
38495 SWIG_Python_SetConstant(d, "SHUTDOWN_REBOOT",SWIG_From_int(static_cast< int >(wxSHUTDOWN_REBOOT)));
38496 SWIG_Python_SetConstant(d, "TIMER_CONTINUOUS",SWIG_From_int(static_cast< int >(wxTIMER_CONTINUOUS)));
38497 SWIG_Python_SetConstant(d, "TIMER_ONE_SHOT",SWIG_From_int(static_cast< int >(wxTIMER_ONE_SHOT)));
38498 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
38499
38500 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
38501
38502 SWIG_Python_SetConstant(d, "LOG_FatalError",SWIG_From_int(static_cast< int >(wxLOG_FatalError)));
38503 SWIG_Python_SetConstant(d, "LOG_Error",SWIG_From_int(static_cast< int >(wxLOG_Error)));
38504 SWIG_Python_SetConstant(d, "LOG_Warning",SWIG_From_int(static_cast< int >(wxLOG_Warning)));
38505 SWIG_Python_SetConstant(d, "LOG_Message",SWIG_From_int(static_cast< int >(wxLOG_Message)));
38506 SWIG_Python_SetConstant(d, "LOG_Status",SWIG_From_int(static_cast< int >(wxLOG_Status)));
38507 SWIG_Python_SetConstant(d, "LOG_Info",SWIG_From_int(static_cast< int >(wxLOG_Info)));
38508 SWIG_Python_SetConstant(d, "LOG_Debug",SWIG_From_int(static_cast< int >(wxLOG_Debug)));
38509 SWIG_Python_SetConstant(d, "LOG_Trace",SWIG_From_int(static_cast< int >(wxLOG_Trace)));
38510 SWIG_Python_SetConstant(d, "LOG_Progress",SWIG_From_int(static_cast< int >(wxLOG_Progress)));
38511 SWIG_Python_SetConstant(d, "LOG_User",SWIG_From_int(static_cast< int >(wxLOG_User)));
38512 SWIG_Python_SetConstant(d, "LOG_Max",SWIG_From_int(static_cast< int >(wxLOG_Max)));
38513 SWIG_Python_SetConstant(d, "TRACE_MemAlloc",SWIG_FromCharPtr("memalloc"));
38514 SWIG_Python_SetConstant(d, "TRACE_Messages",SWIG_FromCharPtr("messages"));
38515 SWIG_Python_SetConstant(d, "TRACE_ResAlloc",SWIG_FromCharPtr("resalloc"));
38516 SWIG_Python_SetConstant(d, "TRACE_RefCount",SWIG_FromCharPtr("refcount"));
38517 SWIG_Python_SetConstant(d, "TRACE_OleCalls",SWIG_FromCharPtr("ole"));
38518 SWIG_Python_SetConstant(d, "TraceMemAlloc",SWIG_From_int(static_cast< int >(0x0001)));
38519 SWIG_Python_SetConstant(d, "TraceMessages",SWIG_From_int(static_cast< int >(0x0002)));
38520 SWIG_Python_SetConstant(d, "TraceResAlloc",SWIG_From_int(static_cast< int >(0x0004)));
38521 SWIG_Python_SetConstant(d, "TraceRefCount",SWIG_From_int(static_cast< int >(0x0008)));
38522 SWIG_Python_SetConstant(d, "TraceOleCalls",SWIG_From_int(static_cast< int >(0x0100)));
38523 SWIG_Python_SetConstant(d, "PROCESS_DEFAULT",SWIG_From_int(static_cast< int >(wxPROCESS_DEFAULT)));
38524 SWIG_Python_SetConstant(d, "PROCESS_REDIRECT",SWIG_From_int(static_cast< int >(wxPROCESS_REDIRECT)));
38525 SWIG_Python_SetConstant(d, "KILL_OK",SWIG_From_int(static_cast< int >(wxKILL_OK)));
38526 SWIG_Python_SetConstant(d, "KILL_BAD_SIGNAL",SWIG_From_int(static_cast< int >(wxKILL_BAD_SIGNAL)));
38527 SWIG_Python_SetConstant(d, "KILL_ACCESS_DENIED",SWIG_From_int(static_cast< int >(wxKILL_ACCESS_DENIED)));
38528 SWIG_Python_SetConstant(d, "KILL_NO_PROCESS",SWIG_From_int(static_cast< int >(wxKILL_NO_PROCESS)));
38529 SWIG_Python_SetConstant(d, "KILL_ERROR",SWIG_From_int(static_cast< int >(wxKILL_ERROR)));
38530 SWIG_Python_SetConstant(d, "KILL_NOCHILDREN",SWIG_From_int(static_cast< int >(wxKILL_NOCHILDREN)));
38531 SWIG_Python_SetConstant(d, "KILL_CHILDREN",SWIG_From_int(static_cast< int >(wxKILL_CHILDREN)));
38532 SWIG_Python_SetConstant(d, "SIGNONE",SWIG_From_int(static_cast< int >(wxSIGNONE)));
38533 SWIG_Python_SetConstant(d, "SIGHUP",SWIG_From_int(static_cast< int >(wxSIGHUP)));
38534 SWIG_Python_SetConstant(d, "SIGINT",SWIG_From_int(static_cast< int >(wxSIGINT)));
38535 SWIG_Python_SetConstant(d, "SIGQUIT",SWIG_From_int(static_cast< int >(wxSIGQUIT)));
38536 SWIG_Python_SetConstant(d, "SIGILL",SWIG_From_int(static_cast< int >(wxSIGILL)));
38537 SWIG_Python_SetConstant(d, "SIGTRAP",SWIG_From_int(static_cast< int >(wxSIGTRAP)));
38538 SWIG_Python_SetConstant(d, "SIGABRT",SWIG_From_int(static_cast< int >(wxSIGABRT)));
38539 SWIG_Python_SetConstant(d, "SIGIOT",SWIG_From_int(static_cast< int >(wxSIGIOT)));
38540 SWIG_Python_SetConstant(d, "SIGEMT",SWIG_From_int(static_cast< int >(wxSIGEMT)));
38541 SWIG_Python_SetConstant(d, "SIGFPE",SWIG_From_int(static_cast< int >(wxSIGFPE)));
38542 SWIG_Python_SetConstant(d, "SIGKILL",SWIG_From_int(static_cast< int >(wxSIGKILL)));
38543 SWIG_Python_SetConstant(d, "SIGBUS",SWIG_From_int(static_cast< int >(wxSIGBUS)));
38544 SWIG_Python_SetConstant(d, "SIGSEGV",SWIG_From_int(static_cast< int >(wxSIGSEGV)));
38545 SWIG_Python_SetConstant(d, "SIGSYS",SWIG_From_int(static_cast< int >(wxSIGSYS)));
38546 SWIG_Python_SetConstant(d, "SIGPIPE",SWIG_From_int(static_cast< int >(wxSIGPIPE)));
38547 SWIG_Python_SetConstant(d, "SIGALRM",SWIG_From_int(static_cast< int >(wxSIGALRM)));
38548 SWIG_Python_SetConstant(d, "SIGTERM",SWIG_From_int(static_cast< int >(wxSIGTERM)));
38549 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
38550 SWIG_Python_SetConstant(d, "EXEC_ASYNC",SWIG_From_int(static_cast< int >(wxEXEC_ASYNC)));
38551 SWIG_Python_SetConstant(d, "EXEC_SYNC",SWIG_From_int(static_cast< int >(wxEXEC_SYNC)));
38552 SWIG_Python_SetConstant(d, "EXEC_NOHIDE",SWIG_From_int(static_cast< int >(wxEXEC_NOHIDE)));
38553 SWIG_Python_SetConstant(d, "EXEC_MAKE_GROUP_LEADER",SWIG_From_int(static_cast< int >(wxEXEC_MAKE_GROUP_LEADER)));
38554 SWIG_Python_SetConstant(d, "EXEC_NODISABLE",SWIG_From_int(static_cast< int >(wxEXEC_NODISABLE)));
38555
38556 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
38557
38558 SWIG_Python_SetConstant(d, "JOYSTICK1",SWIG_From_int(static_cast< int >(wxJOYSTICK1)));
38559 SWIG_Python_SetConstant(d, "JOYSTICK2",SWIG_From_int(static_cast< int >(wxJOYSTICK2)));
38560 SWIG_Python_SetConstant(d, "JOY_BUTTON_ANY",SWIG_From_int(static_cast< int >(wxJOY_BUTTON_ANY)));
38561 SWIG_Python_SetConstant(d, "JOY_BUTTON1",SWIG_From_int(static_cast< int >(wxJOY_BUTTON1)));
38562 SWIG_Python_SetConstant(d, "JOY_BUTTON2",SWIG_From_int(static_cast< int >(wxJOY_BUTTON2)));
38563 SWIG_Python_SetConstant(d, "JOY_BUTTON3",SWIG_From_int(static_cast< int >(wxJOY_BUTTON3)));
38564 SWIG_Python_SetConstant(d, "JOY_BUTTON4",SWIG_From_int(static_cast< int >(wxJOY_BUTTON4)));
38565 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
38566 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
38567 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
38568 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
38569 SWIG_Python_SetConstant(d, "SOUND_SYNC",SWIG_From_int(static_cast< int >(wxSOUND_SYNC)));
38570 SWIG_Python_SetConstant(d, "SOUND_ASYNC",SWIG_From_int(static_cast< int >(wxSOUND_ASYNC)));
38571 SWIG_Python_SetConstant(d, "SOUND_LOOP",SWIG_From_int(static_cast< int >(wxSOUND_LOOP)));
38572 SWIG_Python_SetConstant(d, "MAILCAP_STANDARD",SWIG_From_int(static_cast< int >(wxMAILCAP_STANDARD)));
38573 SWIG_Python_SetConstant(d, "MAILCAP_NETSCAPE",SWIG_From_int(static_cast< int >(wxMAILCAP_NETSCAPE)));
38574 SWIG_Python_SetConstant(d, "MAILCAP_KDE",SWIG_From_int(static_cast< int >(wxMAILCAP_KDE)));
38575 SWIG_Python_SetConstant(d, "MAILCAP_GNOME",SWIG_From_int(static_cast< int >(wxMAILCAP_GNOME)));
38576 SWIG_Python_SetConstant(d, "MAILCAP_ALL",SWIG_From_int(static_cast< int >(wxMAILCAP_ALL)));
38577 SWIG_addvarlink(SWIG_globals(),(char*)"TheMimeTypesManager",TheMimeTypesManager_get, TheMimeTypesManager_set);
38578 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TOOLBAR",ART_TOOLBAR_get, ART_TOOLBAR_set);
38579 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MENU",ART_MENU_get, ART_MENU_set);
38580 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FRAME_ICON",ART_FRAME_ICON_get, ART_FRAME_ICON_set);
38581 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CMN_DIALOG",ART_CMN_DIALOG_get, ART_CMN_DIALOG_set);
38582 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BROWSER",ART_HELP_BROWSER_get, ART_HELP_BROWSER_set);
38583 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MESSAGE_BOX",ART_MESSAGE_BOX_get, ART_MESSAGE_BOX_set);
38584 SWIG_addvarlink(SWIG_globals(),(char*)"ART_BUTTON",ART_BUTTON_get, ART_BUTTON_set);
38585 SWIG_addvarlink(SWIG_globals(),(char*)"ART_OTHER",ART_OTHER_get, ART_OTHER_set);
38586 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ADD_BOOKMARK",ART_ADD_BOOKMARK_get, ART_ADD_BOOKMARK_set);
38587 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DEL_BOOKMARK",ART_DEL_BOOKMARK_get, ART_DEL_BOOKMARK_set);
38588 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SIDE_PANEL",ART_HELP_SIDE_PANEL_get, ART_HELP_SIDE_PANEL_set);
38589 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SETTINGS",ART_HELP_SETTINGS_get, ART_HELP_SETTINGS_set);
38590 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BOOK",ART_HELP_BOOK_get, ART_HELP_BOOK_set);
38591 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_FOLDER",ART_HELP_FOLDER_get, ART_HELP_FOLDER_set);
38592 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_PAGE",ART_HELP_PAGE_get, ART_HELP_PAGE_set);
38593 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_BACK",ART_GO_BACK_get, ART_GO_BACK_set);
38594 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_FORWARD",ART_GO_FORWARD_get, ART_GO_FORWARD_set);
38595 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_UP",ART_GO_UP_get, ART_GO_UP_set);
38596 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DOWN",ART_GO_DOWN_get, ART_GO_DOWN_set);
38597 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_TO_PARENT",ART_GO_TO_PARENT_get, ART_GO_TO_PARENT_set);
38598 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_HOME",ART_GO_HOME_get, ART_GO_HOME_set);
38599 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_OPEN",ART_FILE_OPEN_get, ART_FILE_OPEN_set);
38600 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE",ART_FILE_SAVE_get, ART_FILE_SAVE_set);
38601 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE_AS",ART_FILE_SAVE_AS_get, ART_FILE_SAVE_AS_set);
38602 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PRINT",ART_PRINT_get, ART_PRINT_set);
38603 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP",ART_HELP_get, ART_HELP_set);
38604 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TIP",ART_TIP_get, ART_TIP_set);
38605 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REPORT_VIEW",ART_REPORT_VIEW_get, ART_REPORT_VIEW_set);
38606 SWIG_addvarlink(SWIG_globals(),(char*)"ART_LIST_VIEW",ART_LIST_VIEW_get, ART_LIST_VIEW_set);
38607 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW_DIR",ART_NEW_DIR_get, ART_NEW_DIR_set);
38608 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HARDDISK",ART_HARDDISK_get, ART_HARDDISK_set);
38609 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FLOPPY",ART_FLOPPY_get, ART_FLOPPY_set);
38610 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CDROM",ART_CDROM_get, ART_CDROM_set);
38611 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REMOVABLE",ART_REMOVABLE_get, ART_REMOVABLE_set);
38612 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER",ART_FOLDER_get, ART_FOLDER_set);
38613 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER_OPEN",ART_FOLDER_OPEN_get, ART_FOLDER_OPEN_set);
38614 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DIR_UP",ART_GO_DIR_UP_get, ART_GO_DIR_UP_set);
38615 SWIG_addvarlink(SWIG_globals(),(char*)"ART_EXECUTABLE_FILE",ART_EXECUTABLE_FILE_get, ART_EXECUTABLE_FILE_set);
38616 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NORMAL_FILE",ART_NORMAL_FILE_get, ART_NORMAL_FILE_set);
38617 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TICK_MARK",ART_TICK_MARK_get, ART_TICK_MARK_set);
38618 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CROSS_MARK",ART_CROSS_MARK_get, ART_CROSS_MARK_set);
38619 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ERROR",ART_ERROR_get, ART_ERROR_set);
38620 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUESTION",ART_QUESTION_get, ART_QUESTION_set);
38621 SWIG_addvarlink(SWIG_globals(),(char*)"ART_WARNING",ART_WARNING_get, ART_WARNING_set);
38622 SWIG_addvarlink(SWIG_globals(),(char*)"ART_INFORMATION",ART_INFORMATION_get, ART_INFORMATION_set);
38623 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MISSING_IMAGE",ART_MISSING_IMAGE_get, ART_MISSING_IMAGE_set);
38624 SWIG_addvarlink(SWIG_globals(),(char*)"ART_COPY",ART_COPY_get, ART_COPY_set);
38625 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CUT",ART_CUT_get, ART_CUT_set);
38626 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PASTE",ART_PASTE_get, ART_PASTE_set);
38627 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DELETE",ART_DELETE_get, ART_DELETE_set);
38628 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW",ART_NEW_get, ART_NEW_set);
38629 SWIG_addvarlink(SWIG_globals(),(char*)"ART_UNDO",ART_UNDO_get, ART_UNDO_set);
38630 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REDO",ART_REDO_get, ART_REDO_set);
38631 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUIT",ART_QUIT_get, ART_QUIT_set);
38632 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND",ART_FIND_get, ART_FIND_set);
38633 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND_AND_REPLACE",ART_FIND_AND_REPLACE_get, ART_FIND_AND_REPLACE_set);
38634
38635 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
38636
38637 SWIG_Python_SetConstant(d, "CONFIG_USE_LOCAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_LOCAL_FILE)));
38638 SWIG_Python_SetConstant(d, "CONFIG_USE_GLOBAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_GLOBAL_FILE)));
38639 SWIG_Python_SetConstant(d, "CONFIG_USE_RELATIVE_PATH",SWIG_From_int(static_cast< int >(wxCONFIG_USE_RELATIVE_PATH)));
38640 SWIG_Python_SetConstant(d, "CONFIG_USE_NO_ESCAPE_CHARACTERS",SWIG_From_int(static_cast< int >(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
38641 SWIG_Python_SetConstant(d, "ConfigBase_Type_Unknown",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Unknown)));
38642 SWIG_Python_SetConstant(d, "ConfigBase_Type_String",SWIG_From_int(static_cast< int >(wxConfigBase::Type_String)));
38643 SWIG_Python_SetConstant(d, "ConfigBase_Type_Boolean",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Boolean)));
38644 SWIG_Python_SetConstant(d, "ConfigBase_Type_Integer",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Integer)));
38645 SWIG_Python_SetConstant(d, "ConfigBase_Type_Float",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Float)));
38646 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTimeFormat",DefaultDateTimeFormat_get, DefaultDateTimeFormat_set);
38647 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultTimeSpanFormat",DefaultTimeSpanFormat_get, DefaultTimeSpanFormat_set);
38648 SWIG_Python_SetConstant(d, "DateTime_Local",SWIG_From_int(static_cast< int >(wxDateTime::Local)));
38649 SWIG_Python_SetConstant(d, "DateTime_GMT_12",SWIG_From_int(static_cast< int >(wxDateTime::GMT_12)));
38650 SWIG_Python_SetConstant(d, "DateTime_GMT_11",SWIG_From_int(static_cast< int >(wxDateTime::GMT_11)));
38651 SWIG_Python_SetConstant(d, "DateTime_GMT_10",SWIG_From_int(static_cast< int >(wxDateTime::GMT_10)));
38652 SWIG_Python_SetConstant(d, "DateTime_GMT_9",SWIG_From_int(static_cast< int >(wxDateTime::GMT_9)));
38653 SWIG_Python_SetConstant(d, "DateTime_GMT_8",SWIG_From_int(static_cast< int >(wxDateTime::GMT_8)));
38654 SWIG_Python_SetConstant(d, "DateTime_GMT_7",SWIG_From_int(static_cast< int >(wxDateTime::GMT_7)));
38655 SWIG_Python_SetConstant(d, "DateTime_GMT_6",SWIG_From_int(static_cast< int >(wxDateTime::GMT_6)));
38656 SWIG_Python_SetConstant(d, "DateTime_GMT_5",SWIG_From_int(static_cast< int >(wxDateTime::GMT_5)));
38657 SWIG_Python_SetConstant(d, "DateTime_GMT_4",SWIG_From_int(static_cast< int >(wxDateTime::GMT_4)));
38658 SWIG_Python_SetConstant(d, "DateTime_GMT_3",SWIG_From_int(static_cast< int >(wxDateTime::GMT_3)));
38659 SWIG_Python_SetConstant(d, "DateTime_GMT_2",SWIG_From_int(static_cast< int >(wxDateTime::GMT_2)));
38660 SWIG_Python_SetConstant(d, "DateTime_GMT_1",SWIG_From_int(static_cast< int >(wxDateTime::GMT_1)));
38661 SWIG_Python_SetConstant(d, "DateTime_GMT0",SWIG_From_int(static_cast< int >(wxDateTime::GMT0)));
38662 SWIG_Python_SetConstant(d, "DateTime_GMT1",SWIG_From_int(static_cast< int >(wxDateTime::GMT1)));
38663 SWIG_Python_SetConstant(d, "DateTime_GMT2",SWIG_From_int(static_cast< int >(wxDateTime::GMT2)));
38664 SWIG_Python_SetConstant(d, "DateTime_GMT3",SWIG_From_int(static_cast< int >(wxDateTime::GMT3)));
38665 SWIG_Python_SetConstant(d, "DateTime_GMT4",SWIG_From_int(static_cast< int >(wxDateTime::GMT4)));
38666 SWIG_Python_SetConstant(d, "DateTime_GMT5",SWIG_From_int(static_cast< int >(wxDateTime::GMT5)));
38667 SWIG_Python_SetConstant(d, "DateTime_GMT6",SWIG_From_int(static_cast< int >(wxDateTime::GMT6)));
38668 SWIG_Python_SetConstant(d, "DateTime_GMT7",SWIG_From_int(static_cast< int >(wxDateTime::GMT7)));
38669 SWIG_Python_SetConstant(d, "DateTime_GMT8",SWIG_From_int(static_cast< int >(wxDateTime::GMT8)));
38670 SWIG_Python_SetConstant(d, "DateTime_GMT9",SWIG_From_int(static_cast< int >(wxDateTime::GMT9)));
38671 SWIG_Python_SetConstant(d, "DateTime_GMT10",SWIG_From_int(static_cast< int >(wxDateTime::GMT10)));
38672 SWIG_Python_SetConstant(d, "DateTime_GMT11",SWIG_From_int(static_cast< int >(wxDateTime::GMT11)));
38673 SWIG_Python_SetConstant(d, "DateTime_GMT12",SWIG_From_int(static_cast< int >(wxDateTime::GMT12)));
38674 SWIG_Python_SetConstant(d, "DateTime_WET",SWIG_From_int(static_cast< int >(wxDateTime::WET)));
38675 SWIG_Python_SetConstant(d, "DateTime_WEST",SWIG_From_int(static_cast< int >(wxDateTime::WEST)));
38676 SWIG_Python_SetConstant(d, "DateTime_CET",SWIG_From_int(static_cast< int >(wxDateTime::CET)));
38677 SWIG_Python_SetConstant(d, "DateTime_CEST",SWIG_From_int(static_cast< int >(wxDateTime::CEST)));
38678 SWIG_Python_SetConstant(d, "DateTime_EET",SWIG_From_int(static_cast< int >(wxDateTime::EET)));
38679 SWIG_Python_SetConstant(d, "DateTime_EEST",SWIG_From_int(static_cast< int >(wxDateTime::EEST)));
38680 SWIG_Python_SetConstant(d, "DateTime_MSK",SWIG_From_int(static_cast< int >(wxDateTime::MSK)));
38681 SWIG_Python_SetConstant(d, "DateTime_MSD",SWIG_From_int(static_cast< int >(wxDateTime::MSD)));
38682 SWIG_Python_SetConstant(d, "DateTime_AST",SWIG_From_int(static_cast< int >(wxDateTime::AST)));
38683 SWIG_Python_SetConstant(d, "DateTime_ADT",SWIG_From_int(static_cast< int >(wxDateTime::ADT)));
38684 SWIG_Python_SetConstant(d, "DateTime_EST",SWIG_From_int(static_cast< int >(wxDateTime::EST)));
38685 SWIG_Python_SetConstant(d, "DateTime_EDT",SWIG_From_int(static_cast< int >(wxDateTime::EDT)));
38686 SWIG_Python_SetConstant(d, "DateTime_CST",SWIG_From_int(static_cast< int >(wxDateTime::CST)));
38687 SWIG_Python_SetConstant(d, "DateTime_CDT",SWIG_From_int(static_cast< int >(wxDateTime::CDT)));
38688 SWIG_Python_SetConstant(d, "DateTime_MST",SWIG_From_int(static_cast< int >(wxDateTime::MST)));
38689 SWIG_Python_SetConstant(d, "DateTime_MDT",SWIG_From_int(static_cast< int >(wxDateTime::MDT)));
38690 SWIG_Python_SetConstant(d, "DateTime_PST",SWIG_From_int(static_cast< int >(wxDateTime::PST)));
38691 SWIG_Python_SetConstant(d, "DateTime_PDT",SWIG_From_int(static_cast< int >(wxDateTime::PDT)));
38692 SWIG_Python_SetConstant(d, "DateTime_HST",SWIG_From_int(static_cast< int >(wxDateTime::HST)));
38693 SWIG_Python_SetConstant(d, "DateTime_AKST",SWIG_From_int(static_cast< int >(wxDateTime::AKST)));
38694 SWIG_Python_SetConstant(d, "DateTime_AKDT",SWIG_From_int(static_cast< int >(wxDateTime::AKDT)));
38695 SWIG_Python_SetConstant(d, "DateTime_A_WST",SWIG_From_int(static_cast< int >(wxDateTime::A_WST)));
38696 SWIG_Python_SetConstant(d, "DateTime_A_CST",SWIG_From_int(static_cast< int >(wxDateTime::A_CST)));
38697 SWIG_Python_SetConstant(d, "DateTime_A_EST",SWIG_From_int(static_cast< int >(wxDateTime::A_EST)));
38698 SWIG_Python_SetConstant(d, "DateTime_A_ESST",SWIG_From_int(static_cast< int >(wxDateTime::A_ESST)));
38699 SWIG_Python_SetConstant(d, "DateTime_UTC",SWIG_From_int(static_cast< int >(wxDateTime::UTC)));
38700 SWIG_Python_SetConstant(d, "DateTime_Gregorian",SWIG_From_int(static_cast< int >(wxDateTime::Gregorian)));
38701 SWIG_Python_SetConstant(d, "DateTime_Julian",SWIG_From_int(static_cast< int >(wxDateTime::Julian)));
38702 SWIG_Python_SetConstant(d, "DateTime_Gr_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Unknown)));
38703 SWIG_Python_SetConstant(d, "DateTime_Gr_Standard",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Standard)));
38704 SWIG_Python_SetConstant(d, "DateTime_Gr_Alaska",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Alaska)));
38705 SWIG_Python_SetConstant(d, "DateTime_Gr_Albania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Albania)));
38706 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria)));
38707 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Brixen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Brixen)));
38708 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Salzburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Salzburg)));
38709 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Tyrol",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Tyrol)));
38710 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Carinthia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Carinthia)));
38711 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Styria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Styria)));
38712 SWIG_Python_SetConstant(d, "DateTime_Gr_Belgium",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Belgium)));
38713 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria)));
38714 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_1)));
38715 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_2)));
38716 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_3)));
38717 SWIG_Python_SetConstant(d, "DateTime_Gr_Canada",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Canada)));
38718 SWIG_Python_SetConstant(d, "DateTime_Gr_China",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China)));
38719 SWIG_Python_SetConstant(d, "DateTime_Gr_China_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_1)));
38720 SWIG_Python_SetConstant(d, "DateTime_Gr_China_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_2)));
38721 SWIG_Python_SetConstant(d, "DateTime_Gr_Czechoslovakia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Czechoslovakia)));
38722 SWIG_Python_SetConstant(d, "DateTime_Gr_Denmark",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Denmark)));
38723 SWIG_Python_SetConstant(d, "DateTime_Gr_Egypt",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Egypt)));
38724 SWIG_Python_SetConstant(d, "DateTime_Gr_Estonia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Estonia)));
38725 SWIG_Python_SetConstant(d, "DateTime_Gr_Finland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Finland)));
38726 SWIG_Python_SetConstant(d, "DateTime_Gr_France",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France)));
38727 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Alsace",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Alsace)));
38728 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Lorraine",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Lorraine)));
38729 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Strasbourg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Strasbourg)));
38730 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany)));
38731 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Catholic)));
38732 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Prussia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Prussia)));
38733 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Protestant)));
38734 SWIG_Python_SetConstant(d, "DateTime_Gr_GreatBritain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_GreatBritain)));
38735 SWIG_Python_SetConstant(d, "DateTime_Gr_Greece",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Greece)));
38736 SWIG_Python_SetConstant(d, "DateTime_Gr_Hungary",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Hungary)));
38737 SWIG_Python_SetConstant(d, "DateTime_Gr_Ireland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Ireland)));
38738 SWIG_Python_SetConstant(d, "DateTime_Gr_Italy",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Italy)));
38739 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan)));
38740 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_1)));
38741 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_2)));
38742 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_3)));
38743 SWIG_Python_SetConstant(d, "DateTime_Gr_Latvia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Latvia)));
38744 SWIG_Python_SetConstant(d, "DateTime_Gr_Lithuania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Lithuania)));
38745 SWIG_Python_SetConstant(d, "DateTime_Gr_Luxemburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Luxemburg)));
38746 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands)));
38747 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Groningen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Groningen)));
38748 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Gelderland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Gelderland)));
38749 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Utrecht",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Utrecht)));
38750 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Friesland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Friesland)));
38751 SWIG_Python_SetConstant(d, "DateTime_Gr_Norway",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Norway)));
38752 SWIG_Python_SetConstant(d, "DateTime_Gr_Poland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Poland)));
38753 SWIG_Python_SetConstant(d, "DateTime_Gr_Portugal",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Portugal)));
38754 SWIG_Python_SetConstant(d, "DateTime_Gr_Romania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Romania)));
38755 SWIG_Python_SetConstant(d, "DateTime_Gr_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Russia)));
38756 SWIG_Python_SetConstant(d, "DateTime_Gr_Scotland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Scotland)));
38757 SWIG_Python_SetConstant(d, "DateTime_Gr_Spain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Spain)));
38758 SWIG_Python_SetConstant(d, "DateTime_Gr_Sweden",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Sweden)));
38759 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland)));
38760 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Catholic)));
38761 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Protestant)));
38762 SWIG_Python_SetConstant(d, "DateTime_Gr_Turkey",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Turkey)));
38763 SWIG_Python_SetConstant(d, "DateTime_Gr_USA",SWIG_From_int(static_cast< int >(wxDateTime::Gr_USA)));
38764 SWIG_Python_SetConstant(d, "DateTime_Gr_Wales",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Wales)));
38765 SWIG_Python_SetConstant(d, "DateTime_Gr_Yugoslavia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Yugoslavia)));
38766 SWIG_Python_SetConstant(d, "DateTime_Country_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Country_Unknown)));
38767 SWIG_Python_SetConstant(d, "DateTime_Country_Default",SWIG_From_int(static_cast< int >(wxDateTime::Country_Default)));
38768 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_Start",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_Start)));
38769 SWIG_Python_SetConstant(d, "DateTime_Country_EEC",SWIG_From_int(static_cast< int >(wxDateTime::Country_EEC)));
38770 SWIG_Python_SetConstant(d, "DateTime_France",SWIG_From_int(static_cast< int >(wxDateTime::France)));
38771 SWIG_Python_SetConstant(d, "DateTime_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Germany)));
38772 SWIG_Python_SetConstant(d, "DateTime_UK",SWIG_From_int(static_cast< int >(wxDateTime::UK)));
38773 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_End",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_End)));
38774 SWIG_Python_SetConstant(d, "DateTime_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Russia)));
38775 SWIG_Python_SetConstant(d, "DateTime_USA",SWIG_From_int(static_cast< int >(wxDateTime::USA)));
38776 SWIG_Python_SetConstant(d, "DateTime_Jan",SWIG_From_int(static_cast< int >(wxDateTime::Jan)));
38777 SWIG_Python_SetConstant(d, "DateTime_Feb",SWIG_From_int(static_cast< int >(wxDateTime::Feb)));
38778 SWIG_Python_SetConstant(d, "DateTime_Mar",SWIG_From_int(static_cast< int >(wxDateTime::Mar)));
38779 SWIG_Python_SetConstant(d, "DateTime_Apr",SWIG_From_int(static_cast< int >(wxDateTime::Apr)));
38780 SWIG_Python_SetConstant(d, "DateTime_May",SWIG_From_int(static_cast< int >(wxDateTime::May)));
38781 SWIG_Python_SetConstant(d, "DateTime_Jun",SWIG_From_int(static_cast< int >(wxDateTime::Jun)));
38782 SWIG_Python_SetConstant(d, "DateTime_Jul",SWIG_From_int(static_cast< int >(wxDateTime::Jul)));
38783 SWIG_Python_SetConstant(d, "DateTime_Aug",SWIG_From_int(static_cast< int >(wxDateTime::Aug)));
38784 SWIG_Python_SetConstant(d, "DateTime_Sep",SWIG_From_int(static_cast< int >(wxDateTime::Sep)));
38785 SWIG_Python_SetConstant(d, "DateTime_Oct",SWIG_From_int(static_cast< int >(wxDateTime::Oct)));
38786 SWIG_Python_SetConstant(d, "DateTime_Nov",SWIG_From_int(static_cast< int >(wxDateTime::Nov)));
38787 SWIG_Python_SetConstant(d, "DateTime_Dec",SWIG_From_int(static_cast< int >(wxDateTime::Dec)));
38788 SWIG_Python_SetConstant(d, "DateTime_Inv_Month",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Month)));
38789 SWIG_Python_SetConstant(d, "DateTime_Sun",SWIG_From_int(static_cast< int >(wxDateTime::Sun)));
38790 SWIG_Python_SetConstant(d, "DateTime_Mon",SWIG_From_int(static_cast< int >(wxDateTime::Mon)));
38791 SWIG_Python_SetConstant(d, "DateTime_Tue",SWIG_From_int(static_cast< int >(wxDateTime::Tue)));
38792 SWIG_Python_SetConstant(d, "DateTime_Wed",SWIG_From_int(static_cast< int >(wxDateTime::Wed)));
38793 SWIG_Python_SetConstant(d, "DateTime_Thu",SWIG_From_int(static_cast< int >(wxDateTime::Thu)));
38794 SWIG_Python_SetConstant(d, "DateTime_Fri",SWIG_From_int(static_cast< int >(wxDateTime::Fri)));
38795 SWIG_Python_SetConstant(d, "DateTime_Sat",SWIG_From_int(static_cast< int >(wxDateTime::Sat)));
38796 SWIG_Python_SetConstant(d, "DateTime_Inv_WeekDay",SWIG_From_int(static_cast< int >(wxDateTime::Inv_WeekDay)));
38797 SWIG_Python_SetConstant(d, "DateTime_Inv_Year",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Year)));
38798 SWIG_Python_SetConstant(d, "DateTime_Name_Full",SWIG_From_int(static_cast< int >(wxDateTime::Name_Full)));
38799 SWIG_Python_SetConstant(d, "DateTime_Name_Abbr",SWIG_From_int(static_cast< int >(wxDateTime::Name_Abbr)));
38800 SWIG_Python_SetConstant(d, "DateTime_Default_First",SWIG_From_int(static_cast< int >(wxDateTime::Default_First)));
38801 SWIG_Python_SetConstant(d, "DateTime_Monday_First",SWIG_From_int(static_cast< int >(wxDateTime::Monday_First)));
38802 SWIG_Python_SetConstant(d, "DateTime_Sunday_First",SWIG_From_int(static_cast< int >(wxDateTime::Sunday_First)));
38803 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTime",DefaultDateTime_get, DefaultDateTime_set);
38804 SWIG_Python_SetConstant(d, "DF_INVALID",SWIG_From_int(static_cast< int >(wxDF_INVALID)));
38805 SWIG_Python_SetConstant(d, "DF_TEXT",SWIG_From_int(static_cast< int >(wxDF_TEXT)));
38806 SWIG_Python_SetConstant(d, "DF_BITMAP",SWIG_From_int(static_cast< int >(wxDF_BITMAP)));
38807 SWIG_Python_SetConstant(d, "DF_METAFILE",SWIG_From_int(static_cast< int >(wxDF_METAFILE)));
38808 SWIG_Python_SetConstant(d, "DF_SYLK",SWIG_From_int(static_cast< int >(wxDF_SYLK)));
38809 SWIG_Python_SetConstant(d, "DF_DIF",SWIG_From_int(static_cast< int >(wxDF_DIF)));
38810 SWIG_Python_SetConstant(d, "DF_TIFF",SWIG_From_int(static_cast< int >(wxDF_TIFF)));
38811 SWIG_Python_SetConstant(d, "DF_OEMTEXT",SWIG_From_int(static_cast< int >(wxDF_OEMTEXT)));
38812 SWIG_Python_SetConstant(d, "DF_DIB",SWIG_From_int(static_cast< int >(wxDF_DIB)));
38813 SWIG_Python_SetConstant(d, "DF_PALETTE",SWIG_From_int(static_cast< int >(wxDF_PALETTE)));
38814 SWIG_Python_SetConstant(d, "DF_PENDATA",SWIG_From_int(static_cast< int >(wxDF_PENDATA)));
38815 SWIG_Python_SetConstant(d, "DF_RIFF",SWIG_From_int(static_cast< int >(wxDF_RIFF)));
38816 SWIG_Python_SetConstant(d, "DF_WAVE",SWIG_From_int(static_cast< int >(wxDF_WAVE)));
38817 SWIG_Python_SetConstant(d, "DF_UNICODETEXT",SWIG_From_int(static_cast< int >(wxDF_UNICODETEXT)));
38818 SWIG_Python_SetConstant(d, "DF_ENHMETAFILE",SWIG_From_int(static_cast< int >(wxDF_ENHMETAFILE)));
38819 SWIG_Python_SetConstant(d, "DF_FILENAME",SWIG_From_int(static_cast< int >(wxDF_FILENAME)));
38820 SWIG_Python_SetConstant(d, "DF_LOCALE",SWIG_From_int(static_cast< int >(wxDF_LOCALE)));
38821 SWIG_Python_SetConstant(d, "DF_PRIVATE",SWIG_From_int(static_cast< int >(wxDF_PRIVATE)));
38822 SWIG_Python_SetConstant(d, "DF_HTML",SWIG_From_int(static_cast< int >(wxDF_HTML)));
38823 SWIG_Python_SetConstant(d, "DF_MAX",SWIG_From_int(static_cast< int >(wxDF_MAX)));
38824 SWIG_addvarlink(SWIG_globals(),(char*)"FormatInvalid",FormatInvalid_get, FormatInvalid_set);
38825 SWIG_Python_SetConstant(d, "DataObject_Get",SWIG_From_int(static_cast< int >(wxDataObject::Get)));
38826 SWIG_Python_SetConstant(d, "DataObject_Set",SWIG_From_int(static_cast< int >(wxDataObject::Set)));
38827 SWIG_Python_SetConstant(d, "DataObject_Both",SWIG_From_int(static_cast< int >(wxDataObject::Both)));
38828 SWIG_Python_SetConstant(d, "Drag_CopyOnly",SWIG_From_int(static_cast< int >(wxDrag_CopyOnly)));
38829 SWIG_Python_SetConstant(d, "Drag_AllowMove",SWIG_From_int(static_cast< int >(wxDrag_AllowMove)));
38830 SWIG_Python_SetConstant(d, "Drag_DefaultMove",SWIG_From_int(static_cast< int >(wxDrag_DefaultMove)));
38831 SWIG_Python_SetConstant(d, "DragError",SWIG_From_int(static_cast< int >(wxDragError)));
38832 SWIG_Python_SetConstant(d, "DragNone",SWIG_From_int(static_cast< int >(wxDragNone)));
38833 SWIG_Python_SetConstant(d, "DragCopy",SWIG_From_int(static_cast< int >(wxDragCopy)));
38834 SWIG_Python_SetConstant(d, "DragMove",SWIG_From_int(static_cast< int >(wxDragMove)));
38835 SWIG_Python_SetConstant(d, "DragLink",SWIG_From_int(static_cast< int >(wxDragLink)));
38836 SWIG_Python_SetConstant(d, "DragCancel",SWIG_From_int(static_cast< int >(wxDragCancel)));
38837
38838 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
38839 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
38840 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
38841 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
38842
38843 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultVideoMode",DefaultVideoMode_get, DefaultVideoMode_set);
38844 }
38845
wxWidgets (Impactor)