]> 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
reSWIGged
[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 #if PY_VERSION_HEX < 0x02050000
989 typedef int Py_ssize_t;
990 #endif
991
992 /* for raw pointers */
993 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
994 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
995 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
996 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
997 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
998 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
999 #define swig_owntype int
1000
1001 /* for raw packed data */
1002 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1003 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1004
1005 /* for class or struct pointers */
1006 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1007 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1008
1009 /* for C or C++ function pointers */
1010 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1011 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1012
1013 /* for C++ member pointers, ie, member methods */
1014 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1015 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1016
1017
1018 /* Runtime API */
1019
1020 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1021 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1022 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1023
1024 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1025 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1026 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1027 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1028 #define SWIG_fail goto fail
1029
1030
1031 /* Runtime API implementation */
1032
1033 /* Error manipulation */
1034
1035 SWIGINTERN void
1036 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1037 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1038 PyErr_SetObject(errtype, obj);
1039 Py_DECREF(obj);
1040 SWIG_PYTHON_THREAD_END_BLOCK;
1041 }
1042
1043 SWIGINTERN void
1044 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1045 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1046 PyErr_SetString(errtype, (char *) msg);
1047 SWIG_PYTHON_THREAD_END_BLOCK;
1048 }
1049
1050 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1051
1052 /* Set a constant value */
1053
1054 SWIGINTERN void
1055 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1056 PyDict_SetItemString(d, (char*) name, obj);
1057 Py_DECREF(obj);
1058 }
1059
1060 /* Append a value to the result obj */
1061
1062 SWIGINTERN PyObject*
1063 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1064 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1065 if (!result) {
1066 result = obj;
1067 } else if (result == Py_None) {
1068 Py_DECREF(result);
1069 result = obj;
1070 } else {
1071 if (!PyList_Check(result)) {
1072 PyObject *o2 = result;
1073 result = PyList_New(1);
1074 PyList_SetItem(result, 0, o2);
1075 }
1076 PyList_Append(result,obj);
1077 Py_DECREF(obj);
1078 }
1079 return result;
1080 #else
1081 PyObject* o2;
1082 PyObject* o3;
1083 if (!result) {
1084 result = obj;
1085 } else if (result == Py_None) {
1086 Py_DECREF(result);
1087 result = obj;
1088 } else {
1089 if (!PyTuple_Check(result)) {
1090 o2 = result;
1091 result = PyTuple_New(1);
1092 PyTuple_SET_ITEM(result, 0, o2);
1093 }
1094 o3 = PyTuple_New(1);
1095 PyTuple_SET_ITEM(o3, 0, obj);
1096 o2 = result;
1097 result = PySequence_Concat(o2, o3);
1098 Py_DECREF(o2);
1099 Py_DECREF(o3);
1100 }
1101 return result;
1102 #endif
1103 }
1104
1105 /* Unpack the argument tuple */
1106
1107 SWIGINTERN int
1108 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1109 {
1110 if (!args) {
1111 if (!min && !max) {
1112 return 1;
1113 } else {
1114 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1115 name, (min == max ? "" : "at least "), min);
1116 return 0;
1117 }
1118 }
1119 if (!PyTuple_Check(args)) {
1120 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1121 return 0;
1122 } else {
1123 register int l = PyTuple_GET_SIZE(args);
1124 if (l < min) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at least "), min, l);
1127 return 0;
1128 } else if (l > max) {
1129 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1130 name, (min == max ? "" : "at most "), max, l);
1131 return 0;
1132 } else {
1133 register int i;
1134 for (i = 0; i < l; ++i) {
1135 objs[i] = PyTuple_GET_ITEM(args, i);
1136 }
1137 for (; l < max; ++l) {
1138 objs[l] = 0;
1139 }
1140 return i + 1;
1141 }
1142 }
1143 }
1144
1145 /* A functor is a function object with one single object argument */
1146 #if PY_VERSION_HEX >= 0x02020000
1147 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1148 #else
1149 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1150 #endif
1151
1152 /*
1153 Helper for static pointer initialization for both C and C++ code, for example
1154 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1155 */
1156 #ifdef __cplusplus
1157 #define SWIG_STATIC_POINTER(var) var
1158 #else
1159 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1160 #endif
1161
1162 /* -----------------------------------------------------------------------------
1163 * Pointer declarations
1164 * ----------------------------------------------------------------------------- */
1165
1166 /* Flags for new pointer objects */
1167 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1168 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1169
1170 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1171
1172 #ifdef __cplusplus
1173 extern "C" {
1174 #if 0
1175 } /* cc-mode */
1176 #endif
1177 #endif
1178
1179 /* How to access Py_None */
1180 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1181 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1182 # ifndef SWIG_PYTHON_BUILD_NONE
1183 # define SWIG_PYTHON_BUILD_NONE
1184 # endif
1185 # endif
1186 #endif
1187
1188 #ifdef SWIG_PYTHON_BUILD_NONE
1189 # ifdef Py_None
1190 # undef Py_None
1191 # define Py_None SWIG_Py_None()
1192 # endif
1193 SWIGRUNTIMEINLINE PyObject *
1194 _SWIG_Py_None(void)
1195 {
1196 PyObject *none = Py_BuildValue("");
1197 Py_DECREF(none);
1198 return none;
1199 }
1200 SWIGRUNTIME PyObject *
1201 SWIG_Py_None(void)
1202 {
1203 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1204 return none;
1205 }
1206 #endif
1207
1208 /* The python void return value */
1209
1210 SWIGRUNTIMEINLINE PyObject *
1211 SWIG_Py_Void(void)
1212 {
1213 PyObject *none = Py_None;
1214 Py_INCREF(none);
1215 return none;
1216 }
1217
1218 /* PySwigClientData */
1219
1220 typedef struct {
1221 PyObject *klass;
1222 PyObject *newraw;
1223 PyObject *newargs;
1224 PyObject *destroy;
1225 int delargs;
1226 int implicitconv;
1227 } PySwigClientData;
1228
1229 SWIGRUNTIMEINLINE int
1230 SWIG_Python_CheckImplicit(swig_type_info *ty)
1231 {
1232 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1233 return data ? data->implicitconv : 0;
1234 }
1235
1236 SWIGRUNTIMEINLINE PyObject *
1237 SWIG_Python_ExceptionType(swig_type_info *desc) {
1238 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1239 PyObject *klass = data ? data->klass : 0;
1240 return (klass ? klass : PyExc_RuntimeError);
1241 }
1242
1243
1244 SWIGRUNTIME PySwigClientData *
1245 PySwigClientData_New(PyObject* obj)
1246 {
1247 if (!obj) {
1248 return 0;
1249 } else {
1250 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1251 /* the klass element */
1252 data->klass = obj;
1253 Py_INCREF(data->klass);
1254 /* the newraw method and newargs arguments used to create a new raw instance */
1255 if (PyClass_Check(obj)) {
1256 data->newraw = 0;
1257 data->newargs = obj;
1258 Py_INCREF(obj);
1259 } else {
1260 #if (PY_VERSION_HEX < 0x02020000)
1261 data->newraw = 0;
1262 #else
1263 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1264 #endif
1265 if (data->newraw) {
1266 Py_INCREF(data->newraw);
1267 data->newargs = PyTuple_New(1);
1268 PyTuple_SetItem(data->newargs, 0, obj);
1269 } else {
1270 data->newargs = obj;
1271 }
1272 Py_INCREF(data->newargs);
1273 }
1274 /* the destroy method, aka as the C++ delete method */
1275 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1276 if (PyErr_Occurred()) {
1277 PyErr_Clear();
1278 data->destroy = 0;
1279 }
1280 if (data->destroy) {
1281 int flags;
1282 Py_INCREF(data->destroy);
1283 flags = PyCFunction_GET_FLAGS(data->destroy);
1284 #ifdef METH_O
1285 data->delargs = !(flags & (METH_O));
1286 #else
1287 data->delargs = 0;
1288 #endif
1289 } else {
1290 data->delargs = 0;
1291 }
1292 data->implicitconv = 0;
1293 return data;
1294 }
1295 }
1296
1297 SWIGRUNTIME void
1298 PySwigClientData_Del(PySwigClientData* data)
1299 {
1300 Py_XDECREF(data->newraw);
1301 Py_XDECREF(data->newargs);
1302 Py_XDECREF(data->destroy);
1303 }
1304
1305 /* =============== PySwigObject =====================*/
1306
1307 typedef struct {
1308 PyObject_HEAD
1309 void *ptr;
1310 swig_type_info *ty;
1311 int own;
1312 PyObject *next;
1313 } PySwigObject;
1314
1315 SWIGRUNTIME PyObject *
1316 PySwigObject_long(PySwigObject *v)
1317 {
1318 return PyLong_FromVoidPtr(v->ptr);
1319 }
1320
1321 SWIGRUNTIME PyObject *
1322 PySwigObject_format(const char* fmt, PySwigObject *v)
1323 {
1324 PyObject *res = NULL;
1325 PyObject *args = PyTuple_New(1);
1326 if (args) {
1327 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1328 PyObject *ofmt = PyString_FromString(fmt);
1329 if (ofmt) {
1330 res = PyString_Format(ofmt,args);
1331 Py_DECREF(ofmt);
1332 }
1333 Py_DECREF(args);
1334 }
1335 }
1336 return res;
1337 }
1338
1339 SWIGRUNTIME PyObject *
1340 PySwigObject_oct(PySwigObject *v)
1341 {
1342 return PySwigObject_format("%o",v);
1343 }
1344
1345 SWIGRUNTIME PyObject *
1346 PySwigObject_hex(PySwigObject *v)
1347 {
1348 return PySwigObject_format("%x",v);
1349 }
1350
1351 SWIGRUNTIME PyObject *
1352 #ifdef METH_NOARGS
1353 PySwigObject_repr(PySwigObject *v)
1354 #else
1355 PySwigObject_repr(PySwigObject *v, PyObject *args)
1356 #endif
1357 {
1358 const char *name = SWIG_TypePrettyName(v->ty);
1359 PyObject *hex = PySwigObject_hex(v);
1360 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1361 Py_DECREF(hex);
1362 if (v->next) {
1363 #ifdef METH_NOARGS
1364 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1365 #else
1366 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1367 #endif
1368 PyString_ConcatAndDel(&repr,nrep);
1369 }
1370 return repr;
1371 }
1372
1373 SWIGRUNTIME int
1374 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1375 {
1376 #ifdef METH_NOARGS
1377 PyObject *repr = PySwigObject_repr(v);
1378 #else
1379 PyObject *repr = PySwigObject_repr(v, NULL);
1380 #endif
1381 if (repr) {
1382 fputs(PyString_AsString(repr), fp);
1383 Py_DECREF(repr);
1384 return 0;
1385 } else {
1386 return 1;
1387 }
1388 }
1389
1390 SWIGRUNTIME PyObject *
1391 PySwigObject_str(PySwigObject *v)
1392 {
1393 char result[SWIG_BUFFER_SIZE];
1394 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1395 PyString_FromString(result) : 0;
1396 }
1397
1398 SWIGRUNTIME int
1399 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1400 {
1401 void *i = v->ptr;
1402 void *j = w->ptr;
1403 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1404 }
1405
1406 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1407
1408 SWIGRUNTIME PyTypeObject*
1409 PySwigObject_type(void) {
1410 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1411 return type;
1412 }
1413
1414 SWIGRUNTIMEINLINE int
1415 PySwigObject_Check(PyObject *op) {
1416 return ((op)->ob_type == PySwigObject_type())
1417 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1418 }
1419
1420 SWIGRUNTIME PyObject *
1421 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1422
1423 SWIGRUNTIME void
1424 PySwigObject_dealloc(PyObject *v)
1425 {
1426 PySwigObject *sobj = (PySwigObject *) v;
1427 PyObject *next = sobj->next;
1428 if (sobj->own) {
1429 swig_type_info *ty = sobj->ty;
1430 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1431 PyObject *destroy = data ? data->destroy : 0;
1432 if (destroy) {
1433 /* destroy is always a VARARGS method */
1434 PyObject *res;
1435 if (data->delargs) {
1436 /* we need to create a temporal object to carry the destroy operation */
1437 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1438 res = SWIG_Python_CallFunctor(destroy, tmp);
1439 Py_DECREF(tmp);
1440 } else {
1441 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1442 PyObject *mself = PyCFunction_GET_SELF(destroy);
1443 res = ((*meth)(mself, v));
1444 }
1445 Py_XDECREF(res);
1446 } else {
1447 const char *name = SWIG_TypePrettyName(ty);
1448 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1449 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1450 #endif
1451 }
1452 }
1453 Py_XDECREF(next);
1454 PyObject_DEL(v);
1455 }
1456
1457 SWIGRUNTIME PyObject*
1458 PySwigObject_append(PyObject* v, PyObject* next)
1459 {
1460 PySwigObject *sobj = (PySwigObject *) v;
1461 #ifndef METH_O
1462 PyObject *tmp = 0;
1463 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1464 next = tmp;
1465 #endif
1466 if (!PySwigObject_Check(next)) {
1467 return NULL;
1468 }
1469 sobj->next = next;
1470 Py_INCREF(next);
1471 return SWIG_Py_Void();
1472 }
1473
1474 SWIGRUNTIME PyObject*
1475 #ifdef METH_NOARGS
1476 PySwigObject_next(PyObject* v)
1477 #else
1478 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1479 #endif
1480 {
1481 PySwigObject *sobj = (PySwigObject *) v;
1482 if (sobj->next) {
1483 Py_INCREF(sobj->next);
1484 return sobj->next;
1485 } else {
1486 return SWIG_Py_Void();
1487 }
1488 }
1489
1490 SWIGINTERN PyObject*
1491 #ifdef METH_NOARGS
1492 PySwigObject_disown(PyObject *v)
1493 #else
1494 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1495 #endif
1496 {
1497 PySwigObject *sobj = (PySwigObject *)v;
1498 sobj->own = 0;
1499 return SWIG_Py_Void();
1500 }
1501
1502 SWIGINTERN PyObject*
1503 #ifdef METH_NOARGS
1504 PySwigObject_acquire(PyObject *v)
1505 #else
1506 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1507 #endif
1508 {
1509 PySwigObject *sobj = (PySwigObject *)v;
1510 sobj->own = SWIG_POINTER_OWN;
1511 return SWIG_Py_Void();
1512 }
1513
1514 SWIGINTERN PyObject*
1515 PySwigObject_own(PyObject *v, PyObject *args)
1516 {
1517 PyObject *val = 0;
1518 #if (PY_VERSION_HEX < 0x02020000)
1519 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1520 #else
1521 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1522 #endif
1523 {
1524 return NULL;
1525 }
1526 else
1527 {
1528 PySwigObject *sobj = (PySwigObject *)v;
1529 PyObject *obj = PyBool_FromLong(sobj->own);
1530 if (val) {
1531 #ifdef METH_NOARGS
1532 if (PyObject_IsTrue(val)) {
1533 PySwigObject_acquire(v);
1534 } else {
1535 PySwigObject_disown(v);
1536 }
1537 #else
1538 if (PyObject_IsTrue(val)) {
1539 PySwigObject_acquire(v,args);
1540 } else {
1541 PySwigObject_disown(v,args);
1542 }
1543 #endif
1544 }
1545 return obj;
1546 }
1547 }
1548
1549 #ifdef METH_O
1550 static PyMethodDef
1551 swigobject_methods[] = {
1552 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1553 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1554 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1555 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1556 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1557 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1558 {0, 0, 0, 0}
1559 };
1560 #else
1561 static PyMethodDef
1562 swigobject_methods[] = {
1563 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1564 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1565 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1566 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1567 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1568 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1569 {0, 0, 0, 0}
1570 };
1571 #endif
1572
1573 #if PY_VERSION_HEX < 0x02020000
1574 SWIGINTERN PyObject *
1575 PySwigObject_getattr(PySwigObject *sobj,char *name)
1576 {
1577 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1578 }
1579 #endif
1580
1581 SWIGRUNTIME PyTypeObject*
1582 _PySwigObject_type(void) {
1583 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1584
1585 static PyNumberMethods PySwigObject_as_number = {
1586 (binaryfunc)0, /*nb_add*/
1587 (binaryfunc)0, /*nb_subtract*/
1588 (binaryfunc)0, /*nb_multiply*/
1589 (binaryfunc)0, /*nb_divide*/
1590 (binaryfunc)0, /*nb_remainder*/
1591 (binaryfunc)0, /*nb_divmod*/
1592 (ternaryfunc)0,/*nb_power*/
1593 (unaryfunc)0, /*nb_negative*/
1594 (unaryfunc)0, /*nb_positive*/
1595 (unaryfunc)0, /*nb_absolute*/
1596 (inquiry)0, /*nb_nonzero*/
1597 0, /*nb_invert*/
1598 0, /*nb_lshift*/
1599 0, /*nb_rshift*/
1600 0, /*nb_and*/
1601 0, /*nb_xor*/
1602 0, /*nb_or*/
1603 (coercion)0, /*nb_coerce*/
1604 (unaryfunc)PySwigObject_long, /*nb_int*/
1605 (unaryfunc)PySwigObject_long, /*nb_long*/
1606 (unaryfunc)0, /*nb_float*/
1607 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1608 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1609 #if PY_VERSION_HEX >= 0x02020000
1610 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1611 #elif PY_VERSION_HEX >= 0x02000000
1612 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1613 #endif
1614 };
1615
1616 static PyTypeObject pyswigobject_type;
1617 static int type_init = 0;
1618 if (!type_init) {
1619 const PyTypeObject tmp
1620 = {
1621 PyObject_HEAD_INIT(NULL)
1622 0, /* ob_size */
1623 (char *)"PySwigObject", /* tp_name */
1624 sizeof(PySwigObject), /* tp_basicsize */
1625 0, /* tp_itemsize */
1626 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1627 (printfunc)PySwigObject_print, /* tp_print */
1628 #if PY_VERSION_HEX < 0x02020000
1629 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1630 #else
1631 (getattrfunc)0, /* tp_getattr */
1632 #endif
1633 (setattrfunc)0, /* tp_setattr */
1634 (cmpfunc)PySwigObject_compare, /* tp_compare */
1635 (reprfunc)PySwigObject_repr, /* tp_repr */
1636 &PySwigObject_as_number, /* tp_as_number */
1637 0, /* tp_as_sequence */
1638 0, /* tp_as_mapping */
1639 (hashfunc)0, /* tp_hash */
1640 (ternaryfunc)0, /* tp_call */
1641 (reprfunc)PySwigObject_str, /* tp_str */
1642 PyObject_GenericGetAttr, /* tp_getattro */
1643 0, /* tp_setattro */
1644 0, /* tp_as_buffer */
1645 Py_TPFLAGS_DEFAULT, /* tp_flags */
1646 swigobject_doc, /* tp_doc */
1647 0, /* tp_traverse */
1648 0, /* tp_clear */
1649 0, /* tp_richcompare */
1650 0, /* tp_weaklistoffset */
1651 #if PY_VERSION_HEX >= 0x02020000
1652 0, /* tp_iter */
1653 0, /* tp_iternext */
1654 swigobject_methods, /* tp_methods */
1655 0, /* tp_members */
1656 0, /* tp_getset */
1657 0, /* tp_base */
1658 0, /* tp_dict */
1659 0, /* tp_descr_get */
1660 0, /* tp_descr_set */
1661 0, /* tp_dictoffset */
1662 0, /* tp_init */
1663 0, /* tp_alloc */
1664 0, /* tp_new */
1665 0, /* tp_free */
1666 0, /* tp_is_gc */
1667 0, /* tp_bases */
1668 0, /* tp_mro */
1669 0, /* tp_cache */
1670 0, /* tp_subclasses */
1671 0, /* tp_weaklist */
1672 #endif
1673 #if PY_VERSION_HEX >= 0x02030000
1674 0, /* tp_del */
1675 #endif
1676 #ifdef COUNT_ALLOCS
1677 0,0,0,0 /* tp_alloc -> tp_next */
1678 #endif
1679 };
1680 pyswigobject_type = tmp;
1681 pyswigobject_type.ob_type = &PyType_Type;
1682 type_init = 1;
1683 }
1684 return &pyswigobject_type;
1685 }
1686
1687 SWIGRUNTIME PyObject *
1688 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1689 {
1690 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1691 if (sobj) {
1692 sobj->ptr = ptr;
1693 sobj->ty = ty;
1694 sobj->own = own;
1695 sobj->next = 0;
1696 }
1697 return (PyObject *)sobj;
1698 }
1699
1700 /* -----------------------------------------------------------------------------
1701 * Implements a simple Swig Packed type, and use it instead of string
1702 * ----------------------------------------------------------------------------- */
1703
1704 typedef struct {
1705 PyObject_HEAD
1706 void *pack;
1707 swig_type_info *ty;
1708 size_t size;
1709 } PySwigPacked;
1710
1711 SWIGRUNTIME int
1712 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1713 {
1714 char result[SWIG_BUFFER_SIZE];
1715 fputs("<Swig Packed ", fp);
1716 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1717 fputs("at ", fp);
1718 fputs(result, fp);
1719 }
1720 fputs(v->ty->name,fp);
1721 fputs(">", fp);
1722 return 0;
1723 }
1724
1725 SWIGRUNTIME PyObject *
1726 PySwigPacked_repr(PySwigPacked *v)
1727 {
1728 char result[SWIG_BUFFER_SIZE];
1729 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1730 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1731 } else {
1732 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1733 }
1734 }
1735
1736 SWIGRUNTIME PyObject *
1737 PySwigPacked_str(PySwigPacked *v)
1738 {
1739 char result[SWIG_BUFFER_SIZE];
1740 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1741 return PyString_FromFormat("%s%s", result, v->ty->name);
1742 } else {
1743 return PyString_FromString(v->ty->name);
1744 }
1745 }
1746
1747 SWIGRUNTIME int
1748 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1749 {
1750 size_t i = v->size;
1751 size_t j = w->size;
1752 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1753 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1754 }
1755
1756 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1757
1758 SWIGRUNTIME PyTypeObject*
1759 PySwigPacked_type(void) {
1760 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1761 return type;
1762 }
1763
1764 SWIGRUNTIMEINLINE int
1765 PySwigPacked_Check(PyObject *op) {
1766 return ((op)->ob_type == _PySwigPacked_type())
1767 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1768 }
1769
1770 SWIGRUNTIME void
1771 PySwigPacked_dealloc(PyObject *v)
1772 {
1773 if (PySwigPacked_Check(v)) {
1774 PySwigPacked *sobj = (PySwigPacked *) v;
1775 free(sobj->pack);
1776 }
1777 PyObject_DEL(v);
1778 }
1779
1780 SWIGRUNTIME PyTypeObject*
1781 _PySwigPacked_type(void) {
1782 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1783 static PyTypeObject pyswigpacked_type;
1784 static int type_init = 0;
1785 if (!type_init) {
1786 const PyTypeObject tmp
1787 = {
1788 PyObject_HEAD_INIT(NULL)
1789 0, /* ob_size */
1790 (char *)"PySwigPacked", /* tp_name */
1791 sizeof(PySwigPacked), /* tp_basicsize */
1792 0, /* tp_itemsize */
1793 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1794 (printfunc)PySwigPacked_print, /* tp_print */
1795 (getattrfunc)0, /* tp_getattr */
1796 (setattrfunc)0, /* tp_setattr */
1797 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1798 (reprfunc)PySwigPacked_repr, /* tp_repr */
1799 0, /* tp_as_number */
1800 0, /* tp_as_sequence */
1801 0, /* tp_as_mapping */
1802 (hashfunc)0, /* tp_hash */
1803 (ternaryfunc)0, /* tp_call */
1804 (reprfunc)PySwigPacked_str, /* tp_str */
1805 PyObject_GenericGetAttr, /* tp_getattro */
1806 0, /* tp_setattro */
1807 0, /* tp_as_buffer */
1808 Py_TPFLAGS_DEFAULT, /* tp_flags */
1809 swigpacked_doc, /* tp_doc */
1810 0, /* tp_traverse */
1811 0, /* tp_clear */
1812 0, /* tp_richcompare */
1813 0, /* tp_weaklistoffset */
1814 #if PY_VERSION_HEX >= 0x02020000
1815 0, /* tp_iter */
1816 0, /* tp_iternext */
1817 0, /* tp_methods */
1818 0, /* tp_members */
1819 0, /* tp_getset */
1820 0, /* tp_base */
1821 0, /* tp_dict */
1822 0, /* tp_descr_get */
1823 0, /* tp_descr_set */
1824 0, /* tp_dictoffset */
1825 0, /* tp_init */
1826 0, /* tp_alloc */
1827 0, /* tp_new */
1828 0, /* tp_free */
1829 0, /* tp_is_gc */
1830 0, /* tp_bases */
1831 0, /* tp_mro */
1832 0, /* tp_cache */
1833 0, /* tp_subclasses */
1834 0, /* tp_weaklist */
1835 #endif
1836 #if PY_VERSION_HEX >= 0x02030000
1837 0, /* tp_del */
1838 #endif
1839 #ifdef COUNT_ALLOCS
1840 0,0,0,0 /* tp_alloc -> tp_next */
1841 #endif
1842 };
1843 pyswigpacked_type = tmp;
1844 pyswigpacked_type.ob_type = &PyType_Type;
1845 type_init = 1;
1846 }
1847 return &pyswigpacked_type;
1848 }
1849
1850 SWIGRUNTIME PyObject *
1851 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1852 {
1853 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1854 if (sobj) {
1855 void *pack = malloc(size);
1856 if (pack) {
1857 memcpy(pack, ptr, size);
1858 sobj->pack = pack;
1859 sobj->ty = ty;
1860 sobj->size = size;
1861 } else {
1862 PyObject_DEL((PyObject *) sobj);
1863 sobj = 0;
1864 }
1865 }
1866 return (PyObject *) sobj;
1867 }
1868
1869 SWIGRUNTIME swig_type_info *
1870 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1871 {
1872 if (PySwigPacked_Check(obj)) {
1873 PySwigPacked *sobj = (PySwigPacked *)obj;
1874 if (sobj->size != size) return 0;
1875 memcpy(ptr, sobj->pack, size);
1876 return sobj->ty;
1877 } else {
1878 return 0;
1879 }
1880 }
1881
1882 /* -----------------------------------------------------------------------------
1883 * pointers/data manipulation
1884 * ----------------------------------------------------------------------------- */
1885
1886 SWIGRUNTIMEINLINE PyObject *
1887 _SWIG_This(void)
1888 {
1889 return PyString_FromString("this");
1890 }
1891
1892 SWIGRUNTIME PyObject *
1893 SWIG_This(void)
1894 {
1895 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1896 return swig_this;
1897 }
1898
1899 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1900
1901 SWIGRUNTIME PySwigObject *
1902 SWIG_Python_GetSwigThis(PyObject *pyobj)
1903 {
1904 if (PySwigObject_Check(pyobj)) {
1905 return (PySwigObject *) pyobj;
1906 } else {
1907 PyObject *obj = 0;
1908 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1909 if (PyInstance_Check(pyobj)) {
1910 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1911 } else {
1912 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1913 if (dictptr != NULL) {
1914 PyObject *dict = *dictptr;
1915 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1916 } else {
1917 #ifdef PyWeakref_CheckProxy
1918 if (PyWeakref_CheckProxy(pyobj)) {
1919 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1920 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1921 }
1922 #endif
1923 obj = PyObject_GetAttr(pyobj,SWIG_This());
1924 if (obj) {
1925 Py_DECREF(obj);
1926 } else {
1927 if (PyErr_Occurred()) PyErr_Clear();
1928 return 0;
1929 }
1930 }
1931 }
1932 #else
1933 obj = PyObject_GetAttr(pyobj,SWIG_This());
1934 if (obj) {
1935 Py_DECREF(obj);
1936 } else {
1937 if (PyErr_Occurred()) PyErr_Clear();
1938 return 0;
1939 }
1940 #endif
1941 if (obj && !PySwigObject_Check(obj)) {
1942 /* a PyObject is called 'this', try to get the 'real this'
1943 PySwigObject from it */
1944 return SWIG_Python_GetSwigThis(obj);
1945 }
1946 return (PySwigObject *)obj;
1947 }
1948 }
1949
1950 /* Acquire a pointer value */
1951
1952 SWIGRUNTIME int
1953 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1954 if (own) {
1955 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1956 if (sobj) {
1957 int oldown = sobj->own;
1958 sobj->own = own;
1959 return oldown;
1960 }
1961 }
1962 return 0;
1963 }
1964
1965 /* Convert a pointer value */
1966
1967 SWIGRUNTIME int
1968 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1969 if (!obj) return SWIG_ERROR;
1970 if (obj == Py_None) {
1971 if (ptr) *ptr = 0;
1972 return SWIG_OK;
1973 } else {
1974 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1975 while (sobj) {
1976 void *vptr = sobj->ptr;
1977 if (ty) {
1978 swig_type_info *to = sobj->ty;
1979 if (to == ty) {
1980 /* no type cast needed */
1981 if (ptr) *ptr = vptr;
1982 break;
1983 } else {
1984 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1985 if (!tc) {
1986 sobj = (PySwigObject *)sobj->next;
1987 } else {
1988 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1989 break;
1990 }
1991 }
1992 } else {
1993 if (ptr) *ptr = vptr;
1994 break;
1995 }
1996 }
1997 if (sobj) {
1998 if (own) *own = sobj->own;
1999 if (flags & SWIG_POINTER_DISOWN) {
2000 sobj->own = 0;
2001 }
2002 return SWIG_OK;
2003 } else {
2004 int res = SWIG_ERROR;
2005 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2006 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2007 if (data && !data->implicitconv) {
2008 PyObject *klass = data->klass;
2009 if (klass) {
2010 PyObject *impconv;
2011 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2012 impconv = SWIG_Python_CallFunctor(klass, obj);
2013 data->implicitconv = 0;
2014 if (PyErr_Occurred()) {
2015 PyErr_Clear();
2016 impconv = 0;
2017 }
2018 if (impconv) {
2019 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2020 if (iobj) {
2021 void *vptr;
2022 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2023 if (SWIG_IsOK(res)) {
2024 if (ptr) {
2025 *ptr = vptr;
2026 /* transfer the ownership to 'ptr' */
2027 iobj->own = 0;
2028 res = SWIG_AddCast(res);
2029 res = SWIG_AddNewMask(res);
2030 } else {
2031 res = SWIG_AddCast(res);
2032 }
2033 }
2034 }
2035 Py_DECREF(impconv);
2036 }
2037 }
2038 }
2039 }
2040 return res;
2041 }
2042 }
2043 }
2044
2045 /* Convert a function ptr value */
2046
2047 SWIGRUNTIME int
2048 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2049 if (!PyCFunction_Check(obj)) {
2050 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2051 } else {
2052 void *vptr = 0;
2053
2054 /* here we get the method pointer for callbacks */
2055 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2056 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2057 if (desc) {
2058 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2059 if (!desc) return SWIG_ERROR;
2060 }
2061 if (ty) {
2062 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2063 if (!tc) return SWIG_ERROR;
2064 *ptr = SWIG_TypeCast(tc,vptr);
2065 } else {
2066 *ptr = vptr;
2067 }
2068 return SWIG_OK;
2069 }
2070 }
2071
2072 /* Convert a packed value value */
2073
2074 SWIGRUNTIME int
2075 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2076 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2077 if (!to) return SWIG_ERROR;
2078 if (ty) {
2079 if (to != ty) {
2080 /* check type cast? */
2081 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2082 if (!tc) return SWIG_ERROR;
2083 }
2084 }
2085 return SWIG_OK;
2086 }
2087
2088 /* -----------------------------------------------------------------------------
2089 * Create a new pointer object
2090 * ----------------------------------------------------------------------------- */
2091
2092 /*
2093 Create a new instance object, whitout calling __init__, and set the
2094 'this' attribute.
2095 */
2096
2097 SWIGRUNTIME PyObject*
2098 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2099 {
2100 #if (PY_VERSION_HEX >= 0x02020000)
2101 PyObject *inst = 0;
2102 PyObject *newraw = data->newraw;
2103 if (newraw) {
2104 inst = PyObject_Call(newraw, data->newargs, NULL);
2105 if (inst) {
2106 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2107 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2108 if (dictptr != NULL) {
2109 PyObject *dict = *dictptr;
2110 if (dict == NULL) {
2111 dict = PyDict_New();
2112 *dictptr = dict;
2113 PyDict_SetItem(dict, SWIG_This(), swig_this);
2114 }
2115 }
2116 #else
2117 PyObject *key = SWIG_This();
2118 PyObject_SetAttr(inst, key, swig_this);
2119 #endif
2120 }
2121 } else {
2122 PyObject *dict = PyDict_New();
2123 PyDict_SetItem(dict, SWIG_This(), swig_this);
2124 inst = PyInstance_NewRaw(data->newargs, dict);
2125 Py_DECREF(dict);
2126 }
2127 return inst;
2128 #else
2129 #if (PY_VERSION_HEX >= 0x02010000)
2130 PyObject *inst;
2131 PyObject *dict = PyDict_New();
2132 PyDict_SetItem(dict, SWIG_This(), swig_this);
2133 inst = PyInstance_NewRaw(data->newargs, dict);
2134 Py_DECREF(dict);
2135 return (PyObject *) inst;
2136 #else
2137 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2138 if (inst == NULL) {
2139 return NULL;
2140 }
2141 inst->in_class = (PyClassObject *)data->newargs;
2142 Py_INCREF(inst->in_class);
2143 inst->in_dict = PyDict_New();
2144 if (inst->in_dict == NULL) {
2145 Py_DECREF(inst);
2146 return NULL;
2147 }
2148 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2149 inst->in_weakreflist = NULL;
2150 #endif
2151 #ifdef Py_TPFLAGS_GC
2152 PyObject_GC_Init(inst);
2153 #endif
2154 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2155 return (PyObject *) inst;
2156 #endif
2157 #endif
2158 }
2159
2160 SWIGRUNTIME void
2161 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2162 {
2163 PyObject *dict;
2164 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2165 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2166 if (dictptr != NULL) {
2167 dict = *dictptr;
2168 if (dict == NULL) {
2169 dict = PyDict_New();
2170 *dictptr = dict;
2171 }
2172 PyDict_SetItem(dict, SWIG_This(), swig_this);
2173 return;
2174 }
2175 #endif
2176 dict = PyObject_GetAttrString(inst, "__dict__");
2177 PyDict_SetItem(dict, SWIG_This(), swig_this);
2178 Py_DECREF(dict);
2179 }
2180
2181
2182 SWIGINTERN PyObject *
2183 SWIG_Python_InitShadowInstance(PyObject *args) {
2184 PyObject *obj[2];
2185 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2186 return NULL;
2187 } else {
2188 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2189 if (sthis) {
2190 PySwigObject_append((PyObject*) sthis, obj[1]);
2191 } else {
2192 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2193 }
2194 return SWIG_Py_Void();
2195 }
2196 }
2197
2198 /* Create a new pointer object */
2199
2200 SWIGRUNTIME PyObject *
2201 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2202 if (!ptr) {
2203 return SWIG_Py_Void();
2204 } else {
2205 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2206 PyObject *robj = PySwigObject_New(ptr, type, own);
2207 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2208 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2209 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2210 if (inst) {
2211 Py_DECREF(robj);
2212 robj = inst;
2213 }
2214 }
2215 return robj;
2216 }
2217 }
2218
2219 /* Create a new packed object */
2220
2221 SWIGRUNTIMEINLINE PyObject *
2222 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2223 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2224 }
2225
2226 /* -----------------------------------------------------------------------------*
2227 * Get type list
2228 * -----------------------------------------------------------------------------*/
2229
2230 #ifdef SWIG_LINK_RUNTIME
2231 void *SWIG_ReturnGlobalTypeList(void *);
2232 #endif
2233
2234 SWIGRUNTIME swig_module_info *
2235 SWIG_Python_GetModule(void) {
2236 static void *type_pointer = (void *)0;
2237 /* first check if module already created */
2238 if (!type_pointer) {
2239 #ifdef SWIG_LINK_RUNTIME
2240 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2241 #else
2242 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2243 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2244 if (PyErr_Occurred()) {
2245 PyErr_Clear();
2246 type_pointer = (void *)0;
2247 }
2248 #endif
2249 }
2250 return (swig_module_info *) type_pointer;
2251 }
2252
2253 #if PY_MAJOR_VERSION < 2
2254 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2255 is copied out of Python/modsupport.c in python version 2.3.4 */
2256 SWIGINTERN int
2257 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2258 {
2259 PyObject *dict;
2260 if (!PyModule_Check(m)) {
2261 PyErr_SetString(PyExc_TypeError,
2262 "PyModule_AddObject() needs module as first arg");
2263 return SWIG_ERROR;
2264 }
2265 if (!o) {
2266 PyErr_SetString(PyExc_TypeError,
2267 "PyModule_AddObject() needs non-NULL value");
2268 return SWIG_ERROR;
2269 }
2270
2271 dict = PyModule_GetDict(m);
2272 if (dict == NULL) {
2273 /* Internal error -- modules must have a dict! */
2274 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2275 PyModule_GetName(m));
2276 return SWIG_ERROR;
2277 }
2278 if (PyDict_SetItemString(dict, name, o))
2279 return SWIG_ERROR;
2280 Py_DECREF(o);
2281 return SWIG_OK;
2282 }
2283 #endif
2284
2285 SWIGRUNTIME void
2286 SWIG_Python_DestroyModule(void *vptr)
2287 {
2288 swig_module_info *swig_module = (swig_module_info *) vptr;
2289 swig_type_info **types = swig_module->types;
2290 size_t i;
2291 for (i =0; i < swig_module->size; ++i) {
2292 swig_type_info *ty = types[i];
2293 if (ty->owndata) {
2294 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2295 if (data) PySwigClientData_Del(data);
2296 }
2297 }
2298 Py_DECREF(SWIG_This());
2299 }
2300
2301 SWIGRUNTIME void
2302 SWIG_Python_SetModule(swig_module_info *swig_module) {
2303 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2304
2305 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2306 swig_empty_runtime_method_table);
2307 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2308 if (pointer && module) {
2309 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2310 } else {
2311 Py_XDECREF(pointer);
2312 }
2313 }
2314
2315 /* The python cached type query */
2316 SWIGRUNTIME PyObject *
2317 SWIG_Python_TypeCache() {
2318 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2319 return cache;
2320 }
2321
2322 SWIGRUNTIME swig_type_info *
2323 SWIG_Python_TypeQuery(const char *type)
2324 {
2325 PyObject *cache = SWIG_Python_TypeCache();
2326 PyObject *key = PyString_FromString(type);
2327 PyObject *obj = PyDict_GetItem(cache, key);
2328 swig_type_info *descriptor;
2329 if (obj) {
2330 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2331 } else {
2332 swig_module_info *swig_module = SWIG_Python_GetModule();
2333 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2334 if (descriptor) {
2335 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2336 PyDict_SetItem(cache, key, obj);
2337 Py_DECREF(obj);
2338 }
2339 }
2340 Py_DECREF(key);
2341 return descriptor;
2342 }
2343
2344 /*
2345 For backward compatibility only
2346 */
2347 #define SWIG_POINTER_EXCEPTION 0
2348 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2349 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2350
2351 SWIGRUNTIME int
2352 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2353 {
2354 if (PyErr_Occurred()) {
2355 PyObject *type = 0;
2356 PyObject *value = 0;
2357 PyObject *traceback = 0;
2358 PyErr_Fetch(&type, &value, &traceback);
2359 if (value) {
2360 PyObject *old_str = PyObject_Str(value);
2361 Py_XINCREF(type);
2362 PyErr_Clear();
2363 if (infront) {
2364 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2365 } else {
2366 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2367 }
2368 Py_DECREF(old_str);
2369 }
2370 return 1;
2371 } else {
2372 return 0;
2373 }
2374 }
2375
2376 SWIGRUNTIME int
2377 SWIG_Python_ArgFail(int argnum)
2378 {
2379 if (PyErr_Occurred()) {
2380 /* add information about failing argument */
2381 char mesg[256];
2382 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2383 return SWIG_Python_AddErrMesg(mesg, 1);
2384 } else {
2385 return 0;
2386 }
2387 }
2388
2389 SWIGRUNTIMEINLINE const char *
2390 PySwigObject_GetDesc(PyObject *self)
2391 {
2392 PySwigObject *v = (PySwigObject *)self;
2393 swig_type_info *ty = v ? v->ty : 0;
2394 return ty ? ty->str : (char*)"";
2395 }
2396
2397 SWIGRUNTIME void
2398 SWIG_Python_TypeError(const char *type, PyObject *obj)
2399 {
2400 if (type) {
2401 #if defined(SWIG_COBJECT_TYPES)
2402 if (obj && PySwigObject_Check(obj)) {
2403 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2404 if (otype) {
2405 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2406 type, otype);
2407 return;
2408 }
2409 } else
2410 #endif
2411 {
2412 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2413 if (otype) {
2414 PyObject *str = PyObject_Str(obj);
2415 const char *cstr = str ? PyString_AsString(str) : 0;
2416 if (cstr) {
2417 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2418 type, otype, cstr);
2419 } else {
2420 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2421 type, otype);
2422 }
2423 Py_XDECREF(str);
2424 return;
2425 }
2426 }
2427 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2428 } else {
2429 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2430 }
2431 }
2432
2433
2434 /* Convert a pointer value, signal an exception on a type mismatch */
2435 SWIGRUNTIME void *
2436 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2437 void *result;
2438 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2439 PyErr_Clear();
2440 if (flags & SWIG_POINTER_EXCEPTION) {
2441 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2442 SWIG_Python_ArgFail(argnum);
2443 }
2444 }
2445 return result;
2446 }
2447
2448
2449 #ifdef __cplusplus
2450 #if 0
2451 { /* cc-mode */
2452 #endif
2453 }
2454 #endif
2455
2456
2457
2458 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2459
2460 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2461
2462
2463
2464 /* -------- TYPES TABLE (BEGIN) -------- */
2465
2466 #define SWIGTYPE_p_char swig_types[0]
2467 #define SWIGTYPE_p_form_ops_t swig_types[1]
2468 #define SWIGTYPE_p_int swig_types[2]
2469 #define SWIGTYPE_p_unsigned_char swig_types[3]
2470 #define SWIGTYPE_p_unsigned_int swig_types[4]
2471 #define SWIGTYPE_p_unsigned_long swig_types[5]
2472 #define SWIGTYPE_p_void swig_types[6]
2473 #define SWIGTYPE_p_wxANIHandler swig_types[7]
2474 #define SWIGTYPE_p_wxAcceleratorTable swig_types[8]
2475 #define SWIGTYPE_p_wxActivateEvent swig_types[9]
2476 #define SWIGTYPE_p_wxArrayString swig_types[10]
2477 #define SWIGTYPE_p_wxBMPHandler swig_types[11]
2478 #define SWIGTYPE_p_wxBitmap swig_types[12]
2479 #define SWIGTYPE_p_wxBitmapDataObject swig_types[13]
2480 #define SWIGTYPE_p_wxBoxSizer swig_types[14]
2481 #define SWIGTYPE_p_wxBusyCursor swig_types[15]
2482 #define SWIGTYPE_p_wxBusyInfo swig_types[16]
2483 #define SWIGTYPE_p_wxCURHandler swig_types[17]
2484 #define SWIGTYPE_p_wxCaret swig_types[18]
2485 #define SWIGTYPE_p_wxChar swig_types[19]
2486 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
2487 #define SWIGTYPE_p_wxClipboard swig_types[21]
2488 #define SWIGTYPE_p_wxClipboardLocker swig_types[22]
2489 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[23]
2490 #define SWIGTYPE_p_wxCloseEvent swig_types[24]
2491 #define SWIGTYPE_p_wxColour swig_types[25]
2492 #define SWIGTYPE_p_wxCommandEvent swig_types[26]
2493 #define SWIGTYPE_p_wxConfig swig_types[27]
2494 #define SWIGTYPE_p_wxConfigBase swig_types[28]
2495 #define SWIGTYPE_p_wxConfigPathChanger swig_types[29]
2496 #define SWIGTYPE_p_wxContextMenuEvent swig_types[30]
2497 #define SWIGTYPE_p_wxControl swig_types[31]
2498 #define SWIGTYPE_p_wxControlWithItems swig_types[32]
2499 #define SWIGTYPE_p_wxCursor swig_types[33]
2500 #define SWIGTYPE_p_wxCustomDataObject swig_types[34]
2501 #define SWIGTYPE_p_wxDC swig_types[35]
2502 #define SWIGTYPE_p_wxDataFormat swig_types[36]
2503 #define SWIGTYPE_p_wxDataObject swig_types[37]
2504 #define SWIGTYPE_p_wxDataObjectComposite swig_types[38]
2505 #define SWIGTYPE_p_wxDataObjectSimple swig_types[39]
2506 #define SWIGTYPE_p_wxDateEvent swig_types[40]
2507 #define SWIGTYPE_p_wxDateSpan swig_types[41]
2508 #define SWIGTYPE_p_wxDateTime swig_types[42]
2509 #define SWIGTYPE_p_wxDateTime__TimeZone swig_types[43]
2510 #define SWIGTYPE_p_wxDisplay swig_types[44]
2511 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[45]
2512 #define SWIGTYPE_p_wxDropFilesEvent swig_types[46]
2513 #define SWIGTYPE_p_wxDuplexMode swig_types[47]
2514 #define SWIGTYPE_p_wxEraseEvent swig_types[48]
2515 #define SWIGTYPE_p_wxEvent swig_types[49]
2516 #define SWIGTYPE_p_wxEvtHandler swig_types[50]
2517 #define SWIGTYPE_p_wxFSFile swig_types[51]
2518 #define SWIGTYPE_p_wxFileConfig swig_types[52]
2519 #define SWIGTYPE_p_wxFileDataObject swig_types[53]
2520 #define SWIGTYPE_p_wxFileHistory swig_types[54]
2521 #define SWIGTYPE_p_wxFileSystem swig_types[55]
2522 #define SWIGTYPE_p_wxFileType swig_types[56]
2523 #define SWIGTYPE_p_wxFileTypeInfo swig_types[57]
2524 #define SWIGTYPE_p_wxFlexGridSizer swig_types[58]
2525 #define SWIGTYPE_p_wxFocusEvent swig_types[59]
2526 #define SWIGTYPE_p_wxFont swig_types[60]
2527 #define SWIGTYPE_p_wxFrame swig_types[61]
2528 #define SWIGTYPE_p_wxGBSizerItem swig_types[62]
2529 #define SWIGTYPE_p_wxGIFHandler swig_types[63]
2530 #define SWIGTYPE_p_wxGridBagSizer swig_types[64]
2531 #define SWIGTYPE_p_wxGridSizer swig_types[65]
2532 #define SWIGTYPE_p_wxICOHandler swig_types[66]
2533 #define SWIGTYPE_p_wxIcon swig_types[67]
2534 #define SWIGTYPE_p_wxIconizeEvent swig_types[68]
2535 #define SWIGTYPE_p_wxIdleEvent swig_types[69]
2536 #define SWIGTYPE_p_wxImage swig_types[70]
2537 #define SWIGTYPE_p_wxImageHandler swig_types[71]
2538 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[72]
2539 #define SWIGTYPE_p_wxInitDialogEvent swig_types[73]
2540 #define SWIGTYPE_p_wxJPEGHandler swig_types[74]
2541 #define SWIGTYPE_p_wxJoystick swig_types[75]
2542 #define SWIGTYPE_p_wxJoystickEvent swig_types[76]
2543 #define SWIGTYPE_p_wxKeyEvent swig_types[77]
2544 #define SWIGTYPE_p_wxKillError swig_types[78]
2545 #define SWIGTYPE_p_wxLayoutConstraints swig_types[79]
2546 #define SWIGTYPE_p_wxLog swig_types[80]
2547 #define SWIGTYPE_p_wxLogBuffer swig_types[81]
2548 #define SWIGTYPE_p_wxLogChain swig_types[82]
2549 #define SWIGTYPE_p_wxLogGui swig_types[83]
2550 #define SWIGTYPE_p_wxLogNull swig_types[84]
2551 #define SWIGTYPE_p_wxLogStderr swig_types[85]
2552 #define SWIGTYPE_p_wxLogTextCtrl swig_types[86]
2553 #define SWIGTYPE_p_wxLogWindow swig_types[87]
2554 #define SWIGTYPE_p_wxMaximizeEvent swig_types[88]
2555 #define SWIGTYPE_p_wxMenu swig_types[89]
2556 #define SWIGTYPE_p_wxMenuBar swig_types[90]
2557 #define SWIGTYPE_p_wxMenuEvent swig_types[91]
2558 #define SWIGTYPE_p_wxMenuItem swig_types[92]
2559 #define SWIGTYPE_p_wxMetafile swig_types[93]
2560 #define SWIGTYPE_p_wxMetafileDataObject swig_types[94]
2561 #define SWIGTYPE_p_wxMimeTypesManager swig_types[95]
2562 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[96]
2563 #define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[97]
2564 #define SWIGTYPE_p_wxMouseEvent swig_types[98]
2565 #define SWIGTYPE_p_wxMouseState swig_types[99]
2566 #define SWIGTYPE_p_wxMoveEvent swig_types[100]
2567 #define SWIGTYPE_p_wxMutexGuiLocker swig_types[101]
2568 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[102]
2569 #define SWIGTYPE_p_wxNcPaintEvent swig_types[103]
2570 #define SWIGTYPE_p_wxNotifyEvent swig_types[104]
2571 #define SWIGTYPE_p_wxObject swig_types[105]
2572 #define SWIGTYPE_p_wxOutputStream swig_types[106]
2573 #define SWIGTYPE_p_wxPCXHandler swig_types[107]
2574 #define SWIGTYPE_p_wxPNGHandler swig_types[108]
2575 #define SWIGTYPE_p_wxPNMHandler swig_types[109]
2576 #define SWIGTYPE_p_wxPaintEvent swig_types[110]
2577 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[111]
2578 #define SWIGTYPE_p_wxPaperSize swig_types[112]
2579 #define SWIGTYPE_p_wxPlatformInfo swig_types[113]
2580 #define SWIGTYPE_p_wxPoint swig_types[114]
2581 #define SWIGTYPE_p_wxPowerEvent swig_types[115]
2582 #define SWIGTYPE_p_wxProcessEvent swig_types[116]
2583 #define SWIGTYPE_p_wxPyApp swig_types[117]
2584 #define SWIGTYPE_p_wxPyArtProvider swig_types[118]
2585 #define SWIGTYPE_p_wxPyBitmapDataObject swig_types[119]
2586 #define SWIGTYPE_p_wxPyCommandEvent swig_types[120]
2587 #define SWIGTYPE_p_wxPyDataObjectSimple swig_types[121]
2588 #define SWIGTYPE_p_wxPyDropSource swig_types[122]
2589 #define SWIGTYPE_p_wxPyDropTarget swig_types[123]
2590 #define SWIGTYPE_p_wxPyEvent swig_types[124]
2591 #define SWIGTYPE_p_wxPyFileDropTarget swig_types[125]
2592 #define SWIGTYPE_p_wxPyImageHandler swig_types[126]
2593 #define SWIGTYPE_p_wxPyLog swig_types[127]
2594 #define SWIGTYPE_p_wxPyProcess swig_types[128]
2595 #define SWIGTYPE_p_wxPySizer swig_types[129]
2596 #define SWIGTYPE_p_wxPyTextDataObject swig_types[130]
2597 #define SWIGTYPE_p_wxPyTextDropTarget swig_types[131]
2598 #define SWIGTYPE_p_wxPyTimer swig_types[132]
2599 #define SWIGTYPE_p_wxPyTipProvider swig_types[133]
2600 #define SWIGTYPE_p_wxPyValidator swig_types[134]
2601 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[135]
2602 #define SWIGTYPE_p_wxRect swig_types[136]
2603 #define SWIGTYPE_p_wxScrollEvent swig_types[137]
2604 #define SWIGTYPE_p_wxScrollWinEvent swig_types[138]
2605 #define SWIGTYPE_p_wxSetCursorEvent swig_types[139]
2606 #define SWIGTYPE_p_wxShowEvent swig_types[140]
2607 #define SWIGTYPE_p_wxSingleInstanceChecker swig_types[141]
2608 #define SWIGTYPE_p_wxSize swig_types[142]
2609 #define SWIGTYPE_p_wxSizeEvent swig_types[143]
2610 #define SWIGTYPE_p_wxSizer swig_types[144]
2611 #define SWIGTYPE_p_wxSizerItem swig_types[145]
2612 #define SWIGTYPE_p_wxSound swig_types[146]
2613 #define SWIGTYPE_p_wxStandardPaths swig_types[147]
2614 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[148]
2615 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[149]
2616 #define SWIGTYPE_p_wxStopWatch swig_types[150]
2617 #define SWIGTYPE_p_wxString swig_types[151]
2618 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[152]
2619 #define SWIGTYPE_p_wxSystemOptions swig_types[153]
2620 #define SWIGTYPE_p_wxSystemSettings swig_types[154]
2621 #define SWIGTYPE_p_wxTIFFHandler swig_types[155]
2622 #define SWIGTYPE_p_wxTextCtrl swig_types[156]
2623 #define SWIGTYPE_p_wxTextDataObject swig_types[157]
2624 #define SWIGTYPE_p_wxTimeSpan swig_types[158]
2625 #define SWIGTYPE_p_wxTimer swig_types[159]
2626 #define SWIGTYPE_p_wxTimerEvent swig_types[160]
2627 #define SWIGTYPE_p_wxTimerRunner swig_types[161]
2628 #define SWIGTYPE_p_wxTipProvider swig_types[162]
2629 #define SWIGTYPE_p_wxToolTip swig_types[163]
2630 #define SWIGTYPE_p_wxURLDataObject swig_types[164]
2631 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[165]
2632 #define SWIGTYPE_p_wxValidator swig_types[166]
2633 #define SWIGTYPE_p_wxVideoMode swig_types[167]
2634 #define SWIGTYPE_p_wxWindow swig_types[168]
2635 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[169]
2636 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[170]
2637 #define SWIGTYPE_p_wxWindowDisabler swig_types[171]
2638 #define SWIGTYPE_p_wxXPMHandler swig_types[172]
2639 static swig_type_info *swig_types[174];
2640 static swig_module_info swig_module = {swig_types, 173, 0, 0, 0, 0};
2641 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2642 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2643
2644 /* -------- TYPES TABLE (END) -------- */
2645
2646 #if (PY_VERSION_HEX <= 0x02000000)
2647 # if !defined(SWIG_PYTHON_CLASSIC)
2648 # error "This python version requires to use swig with the '-classic' option"
2649 # endif
2650 #endif
2651 #if (PY_VERSION_HEX <= 0x02020000)
2652 # error "This python version requires to use swig with the '-nomodern' option"
2653 #endif
2654 #if (PY_VERSION_HEX <= 0x02020000)
2655 # error "This python version requires to use swig with the '-nomodernargs' option"
2656 #endif
2657 #ifndef METH_O
2658 # error "This python version requires to use swig with the '-nofastunpack' option"
2659 #endif
2660
2661 /*-----------------------------------------------
2662 @(target):= _misc_.so
2663 ------------------------------------------------*/
2664 #define SWIG_init init_misc_
2665
2666 #define SWIG_name "_misc_"
2667
2668 #define SWIGVERSION 0x010329
2669
2670
2671 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2672 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2673
2674
2675 #include <stdexcept>
2676
2677
2678 namespace swig {
2679 class PyObject_ptr {
2680 protected:
2681 PyObject *_obj;
2682
2683 public:
2684 PyObject_ptr() :_obj(0)
2685 {
2686 }
2687
2688 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2689 {
2690 Py_XINCREF(_obj);
2691 }
2692
2693 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2694 {
2695 if (initial_ref) Py_XINCREF(_obj);
2696 }
2697
2698 PyObject_ptr & operator=(const PyObject_ptr& item)
2699 {
2700 Py_XINCREF(item._obj);
2701 Py_XDECREF(_obj);
2702 _obj = item._obj;
2703 return *this;
2704 }
2705
2706 ~PyObject_ptr()
2707 {
2708 Py_XDECREF(_obj);
2709 }
2710
2711 operator PyObject *() const
2712 {
2713 return _obj;
2714 }
2715
2716 PyObject *operator->() const
2717 {
2718 return _obj;
2719 }
2720 };
2721 }
2722
2723
2724 namespace swig {
2725 struct PyObject_var : PyObject_ptr {
2726 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2727
2728 PyObject_var & operator = (PyObject* obj)
2729 {
2730 Py_XDECREF(_obj);
2731 _obj = obj;
2732 return *this;
2733 }
2734 };
2735 }
2736
2737
2738 #include "wx/wxPython/wxPython.h"
2739 #include "wx/wxPython/pyclasses.h"
2740 #include "wx/wxPython/pyistream.h"
2741
2742 static const wxString wxPyEmptyString(wxEmptyString);
2743
2744
2745
2746 #define SWIG_From_long PyInt_FromLong
2747
2748
2749 SWIGINTERNINLINE PyObject *
2750 SWIG_From_int (int value)
2751 {
2752 return SWIG_From_long (value);
2753 }
2754
2755
2756 #include <limits.h>
2757 #ifndef LLONG_MIN
2758 # define LLONG_MIN LONG_LONG_MIN
2759 #endif
2760 #ifndef LLONG_MAX
2761 # define LLONG_MAX LONG_LONG_MAX
2762 #endif
2763 #ifndef ULLONG_MAX
2764 # define ULLONG_MAX ULONG_LONG_MAX
2765 #endif
2766
2767
2768 SWIGINTERN int
2769 SWIG_AsVal_long (PyObject* obj, long* val)
2770 {
2771 if (PyNumber_Check(obj)) {
2772 if (val) *val = PyInt_AsLong(obj);
2773 return SWIG_OK;
2774 }
2775 return SWIG_TypeError;
2776 }
2777
2778
2779 SWIGINTERN int
2780 SWIG_AsVal_int (PyObject * obj, int *val)
2781 {
2782 long v;
2783 int res = SWIG_AsVal_long (obj, &v);
2784 if (SWIG_IsOK(res)) {
2785 if ((v < INT_MIN || v > INT_MAX)) {
2786 return SWIG_OverflowError;
2787 } else {
2788 if (val) *val = static_cast< int >(v);
2789 }
2790 }
2791 return res;
2792 }
2793
2794 static const wxString wxPyWINDOW_DEFAULT_VARIANT(wxWINDOW_DEFAULT_VARIANT);
2795
2796 #include <wx/stockitem.h>
2797
2798 static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
2799 static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
2800 static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
2801
2802 SWIGINTERN int
2803 SWIG_AsVal_bool (PyObject *obj, bool *val)
2804 {
2805 if (obj == Py_True) {
2806 if (val) *val = true;
2807 return SWIG_OK;
2808 } else if (obj == Py_False) {
2809 if (val) *val = false;
2810 return SWIG_OK;
2811 } else {
2812 long v = 0;
2813 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
2814 if (SWIG_IsOK(res) && val) *val = v ? true : false;
2815 return res;
2816 }
2817 }
2818
2819
2820 SWIGINTERN int
2821 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
2822 {
2823 long v = 0;
2824 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2825 return SWIG_TypeError;
2826 }
2827 else if (val)
2828 *val = (unsigned long)v;
2829 return SWIG_OK;
2830 }
2831
2832
2833 SWIGINTERNINLINE PyObject*
2834 SWIG_From_unsigned_SS_long (unsigned long value)
2835 {
2836 return (value > LONG_MAX) ?
2837 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
2838 }
2839
2840
2841 void* wxGetXDisplay()
2842 {
2843 #ifdef __WXGTK__
2844 return wxGetDisplay();
2845 #else
2846 return NULL;
2847 #endif
2848 }
2849
2850
2851 wxWindow* FindWindowAtPointer() {
2852 wxPoint unused;
2853 return wxFindWindowAtPointer(unused);
2854 }
2855
2856
2857 bool wxThread_IsMain() {
2858 #ifdef WXP_WITH_THREAD
2859 return wxThread::IsMain();
2860 #else
2861 return true;
2862 #endif
2863 }
2864
2865 SWIGINTERN void wxCaret_Destroy(wxCaret *self){
2866 delete self;
2867 }
2868
2869 #include <wx/snglinst.h>
2870
2871
2872 #ifdef __WXMSW__
2873 #include <wx/msw/private.h>
2874 #include <wx/dynload.h>
2875 #endif
2876
2877
2878
2879 bool wxDrawWindowOnDC(wxWindow* window, const wxDC& dc
2880 #if 0
2881 , int method
2882 #endif
2883 )
2884 {
2885 #ifdef __WXMSW__
2886 #if 0
2887 switch (method)
2888 {
2889 case 1:
2890 // This one only partially works. Appears to be an undocumented
2891 // "standard" convention that not all widgets adhear to. For
2892 // example, for some widgets backgrounds or non-client areas may
2893 // not be painted.
2894 ::SendMessage(GetHwndOf(window), WM_PAINT, (long)GetHdcOf(dc), 0);
2895 break;
2896
2897 case 2:
2898 #endif
2899 // This one works much better, nearly all widgets and their
2900 // children are captured correctly[**]. Prior to the big
2901 // background erase changes that Vadim did in 2004-2005 this
2902 // method failed badly on XP with Themes activated, most native
2903 // widgets draw only partially, if at all. Without themes it
2904 // worked just like on Win2k. After those changes this method
2905 // works very well.
2906 //
2907 // ** For example the radio buttons in a wxRadioBox are not its
2908 // children by default, but you can capture it via the panel
2909 // instead, or change RADIOBTN_PARENT_IS_RADIOBOX in radiobox.cpp.
2910 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2911 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2912 PRF_ERASEBKGND | PRF_OWNED );
2913 return true;
2914 #if 0
2915 break;
2916
2917 case 3:
2918 // This one is only defined in the latest SDK and is only
2919 // available on XP. MSDN says it is similar to sending WM_PRINT
2920 // so I expect that it will work similar to the above. Since it
2921 // is avaialble only on XP, it can't be compiled like this and
2922 // will have to be loaded dynamically.
2923 // //::PrintWindow(GetHwndOf(window), GetHdcOf(dc), 0); //break;
2924
2925 // fall through
2926
2927 case 4:
2928 // Use PrintWindow if available, or fallback to WM_PRINT
2929 // otherwise. Unfortunately using PrintWindow is even worse than
2930 // WM_PRINT. For most native widgets nothing is drawn to the dc
2931 // at all, with or without Themes.
2932 typedef BOOL (WINAPI *PrintWindow_t)(HWND, HDC, UINT);
2933 static bool s_triedToLoad = false;
2934 static PrintWindow_t pfnPrintWindow = NULL;
2935 if ( !s_triedToLoad )
2936 {
2937
2938 s_triedToLoad = true;
2939 wxDynamicLibrary dllUser32(_T("user32.dll"));
2940 if ( dllUser32.IsLoaded() )
2941 {
2942 wxLogNull nolog; // Don't report errors here
2943 pfnPrintWindow = (PrintWindow_t)dllUser32.GetSymbol(_T("PrintWindow"));
2944 }
2945 }
2946 if (pfnPrintWindow)
2947 {
2948 //printf("Using PrintWindow\n");
2949 pfnPrintWindow(GetHwndOf(window), GetHdcOf(dc), 0);
2950 }
2951 else
2952 {
2953 //printf("Using WM_PRINT\n");
2954 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2955 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2956 PRF_ERASEBKGND | PRF_OWNED );
2957 }
2958 }
2959 #endif // 0
2960 #else
2961 return false;
2962 #endif // __WXMSW__
2963 }
2964
2965
2966
2967 #include <wx/tipdlg.h>
2968
2969
2970 SWIGINTERNINLINE PyObject *
2971 SWIG_From_size_t (size_t value)
2972 {
2973 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
2974 }
2975
2976
2977 class wxPyTipProvider : public wxTipProvider {
2978 public:
2979 wxPyTipProvider(size_t currentTip)
2980 : wxTipProvider(currentTip) {}
2981
2982 DEC_PYCALLBACK_STRING__pure(GetTip);
2983 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
2984 PYPRIVATE;
2985 };
2986
2987 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
2988 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
2989
2990
2991 SWIGINTERNINLINE int
2992 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
2993 {
2994 unsigned long v;
2995 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
2996 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
2997 return res;
2998 }
2999
3000
3001 IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
3002
3003 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
3004
3005 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
3006 : wxTimer(owner, id)
3007 {
3008 if (owner == NULL)
3009 SetOwner(this);
3010 }
3011
3012
3013 SWIGINTERN swig_type_info*
3014 SWIG_pchar_descriptor()
3015 {
3016 static int init = 0;
3017 static swig_type_info* info = 0;
3018 if (!init) {
3019 info = SWIG_TypeQuery("_p_char");
3020 init = 1;
3021 }
3022 return info;
3023 }
3024
3025
3026 SWIGINTERNINLINE PyObject *
3027 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3028 {
3029 if (carray) {
3030 if (size > INT_MAX) {
3031 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3032 return pchar_descriptor ?
3033 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3034 } else {
3035 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3036 }
3037 } else {
3038 return SWIG_Py_Void();
3039 }
3040 }
3041
3042
3043 SWIGINTERNINLINE PyObject *
3044 SWIG_FromCharPtr(const char *cptr)
3045 {
3046 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3047 }
3048
3049
3050 SWIGINTERN int
3051 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3052 {
3053 unsigned long v;
3054 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3055 if (SWIG_IsOK(res)) {
3056 if ((v > UINT_MAX)) {
3057 return SWIG_OverflowError;
3058 } else {
3059 if (val) *val = static_cast< unsigned int >(v);
3060 }
3061 }
3062 return res;
3063 }
3064
3065 SWIGINTERN wxString wxLog_TimeStamp(){
3066 wxString msg;
3067 wxLog::TimeStamp(&msg);
3068 return msg;
3069 }
3070 SWIGINTERN void wxLog_Destroy(wxLog *self){ delete self; }
3071 // Make some wrappers that double any % signs so they are 'escaped'
3072 void wxPyLogFatalError(const wxString& msg)
3073 {
3074 wxString m(msg);
3075 m.Replace(wxT("%"), wxT("%%"));
3076 wxLogFatalError(m);
3077 }
3078
3079 void wxPyLogError(const wxString& msg)
3080 {
3081 wxString m(msg);
3082 m.Replace(wxT("%"), wxT("%%"));
3083 wxLogError(m);
3084 }
3085
3086 void wxPyLogWarning(const wxString& msg)
3087 {
3088 wxString m(msg);
3089 m.Replace(wxT("%"), wxT("%%"));
3090 wxLogWarning(m);
3091 }
3092
3093 void wxPyLogMessage(const wxString& msg)
3094 {
3095 wxString m(msg);
3096 m.Replace(wxT("%"), wxT("%%"));
3097 wxLogMessage(m);
3098 }
3099
3100 void wxPyLogInfo(const wxString& msg)
3101 {
3102 wxString m(msg);
3103 m.Replace(wxT("%"), wxT("%%"));
3104 wxLogInfo(m);
3105 }
3106
3107 void wxPyLogDebug(const wxString& msg)
3108 {
3109 wxString m(msg);
3110 m.Replace(wxT("%"), wxT("%%"));
3111 wxLogDebug(m);
3112 }
3113
3114 void wxPyLogVerbose(const wxString& msg)
3115 {
3116 wxString m(msg);
3117 m.Replace(wxT("%"), wxT("%%"));
3118 wxLogVerbose(m);
3119 }
3120
3121 void wxPyLogStatus(const wxString& msg)
3122 {
3123 wxString m(msg);
3124 m.Replace(wxT("%"), wxT("%%"));
3125 wxLogStatus(m);
3126 }
3127
3128 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
3129 {
3130 wxString m(msg);
3131 m.Replace(wxT("%"), wxT("%%"));
3132 wxLogStatus(pFrame, m);
3133 }
3134
3135 void wxPyLogSysError(const wxString& msg)
3136 {
3137 wxString m(msg);
3138 m.Replace(wxT("%"), wxT("%%"));
3139 wxLogSysError(m);
3140 }
3141
3142 void wxPyLogGeneric(unsigned long level, const wxString& msg)
3143 {
3144 wxString m(msg);
3145 m.Replace(wxT("%"), wxT("%%"));
3146 wxLogGeneric(level, m);
3147 }
3148
3149 void wxPyLogTrace(unsigned long mask, const wxString& msg)
3150 {
3151 wxString m(msg);
3152 m.Replace(wxT("%"), wxT("%%"));
3153 wxLogTrace(mask, m);
3154 }
3155
3156 void wxPyLogTrace(const wxString& mask, const wxString& msg)
3157 {
3158 wxString m(msg);
3159 m.Replace(wxT("%"), wxT("%%"));
3160 wxLogTrace(mask, m);
3161 }
3162
3163
3164
3165 // A wxLog class that can be derived from in wxPython
3166 class wxPyLog : public wxLog {
3167 public:
3168 wxPyLog() : wxLog() {}
3169
3170 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
3171 bool found;
3172 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3173 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
3174 PyObject* s = wx2PyString(szString);
3175 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
3176 Py_DECREF(s);
3177 }
3178 wxPyEndBlockThreads(blocked);
3179 if (! found)
3180 wxLog::DoLog(level, szString, t);
3181 }
3182
3183 virtual void DoLogString(const wxChar *szString, time_t t) {
3184 bool found;
3185 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3186 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
3187 PyObject* s = wx2PyString(szString);
3188 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
3189 Py_DECREF(s);
3190 }
3191 wxPyEndBlockThreads(blocked);
3192 if (! found)
3193 wxLog::DoLogString(szString, t);
3194 }
3195
3196 DEC_PYCALLBACK_VOID_(Flush);
3197 PYPRIVATE;
3198 };
3199 IMP_PYCALLBACK_VOID_(wxPyLog, wxLog, Flush);
3200
3201
3202
3203
3204 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
3205
3206
3207 #include <wx/joystick.h>
3208
3209
3210 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
3211 // A C++ stub class for wxJoystick for platforms that don't have it.
3212 class wxJoystick : public wxObject {
3213 public:
3214 wxJoystick(int joystick = wxJOYSTICK1) {
3215 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3216 PyErr_SetString(PyExc_NotImplementedError,
3217 "wxJoystick is not available on this platform.");
3218 wxPyEndBlockThreads(blocked);
3219 }
3220 wxPoint GetPosition() { return wxPoint(-1,-1); }
3221 int GetZPosition() { return -1; }
3222 int GetButtonState() { return -1; }
3223 int GetPOVPosition() { return -1; }
3224 int GetPOVCTSPosition() { return -1; }
3225 int GetRudderPosition() { return -1; }
3226 int GetUPosition() { return -1; }
3227 int GetVPosition() { return -1; }
3228 int GetMovementThreshold() { return -1; }
3229 void SetMovementThreshold(int threshold) {}
3230
3231 bool IsOk(void) { return false; }
3232 int GetNumberJoysticks() { return -1; }
3233 int GetManufacturerId() { return -1; }
3234 int GetProductId() { return -1; }
3235 wxString GetProductName() { return wxEmptyString; }
3236 int GetXMin() { return -1; }
3237 int GetYMin() { return -1; }
3238 int GetZMin() { return -1; }
3239 int GetXMax() { return -1; }
3240 int GetYMax() { return -1; }
3241 int GetZMax() { return -1; }
3242 int GetNumberButtons() { return -1; }
3243 int GetNumberAxes() { return -1; }
3244 int GetMaxButtons() { return -1; }
3245 int GetMaxAxes() { return -1; }
3246 int GetPollingMin() { return -1; }
3247 int GetPollingMax() { return -1; }
3248 int GetRudderMin() { return -1; }
3249 int GetRudderMax() { return -1; }
3250 int GetUMin() { return -1; }
3251 int GetUMax() { return -1; }
3252 int GetVMin() { return -1; }
3253 int GetVMax() { return -1; }
3254
3255 bool HasRudder() { return false; }
3256 bool HasZ() { return false; }
3257 bool HasU() { return false; }
3258 bool HasV() { return false; }
3259 bool HasPOV() { return false; }
3260 bool HasPOV4Dir() { return false; }
3261 bool HasPOVCTS() { return false; }
3262
3263 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
3264 bool ReleaseCapture() { return false; }
3265 };
3266 #endif
3267
3268
3269 #include <wx/sound.h>
3270
3271
3272 #if !wxUSE_SOUND
3273 // A C++ stub class for wxWave for platforms that don't have it.
3274 class wxSound : public wxObject
3275 {
3276 public:
3277 wxSound() {
3278 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3279 PyErr_SetString(PyExc_NotImplementedError,
3280 "wxSound is not available on this platform.");
3281 wxPyEndBlockThreads(blocked);
3282 }
3283 wxSound(const wxString&/*, bool*/) {
3284 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3285 PyErr_SetString(PyExc_NotImplementedError,
3286 "wxSound is not available on this platform.");
3287 wxPyEndBlockThreads(blocked);
3288 }
3289 wxSound(int, const wxByte*) {
3290 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3291 PyErr_SetString(PyExc_NotImplementedError,
3292 "wxSound is not available on this platform.");
3293 wxPyEndBlockThreads(blocked);
3294 }
3295
3296 ~wxSound() {};
3297
3298 bool Create(const wxString&/*, bool*/) { return false; }
3299 bool Create(int, const wxByte*) { return false; };
3300 bool IsOk() { return false; };
3301 bool Play(unsigned) const { return false; }
3302 static bool Play(const wxString&, unsigned) { return false; }
3303 static void Stop() {}
3304 };
3305
3306 #endif
3307
3308 SWIGINTERN wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
3309 if (fileName.Length() == 0)
3310 return new wxSound;
3311 else
3312 return new wxSound(fileName);
3313 }
3314 SWIGINTERN wxSound *new_wxSound(PyObject *data){
3315 unsigned char* buffer; int size;
3316 wxSound *sound = NULL;
3317
3318 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3319 if (!PyArg_Parse(data, "t#", &buffer, &size))
3320 goto done;
3321 sound = new wxSound(size, buffer);
3322 done:
3323 wxPyEndBlockThreads(blocked);
3324 return sound;
3325 }
3326 SWIGINTERN bool wxSound_CreateFromData(wxSound *self,PyObject *data){
3327 #ifndef __WXMAC__
3328 unsigned char* buffer;
3329 int size;
3330 bool rv = false;
3331
3332 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3333 if (!PyArg_Parse(data, "t#", &buffer, &size))
3334 goto done;
3335 rv = self->Create(size, buffer);
3336 done:
3337 wxPyEndBlockThreads(blocked);
3338 return rv;
3339 #else
3340 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3341 PyErr_SetString(PyExc_NotImplementedError,
3342 "Create from data is not available on this platform.");
3343 wxPyEndBlockThreads(blocked);
3344 return false;
3345 #endif
3346 }
3347
3348 #include <wx/mimetype.h>
3349
3350 SWIGINTERN PyObject *wxFileType_GetMimeType(wxFileType *self){
3351 wxString str;
3352 if (self->GetMimeType(&str))
3353 return wx2PyString(str);
3354 else
3355 RETURN_NONE();
3356 }
3357 SWIGINTERN PyObject *wxFileType_GetMimeTypes(wxFileType *self){
3358 wxArrayString arr;
3359 if (self->GetMimeTypes(arr))
3360 return wxArrayString2PyList_helper(arr);
3361 else
3362 RETURN_NONE();
3363 }
3364 SWIGINTERN PyObject *wxFileType_GetExtensions(wxFileType *self){
3365 wxArrayString arr;
3366 if (self->GetExtensions(arr))
3367 return wxArrayString2PyList_helper(arr);
3368 else
3369 RETURN_NONE();
3370 }
3371 SWIGINTERN wxIcon *wxFileType_GetIcon(wxFileType *self){
3372 wxIconLocation loc;
3373 if (self->GetIcon(&loc))
3374 return new wxIcon(loc);
3375 else
3376 return NULL;
3377 }
3378 SWIGINTERN PyObject *wxFileType_GetIconInfo(wxFileType *self){
3379 wxIconLocation loc;
3380 if (self->GetIcon(&loc)) {
3381 wxString iconFile = loc.GetFileName();
3382 int iconIndex = -1;
3383
3384 iconIndex = loc.GetIndex();
3385
3386 // Make a tuple and put the values in it
3387 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3388 PyObject* tuple = PyTuple_New(3);
3389 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
3390 wxT("wxIcon"), true));
3391 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
3392 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
3393 wxPyEndBlockThreads(blocked);
3394 return tuple;
3395 }
3396 else
3397 RETURN_NONE();
3398 }
3399 SWIGINTERN PyObject *wxFileType_GetDescription(wxFileType *self){
3400 wxString str;
3401 if (self->GetDescription(&str))
3402 return wx2PyString(str);
3403 else
3404 RETURN_NONE();
3405 }
3406 SWIGINTERN PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3407 wxString str;
3408 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3409 return wx2PyString(str);
3410 else
3411 RETURN_NONE();
3412 }
3413 SWIGINTERN PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3414 wxString str;
3415 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3416 return wx2PyString(str);
3417 else
3418 RETURN_NONE();
3419 }
3420 SWIGINTERN PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3421 wxArrayString verbs;
3422 wxArrayString commands;
3423 if (self->GetAllCommands(&verbs, &commands,
3424 wxFileType::MessageParameters(filename, mimetype))) {
3425 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3426 PyObject* tuple = PyTuple_New(2);
3427 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
3428 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
3429 wxPyEndBlockThreads(blocked);
3430 return tuple;
3431 }
3432 else
3433 RETURN_NONE();
3434 }
3435 SWIGINTERN wxString wxFileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3436 return wxFileType::ExpandCommand(command,
3437 wxFileType::MessageParameters(filename, mimetype));
3438 }
3439 SWIGINTERN PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
3440 wxArrayString arr;
3441 self->EnumAllFileTypes(arr);
3442 return wxArrayString2PyList_helper(arr);
3443 }
3444
3445 #include <wx/artprov.h>
3446
3447 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
3448 static const wxString wxPyART_MENU(wxART_MENU);
3449 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
3450 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
3451 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
3452 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
3453 static const wxString wxPyART_BUTTON(wxART_BUTTON);
3454 static const wxString wxPyART_OTHER(wxART_OTHER);
3455 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
3456 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
3457 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
3458 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
3459 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
3460 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
3461 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
3462 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
3463 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
3464 static const wxString wxPyART_GO_UP(wxART_GO_UP);
3465 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
3466 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
3467 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
3468 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
3469 static const wxString wxPyART_FILE_SAVE(wxART_FILE_SAVE);
3470 static const wxString wxPyART_FILE_SAVE_AS(wxART_FILE_SAVE_AS);
3471 static const wxString wxPyART_PRINT(wxART_PRINT);
3472 static const wxString wxPyART_HELP(wxART_HELP);
3473 static const wxString wxPyART_TIP(wxART_TIP);
3474 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
3475 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
3476 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
3477 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
3478 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
3479 static const wxString wxPyART_CDROM(wxART_CDROM);
3480 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
3481 static const wxString wxPyART_FOLDER(wxART_FOLDER);
3482 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
3483 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
3484 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
3485 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
3486 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
3487 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
3488 static const wxString wxPyART_ERROR(wxART_ERROR);
3489 static const wxString wxPyART_QUESTION(wxART_QUESTION);
3490 static const wxString wxPyART_WARNING(wxART_WARNING);
3491 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
3492 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
3493 static const wxString wxPyART_COPY(wxART_COPY);
3494 static const wxString wxPyART_CUT(wxART_CUT);
3495 static const wxString wxPyART_PASTE(wxART_PASTE);
3496 static const wxString wxPyART_DELETE(wxART_DELETE);
3497 static const wxString wxPyART_NEW(wxART_NEW);
3498 static const wxString wxPyART_UNDO(wxART_UNDO);
3499 static const wxString wxPyART_REDO(wxART_REDO);
3500 static const wxString wxPyART_QUIT(wxART_QUIT);
3501 static const wxString wxPyART_FIND(wxART_FIND);
3502 static const wxString wxPyART_FIND_AND_REPLACE(wxART_FIND_AND_REPLACE);
3503 // Python aware wxArtProvider
3504 class wxPyArtProvider : public wxArtProvider {
3505 public:
3506
3507 virtual wxBitmap CreateBitmap(const wxArtID& id,
3508 const wxArtClient& client,
3509 const wxSize& size) {
3510 wxBitmap rval = wxNullBitmap;
3511 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3512 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
3513 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
3514 PyObject* ro;
3515 wxBitmap* ptr;
3516 PyObject* s1, *s2;
3517 s1 = wx2PyString(id);
3518 s2 = wx2PyString(client);
3519 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
3520 Py_DECREF(so);
3521 Py_DECREF(s1);
3522 Py_DECREF(s2);
3523 if (ro) {
3524 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
3525 rval = *ptr;
3526 Py_DECREF(ro);
3527 }
3528 }
3529 wxPyEndBlockThreads(blocked);
3530 return rval;
3531 }
3532
3533 PYPRIVATE;
3534 };
3535
3536 SWIGINTERN void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
3537
3538
3539
3540 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
3541 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3542 PyObject* ret = PyTuple_New(3);
3543 if (ret) {
3544 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
3545 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
3546 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
3547 }
3548 wxPyEndBlockThreads(blocked);
3549 return ret;
3550 }
3551
3552 SWIGINTERN PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
3553 bool cont;
3554 long index = 0;
3555 wxString value;
3556
3557 cont = self->GetFirstGroup(value, index);
3558 return __EnumerationHelper(cont, value, index);
3559 }
3560 SWIGINTERN PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
3561 bool cont;
3562 wxString value;
3563
3564 cont = self->GetNextGroup(value, index);
3565 return __EnumerationHelper(cont, value, index);
3566 }
3567 SWIGINTERN PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
3568 bool cont;
3569 long index = 0;
3570 wxString value;
3571
3572 cont = self->GetFirstEntry(value, index);
3573 return __EnumerationHelper(cont, value, index);
3574 }
3575 SWIGINTERN PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
3576 bool cont;
3577 wxString value;
3578
3579 cont = self->GetNextEntry(value, index);
3580 return __EnumerationHelper(cont, value, index);
3581 }
3582 SWIGINTERN long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
3583 long rv;
3584 self->Read(key, &rv, defaultVal);
3585 return rv;
3586 }
3587
3588 SWIGINTERN int
3589 SWIG_AsVal_double (PyObject *obj, double* val)
3590 {
3591 if (PyNumber_Check(obj)) {
3592 if (val) *val = PyFloat_AsDouble(obj);
3593 return SWIG_OK;
3594 }
3595 return SWIG_TypeError;
3596 }
3597
3598 SWIGINTERN double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
3599 double rv;
3600 self->Read(key, &rv, defaultVal);
3601 return rv;
3602 }
3603
3604 #define SWIG_From_double PyFloat_FromDouble
3605
3606 SWIGINTERN bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
3607 bool rv;
3608 self->Read(key, &rv, defaultVal);
3609 return rv;
3610 }
3611
3612 #include <wx/datetime.h>
3613
3614 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
3615 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
3616
3617 #define LOCAL_TZ wxDateTime::Local
3618
3619 SWIGINTERN PyObject *wxDateTime_GetAmPmStrings(){
3620 wxString am;
3621 wxString pm;
3622 wxDateTime::GetAmPmStrings(&am, &pm);
3623 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3624 PyObject* tup = PyTuple_New(2);
3625 PyTuple_SET_ITEM(tup, 0, wx2PyString(am));
3626 PyTuple_SET_ITEM(tup, 1, wx2PyString(pm));
3627 wxPyEndBlockThreads(blocked);
3628 return tup;
3629 }
3630
3631 SWIGINTERNINLINE PyObject *
3632 SWIG_From_unsigned_SS_int (unsigned int value)
3633 {
3634 return SWIG_From_unsigned_SS_long (value);
3635 }
3636
3637 SWIGINTERN wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
3638 SWIGINTERN wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
3639 SWIGINTERN wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
3640 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
3641 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
3642 SWIGINTERN bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
3643 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
3644 return (*self < *other);
3645 }
3646 SWIGINTERN bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
3647 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
3648 return (*self <= *other);
3649 }
3650 SWIGINTERN bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
3651 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
3652 return (*self > *other);
3653 }
3654 SWIGINTERN bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
3655 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
3656 return (*self >= *other);
3657 }
3658 SWIGINTERN bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
3659 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
3660 return (*self == *other);
3661 }
3662 SWIGINTERN bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
3663 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
3664 return (*self != *other);
3665 }
3666 SWIGINTERN int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
3667 const wxChar* rv;
3668 const wxChar* _date = date;
3669 rv = self->ParseRfc822Date(_date);
3670 if (rv == NULL) return -1;
3671 return rv - _date;
3672 }
3673 SWIGINTERN int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
3674 const wxChar* rv;
3675 const wxChar* _date = date;
3676 rv = self->ParseFormat(_date, format, dateDef);
3677 if (rv == NULL) return -1;
3678 return rv - _date;
3679 }
3680 SWIGINTERN int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
3681 const wxChar* rv;
3682 const wxChar* _datetime = datetime;
3683 rv = self->ParseDateTime(_datetime);
3684 if (rv == NULL) return -1;
3685 return rv - _datetime;
3686 }
3687 SWIGINTERN int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
3688 const wxChar* rv;
3689 const wxChar* _date = date;
3690 rv = self->ParseDate(_date);
3691 if (rv == NULL) return -1;
3692 return rv - _date;
3693 }
3694 SWIGINTERN int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
3695 const wxChar* rv;
3696 const wxChar* _time = time;
3697 rv = self->ParseTime(_time);
3698 if (rv == NULL) return -1;
3699 return rv - _time;
3700 }
3701 SWIGINTERN wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
3702 SWIGINTERN wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
3703 SWIGINTERN wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
3704 SWIGINTERN wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
3705 SWIGINTERN bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
3706 SWIGINTERN bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
3707 SWIGINTERN bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
3708 SWIGINTERN bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
3709 SWIGINTERN bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
3710 SWIGINTERN bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
3711 SWIGINTERN wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
3712 SWIGINTERN wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
3713 SWIGINTERN wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
3714 SWIGINTERN wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
3715 SWIGINTERN bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
3716 SWIGINTERN bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
3717
3718 #include <wx/dataobj.h>
3719
3720 SWIGINTERN PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
3721 size_t count = self->GetFormatCount(dir);
3722 wxDataFormat* formats = new wxDataFormat[count];
3723 self->GetAllFormats(formats, dir);
3724
3725 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3726 PyObject* list = PyList_New(count);
3727 for (size_t i=0; i<count; i++) {
3728 wxDataFormat* format = new wxDataFormat(formats[i]);
3729 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
3730 PyList_SET_ITEM(list, i, obj); // PyList_SET_ITEM steals a reference
3731 }
3732 wxPyEndBlockThreads(blocked);
3733 delete [] formats;
3734 return list;
3735 }
3736 SWIGINTERN PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
3737 PyObject* rval = NULL;
3738 size_t size = self->GetDataSize(format);
3739 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3740 if (size) {
3741 char* buf = new char[size];
3742 if (self->GetDataHere(format, buf))
3743 rval = PyString_FromStringAndSize(buf, size);
3744 delete [] buf;
3745 }
3746 if (! rval) {
3747 rval = Py_None;
3748 Py_INCREF(rval);
3749 }
3750 wxPyEndBlockThreads(blocked);
3751 return rval;
3752 }
3753 SWIGINTERN bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
3754 bool rval;
3755 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3756 if (PyString_Check(data)) {
3757 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
3758 }
3759 else {
3760 // raise a TypeError if not a string
3761 PyErr_SetString(PyExc_TypeError, "String expected.");
3762 rval = false;
3763 }
3764 wxPyEndBlockThreads(blocked);
3765 return rval;
3766 }
3767 SWIGINTERN PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
3768 PyObject* rval = NULL;
3769 size_t size = self->GetDataSize();
3770 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3771 if (size) {
3772 char* buf = new char[size];
3773 if (self->GetDataHere(buf))
3774 rval = PyString_FromStringAndSize(buf, size);
3775 delete [] buf;
3776 }
3777 if (! rval) {
3778 rval = Py_None;
3779 Py_INCREF(rval);
3780 }
3781 wxPyEndBlockThreads(blocked);
3782 return rval;
3783 }
3784 SWIGINTERN bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
3785 bool rval;
3786 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3787 if (PyString_Check(data)) {
3788 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3789 }
3790 else {
3791 // raise a TypeError if not a string
3792 PyErr_SetString(PyExc_TypeError, "String expected.");
3793 rval = false;
3794 }
3795 wxPyEndBlockThreads(blocked);
3796 return rval;
3797 }
3798 // Create a new class for wxPython to use
3799 class wxPyDataObjectSimple : public wxDataObjectSimple {
3800 public:
3801 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
3802 : wxDataObjectSimple(format) {}
3803
3804 DEC_PYCALLBACK_SIZET__const(GetDataSize);
3805 bool GetDataHere(void *buf) const;
3806 bool SetData(size_t len, const void *buf);
3807 PYPRIVATE;
3808 };
3809
3810 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
3811
3812 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
3813 // We need to get the data for this object and write it to buf. I think
3814 // the best way to do this for wxPython is to have the Python method
3815 // return either a string or None and then act appropriately with the
3816 // C++ version.
3817
3818 bool rval = false;
3819 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3820 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
3821 PyObject* ro;
3822 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3823 if (ro) {
3824 rval = (ro != Py_None && PyString_Check(ro));
3825 if (rval)
3826 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
3827 Py_DECREF(ro);
3828 }
3829 }
3830 wxPyEndBlockThreads(blocked);
3831 return rval;
3832 }
3833
3834 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) {
3835 // For this one we simply need to make a string from buf and len
3836 // and send it to the Python method.
3837 bool rval = false;
3838 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3839 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
3840 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
3841 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
3842 Py_DECREF(data);
3843 }
3844 wxPyEndBlockThreads(blocked);
3845 return rval;
3846 }
3847
3848 // Create a new class for wxPython to use
3849 class wxPyTextDataObject : public wxTextDataObject {
3850 public:
3851 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
3852 : wxTextDataObject(text) {}
3853
3854 DEC_PYCALLBACK_SIZET__const(GetTextLength);
3855 DEC_PYCALLBACK_STRING__const(GetText);
3856 DEC_PYCALLBACK__STRING(SetText);
3857 PYPRIVATE;
3858 };
3859
3860 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
3861 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
3862 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
3863
3864
3865 // Create a new class for wxPython to use
3866 class wxPyBitmapDataObject : public wxBitmapDataObject {
3867 public:
3868 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
3869 : wxBitmapDataObject(bitmap) {}
3870
3871 wxBitmap GetBitmap() const;
3872 void SetBitmap(const wxBitmap& bitmap);
3873 PYPRIVATE;
3874 };
3875
3876 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
3877 wxBitmap* rval = &wxNullBitmap;
3878 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3879 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
3880 PyObject* ro;
3881 wxBitmap* ptr;
3882 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3883 if (ro) {
3884 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
3885 rval = ptr;
3886 Py_DECREF(ro);
3887 }
3888 }
3889 wxPyEndBlockThreads(blocked);
3890 return *rval;
3891 }
3892
3893 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
3894 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3895 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
3896 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
3897 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
3898 Py_DECREF(bo);
3899 }
3900 wxPyEndBlockThreads(blocked);
3901 }
3902
3903 SWIGINTERN wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
3904 return new wxCustomDataObject(wxDataFormat(formatName));
3905 }
3906 SWIGINTERN bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
3907 bool rval;
3908 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3909 if (PyString_Check(data)) {
3910 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3911 }
3912 else {
3913 // raise a TypeError if not a string
3914 PyErr_SetString(PyExc_TypeError, "String expected.");
3915 rval = false;
3916 }
3917 wxPyEndBlockThreads(blocked);
3918 return rval;
3919 }
3920 SWIGINTERN PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
3921 PyObject* obj;
3922 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3923 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
3924 wxPyEndBlockThreads(blocked);
3925 return obj;
3926 }
3927
3928 #include <wx/metafile.h>
3929
3930
3931 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
3932
3933
3934 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
3935 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
3936 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
3937 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
3938 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
3939
3940
3941 class wxPyTextDropTarget : public wxTextDropTarget {
3942 public:
3943 wxPyTextDropTarget() {}
3944
3945 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
3946
3947 DEC_PYCALLBACK__(OnLeave);
3948 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3949 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3950 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3951 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3952
3953 PYPRIVATE;
3954 };
3955
3956 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
3957 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
3958 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
3959 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
3960 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
3961 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
3962
3963
3964
3965 class wxPyFileDropTarget : public wxFileDropTarget {
3966 public:
3967 wxPyFileDropTarget() {}
3968
3969 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
3970
3971 DEC_PYCALLBACK__(OnLeave);
3972 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3973 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3974 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3975 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3976
3977 PYPRIVATE;
3978 };
3979
3980 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
3981 const wxArrayString& filenames) {
3982 bool rval = false;
3983 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3984 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
3985 PyObject* list = wxArrayString2PyList_helper(filenames);
3986 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
3987 Py_DECREF(list);
3988 }
3989 wxPyEndBlockThreads(blocked);
3990 return rval;
3991 }
3992
3993
3994
3995 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
3996 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
3997 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
3998 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
3999 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
4000
4001
4002
4003
4004 SWIGINTERN bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
4005
4006 #include <wx/display.h>
4007
4008 SWIGINTERN bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
4009 SWIGINTERN bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
4010
4011 #if !wxUSE_DISPLAY
4012 const wxVideoMode wxDefaultVideoMode;
4013 #endif
4014
4015 SWIGINTERN PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4016 #if wxUSE_DISPLAY
4017 PyObject* pyList = NULL;
4018 wxArrayVideoModes arr = self->GetModes(mode);
4019 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4020 pyList = PyList_New(0);
4021 for (size_t i=0; i < arr.GetCount(); i++)
4022 {
4023 wxVideoMode* m = new wxVideoMode(arr.Item(i));
4024 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
4025 PyList_Append(pyList, pyObj);
4026 Py_DECREF(pyObj);
4027 }
4028 wxPyEndBlockThreads(blocked);
4029 return pyList;
4030 #else
4031 wxPyRaiseNotImplemented();
4032 return NULL;
4033 #endif
4034 }
4035 SWIGINTERN wxVideoMode wxDisplay_GetCurrentMode(wxDisplay const *self){
4036 #if wxUSE_DISPLAY
4037 return self->GetCurrentMode();
4038 #else
4039 wxPyRaiseNotImplemented();
4040 return wxDefaultVideoMode;
4041 #endif
4042 }
4043 SWIGINTERN bool wxDisplay_ChangeMode(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4044 #if wxUSE_DISPLAY
4045 return self->ChangeMode(mode);
4046 #else
4047 wxPyRaiseNotImplemented();
4048 return false;
4049 #endif
4050 }
4051 SWIGINTERN void wxDisplay_ResetMode(wxDisplay *self){
4052 #if wxUSE_DISPLAY
4053 self->ResetMode();
4054 #else
4055 wxPyRaiseNotImplemented();
4056 #endif
4057 }
4058
4059 #include <wx/stdpaths.h>
4060
4061 SWIGINTERN wxStandardPaths *wxStandardPaths_Get(){
4062 return (wxStandardPaths*) &wxStandardPaths::Get();
4063 }
4064 SWIGINTERN void wxStandardPaths_SetInstallPrefix(wxStandardPaths *self,wxString const &prefix){}
4065 SWIGINTERN wxString wxStandardPaths_GetInstallPrefix(wxStandardPaths *self){ return wxEmptyString; }
4066
4067 #ifndef wxHAS_POWER_EVENTS
4068 // Dummy class and other definitions for platforms that don't have them
4069
4070 // See wxPython_int.h for wxPowerEvent
4071
4072 enum {
4073 wxEVT_POWER_SUSPENDING,
4074 wxEVT_POWER_SUSPENDED,
4075 wxEVT_POWER_SUSPEND_CANCEL,
4076 wxEVT_POWER_RESUME,
4077 };
4078
4079 wxPowerType wxGetPowerType() { return wxPOWER_UNKNOWN; }
4080 wxBatteryState wxGetBatteryState() { return wxBATTERY_UNKNOWN_STATE; }
4081
4082 #endif
4083
4084 #ifdef __cplusplus
4085 extern "C" {
4086 #endif
4087 SWIGINTERN PyObject *_wrap_SystemSettings_GetColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4088 PyObject *resultobj = 0;
4089 wxSystemColour arg1 ;
4090 wxColour result;
4091 int val1 ;
4092 int ecode1 = 0 ;
4093 PyObject * obj0 = 0 ;
4094 char * kwnames[] = {
4095 (char *) "index", NULL
4096 };
4097
4098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) SWIG_fail;
4099 ecode1 = SWIG_AsVal_int(obj0, &val1);
4100 if (!SWIG_IsOK(ecode1)) {
4101 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetColour" "', expected argument " "1"" of type '" "wxSystemColour""'");
4102 }
4103 arg1 = static_cast< wxSystemColour >(val1);
4104 {
4105 if (!wxPyCheckForApp()) SWIG_fail;
4106 PyThreadState* __tstate = wxPyBeginAllowThreads();
4107 result = wxSystemSettings::GetColour(arg1);
4108 wxPyEndAllowThreads(__tstate);
4109 if (PyErr_Occurred()) SWIG_fail;
4110 }
4111 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
4112 return resultobj;
4113 fail:
4114 return NULL;
4115 }
4116
4117
4118 SWIGINTERN PyObject *_wrap_SystemSettings_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4119 PyObject *resultobj = 0;
4120 wxSystemFont arg1 ;
4121 wxFont result;
4122 int val1 ;
4123 int ecode1 = 0 ;
4124 PyObject * obj0 = 0 ;
4125 char * kwnames[] = {
4126 (char *) "index", NULL
4127 };
4128
4129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) SWIG_fail;
4130 ecode1 = SWIG_AsVal_int(obj0, &val1);
4131 if (!SWIG_IsOK(ecode1)) {
4132 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetFont" "', expected argument " "1"" of type '" "wxSystemFont""'");
4133 }
4134 arg1 = static_cast< wxSystemFont >(val1);
4135 {
4136 if (!wxPyCheckForApp()) SWIG_fail;
4137 PyThreadState* __tstate = wxPyBeginAllowThreads();
4138 result = wxSystemSettings::GetFont(arg1);
4139 wxPyEndAllowThreads(__tstate);
4140 if (PyErr_Occurred()) SWIG_fail;
4141 }
4142 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
4143 return resultobj;
4144 fail:
4145 return NULL;
4146 }
4147
4148
4149 SWIGINTERN PyObject *_wrap_SystemSettings_GetMetric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4150 PyObject *resultobj = 0;
4151 wxSystemMetric arg1 ;
4152 wxWindow *arg2 = (wxWindow *) NULL ;
4153 int result;
4154 int val1 ;
4155 int ecode1 = 0 ;
4156 void *argp2 = 0 ;
4157 int res2 = 0 ;
4158 PyObject * obj0 = 0 ;
4159 PyObject * obj1 = 0 ;
4160 char * kwnames[] = {
4161 (char *) "index",(char *) "win", NULL
4162 };
4163
4164 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SystemSettings_GetMetric",kwnames,&obj0,&obj1)) SWIG_fail;
4165 ecode1 = SWIG_AsVal_int(obj0, &val1);
4166 if (!SWIG_IsOK(ecode1)) {
4167 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetMetric" "', expected argument " "1"" of type '" "wxSystemMetric""'");
4168 }
4169 arg1 = static_cast< wxSystemMetric >(val1);
4170 if (obj1) {
4171 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
4172 if (!SWIG_IsOK(res2)) {
4173 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SystemSettings_GetMetric" "', expected argument " "2"" of type '" "wxWindow *""'");
4174 }
4175 arg2 = reinterpret_cast< wxWindow * >(argp2);
4176 }
4177 {
4178 if (!wxPyCheckForApp()) SWIG_fail;
4179 PyThreadState* __tstate = wxPyBeginAllowThreads();
4180 result = (int)wxSystemSettings::GetMetric(arg1,arg2);
4181 wxPyEndAllowThreads(__tstate);
4182 if (PyErr_Occurred()) SWIG_fail;
4183 }
4184 resultobj = SWIG_From_int(static_cast< int >(result));
4185 return resultobj;
4186 fail:
4187 return NULL;
4188 }
4189
4190
4191 SWIGINTERN PyObject *_wrap_SystemSettings_HasFeature(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4192 PyObject *resultobj = 0;
4193 wxSystemFeature arg1 ;
4194 bool result;
4195 int val1 ;
4196 int ecode1 = 0 ;
4197 PyObject * obj0 = 0 ;
4198 char * kwnames[] = {
4199 (char *) "index", NULL
4200 };
4201
4202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) SWIG_fail;
4203 ecode1 = SWIG_AsVal_int(obj0, &val1);
4204 if (!SWIG_IsOK(ecode1)) {
4205 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_HasFeature" "', expected argument " "1"" of type '" "wxSystemFeature""'");
4206 }
4207 arg1 = static_cast< wxSystemFeature >(val1);
4208 {
4209 if (!wxPyCheckForApp()) SWIG_fail;
4210 PyThreadState* __tstate = wxPyBeginAllowThreads();
4211 result = (bool)wxSystemSettings::HasFeature(arg1);
4212 wxPyEndAllowThreads(__tstate);
4213 if (PyErr_Occurred()) SWIG_fail;
4214 }
4215 {
4216 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4217 }
4218 return resultobj;
4219 fail:
4220 return NULL;
4221 }
4222
4223
4224 SWIGINTERN PyObject *_wrap_SystemSettings_GetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4225 PyObject *resultobj = 0;
4226 wxSystemScreenType result;
4227
4228 if (!SWIG_Python_UnpackTuple(args,"SystemSettings_GetScreenType",0,0,0)) SWIG_fail;
4229 {
4230 if (!wxPyCheckForApp()) SWIG_fail;
4231 PyThreadState* __tstate = wxPyBeginAllowThreads();
4232 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
4233 wxPyEndAllowThreads(__tstate);
4234 if (PyErr_Occurred()) SWIG_fail;
4235 }
4236 resultobj = SWIG_From_int(static_cast< int >(result));
4237 return resultobj;
4238 fail:
4239 return NULL;
4240 }
4241
4242
4243 SWIGINTERN PyObject *_wrap_SystemSettings_SetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4244 PyObject *resultobj = 0;
4245 wxSystemScreenType arg1 ;
4246 int val1 ;
4247 int ecode1 = 0 ;
4248 PyObject * obj0 = 0 ;
4249 char * kwnames[] = {
4250 (char *) "screen", NULL
4251 };
4252
4253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) SWIG_fail;
4254 ecode1 = SWIG_AsVal_int(obj0, &val1);
4255 if (!SWIG_IsOK(ecode1)) {
4256 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_SetScreenType" "', expected argument " "1"" of type '" "wxSystemScreenType""'");
4257 }
4258 arg1 = static_cast< wxSystemScreenType >(val1);
4259 {
4260 if (!wxPyCheckForApp()) SWIG_fail;
4261 PyThreadState* __tstate = wxPyBeginAllowThreads();
4262 wxSystemSettings::SetScreenType(arg1);
4263 wxPyEndAllowThreads(__tstate);
4264 if (PyErr_Occurred()) SWIG_fail;
4265 }
4266 resultobj = SWIG_Py_Void();
4267 return resultobj;
4268 fail:
4269 return NULL;
4270 }
4271
4272
4273 SWIGINTERN PyObject *SystemSettings_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4274 PyObject *obj;
4275 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4276 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemSettings, SWIG_NewClientData(obj));
4277 return SWIG_Py_Void();
4278 }
4279
4280 SWIGINTERN int WINDOW_DEFAULT_VARIANT_set(PyObject *) {
4281 SWIG_Error(SWIG_AttributeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
4282 return 1;
4283 }
4284
4285
4286 SWIGINTERN PyObject *WINDOW_DEFAULT_VARIANT_get(void) {
4287 PyObject *pyobj = 0;
4288
4289 {
4290 #if wxUSE_UNICODE
4291 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4292 #else
4293 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4294 #endif
4295 }
4296 return pyobj;
4297 }
4298
4299
4300 SWIGINTERN PyObject *_wrap_new_SystemOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4301 PyObject *resultobj = 0;
4302 wxSystemOptions *result = 0 ;
4303
4304 if (!SWIG_Python_UnpackTuple(args,"new_SystemOptions",0,0,0)) SWIG_fail;
4305 {
4306 PyThreadState* __tstate = wxPyBeginAllowThreads();
4307 result = (wxSystemOptions *)new wxSystemOptions();
4308 wxPyEndAllowThreads(__tstate);
4309 if (PyErr_Occurred()) SWIG_fail;
4310 }
4311 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSystemOptions, SWIG_POINTER_NEW | 0 );
4312 return resultobj;
4313 fail:
4314 return NULL;
4315 }
4316
4317
4318 SWIGINTERN PyObject *_wrap_SystemOptions_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4319 PyObject *resultobj = 0;
4320 wxString *arg1 = 0 ;
4321 wxString *arg2 = 0 ;
4322 bool temp1 = false ;
4323 bool temp2 = false ;
4324 PyObject * obj0 = 0 ;
4325 PyObject * obj1 = 0 ;
4326 char * kwnames[] = {
4327 (char *) "name",(char *) "value", NULL
4328 };
4329
4330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) SWIG_fail;
4331 {
4332 arg1 = wxString_in_helper(obj0);
4333 if (arg1 == NULL) SWIG_fail;
4334 temp1 = true;
4335 }
4336 {
4337 arg2 = wxString_in_helper(obj1);
4338 if (arg2 == NULL) SWIG_fail;
4339 temp2 = true;
4340 }
4341 {
4342 PyThreadState* __tstate = wxPyBeginAllowThreads();
4343 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
4344 wxPyEndAllowThreads(__tstate);
4345 if (PyErr_Occurred()) SWIG_fail;
4346 }
4347 resultobj = SWIG_Py_Void();
4348 {
4349 if (temp1)
4350 delete arg1;
4351 }
4352 {
4353 if (temp2)
4354 delete arg2;
4355 }
4356 return resultobj;
4357 fail:
4358 {
4359 if (temp1)
4360 delete arg1;
4361 }
4362 {
4363 if (temp2)
4364 delete arg2;
4365 }
4366 return NULL;
4367 }
4368
4369
4370 SWIGINTERN PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4371 PyObject *resultobj = 0;
4372 wxString *arg1 = 0 ;
4373 int arg2 ;
4374 bool temp1 = false ;
4375 int val2 ;
4376 int ecode2 = 0 ;
4377 PyObject * obj0 = 0 ;
4378 PyObject * obj1 = 0 ;
4379 char * kwnames[] = {
4380 (char *) "name",(char *) "value", NULL
4381 };
4382
4383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
4384 {
4385 arg1 = wxString_in_helper(obj0);
4386 if (arg1 == NULL) SWIG_fail;
4387 temp1 = true;
4388 }
4389 ecode2 = SWIG_AsVal_int(obj1, &val2);
4390 if (!SWIG_IsOK(ecode2)) {
4391 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SystemOptions_SetOptionInt" "', expected argument " "2"" of type '" "int""'");
4392 }
4393 arg2 = static_cast< int >(val2);
4394 {
4395 PyThreadState* __tstate = wxPyBeginAllowThreads();
4396 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
4397 wxPyEndAllowThreads(__tstate);
4398 if (PyErr_Occurred()) SWIG_fail;
4399 }
4400 resultobj = SWIG_Py_Void();
4401 {
4402 if (temp1)
4403 delete arg1;
4404 }
4405 return resultobj;
4406 fail:
4407 {
4408 if (temp1)
4409 delete arg1;
4410 }
4411 return NULL;
4412 }
4413
4414
4415 SWIGINTERN PyObject *_wrap_SystemOptions_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4416 PyObject *resultobj = 0;
4417 wxString *arg1 = 0 ;
4418 wxString result;
4419 bool temp1 = false ;
4420 PyObject * obj0 = 0 ;
4421 char * kwnames[] = {
4422 (char *) "name", NULL
4423 };
4424
4425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) SWIG_fail;
4426 {
4427 arg1 = wxString_in_helper(obj0);
4428 if (arg1 == NULL) SWIG_fail;
4429 temp1 = true;
4430 }
4431 {
4432 PyThreadState* __tstate = wxPyBeginAllowThreads();
4433 result = wxSystemOptions::GetOption((wxString const &)*arg1);
4434 wxPyEndAllowThreads(__tstate);
4435 if (PyErr_Occurred()) SWIG_fail;
4436 }
4437 {
4438 #if wxUSE_UNICODE
4439 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4440 #else
4441 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4442 #endif
4443 }
4444 {
4445 if (temp1)
4446 delete arg1;
4447 }
4448 return resultobj;
4449 fail:
4450 {
4451 if (temp1)
4452 delete arg1;
4453 }
4454 return NULL;
4455 }
4456
4457
4458 SWIGINTERN PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4459 PyObject *resultobj = 0;
4460 wxString *arg1 = 0 ;
4461 int result;
4462 bool temp1 = false ;
4463 PyObject * obj0 = 0 ;
4464 char * kwnames[] = {
4465 (char *) "name", NULL
4466 };
4467
4468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) SWIG_fail;
4469 {
4470 arg1 = wxString_in_helper(obj0);
4471 if (arg1 == NULL) SWIG_fail;
4472 temp1 = true;
4473 }
4474 {
4475 PyThreadState* __tstate = wxPyBeginAllowThreads();
4476 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
4477 wxPyEndAllowThreads(__tstate);
4478 if (PyErr_Occurred()) SWIG_fail;
4479 }
4480 resultobj = SWIG_From_int(static_cast< int >(result));
4481 {
4482 if (temp1)
4483 delete arg1;
4484 }
4485 return resultobj;
4486 fail:
4487 {
4488 if (temp1)
4489 delete arg1;
4490 }
4491 return NULL;
4492 }
4493
4494
4495 SWIGINTERN PyObject *_wrap_SystemOptions_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4496 PyObject *resultobj = 0;
4497 wxString *arg1 = 0 ;
4498 bool result;
4499 bool temp1 = false ;
4500 PyObject * obj0 = 0 ;
4501 char * kwnames[] = {
4502 (char *) "name", NULL
4503 };
4504
4505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) SWIG_fail;
4506 {
4507 arg1 = wxString_in_helper(obj0);
4508 if (arg1 == NULL) SWIG_fail;
4509 temp1 = true;
4510 }
4511 {
4512 PyThreadState* __tstate = wxPyBeginAllowThreads();
4513 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
4514 wxPyEndAllowThreads(__tstate);
4515 if (PyErr_Occurred()) SWIG_fail;
4516 }
4517 {
4518 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4519 }
4520 {
4521 if (temp1)
4522 delete arg1;
4523 }
4524 return resultobj;
4525 fail:
4526 {
4527 if (temp1)
4528 delete arg1;
4529 }
4530 return NULL;
4531 }
4532
4533
4534 SWIGINTERN PyObject *_wrap_SystemOptions_IsFalse(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4535 PyObject *resultobj = 0;
4536 wxString *arg1 = 0 ;
4537 bool result;
4538 bool temp1 = false ;
4539 PyObject * obj0 = 0 ;
4540 char * kwnames[] = {
4541 (char *) "name", NULL
4542 };
4543
4544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_IsFalse",kwnames,&obj0)) SWIG_fail;
4545 {
4546 arg1 = wxString_in_helper(obj0);
4547 if (arg1 == NULL) SWIG_fail;
4548 temp1 = true;
4549 }
4550 {
4551 PyThreadState* __tstate = wxPyBeginAllowThreads();
4552 result = (bool)wxSystemOptions::IsFalse((wxString const &)*arg1);
4553 wxPyEndAllowThreads(__tstate);
4554 if (PyErr_Occurred()) SWIG_fail;
4555 }
4556 {
4557 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4558 }
4559 {
4560 if (temp1)
4561 delete arg1;
4562 }
4563 return resultobj;
4564 fail:
4565 {
4566 if (temp1)
4567 delete arg1;
4568 }
4569 return NULL;
4570 }
4571
4572
4573 SWIGINTERN PyObject *SystemOptions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4574 PyObject *obj;
4575 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4576 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemOptions, SWIG_NewClientData(obj));
4577 return SWIG_Py_Void();
4578 }
4579
4580 SWIGINTERN PyObject *SystemOptions_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4581 return SWIG_Python_InitShadowInstance(args);
4582 }
4583
4584 SWIGINTERN int FileSelectorPromptStr_set(PyObject *) {
4585 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorPromptStr is read-only.");
4586 return 1;
4587 }
4588
4589
4590 SWIGINTERN PyObject *FileSelectorPromptStr_get(void) {
4591 PyObject *pyobj = 0;
4592
4593 {
4594 #if wxUSE_UNICODE
4595 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4596 #else
4597 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4598 #endif
4599 }
4600 return pyobj;
4601 }
4602
4603
4604 SWIGINTERN int FileSelectorDefaultWildcardStr_set(PyObject *) {
4605 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
4606 return 1;
4607 }
4608
4609
4610 SWIGINTERN PyObject *FileSelectorDefaultWildcardStr_get(void) {
4611 PyObject *pyobj = 0;
4612
4613 {
4614 #if wxUSE_UNICODE
4615 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4616 #else
4617 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4618 #endif
4619 }
4620 return pyobj;
4621 }
4622
4623
4624 SWIGINTERN int DirSelectorPromptStr_set(PyObject *) {
4625 SWIG_Error(SWIG_AttributeError,"Variable DirSelectorPromptStr is read-only.");
4626 return 1;
4627 }
4628
4629
4630 SWIGINTERN PyObject *DirSelectorPromptStr_get(void) {
4631 PyObject *pyobj = 0;
4632
4633 {
4634 #if wxUSE_UNICODE
4635 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4636 #else
4637 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4638 #endif
4639 }
4640 return pyobj;
4641 }
4642
4643
4644 SWIGINTERN PyObject *_wrap_NewId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4645 PyObject *resultobj = 0;
4646 long result;
4647
4648 if (!SWIG_Python_UnpackTuple(args,"NewId",0,0,0)) SWIG_fail;
4649 {
4650 PyThreadState* __tstate = wxPyBeginAllowThreads();
4651 result = (long)wxNewId();
4652 wxPyEndAllowThreads(__tstate);
4653 if (PyErr_Occurred()) SWIG_fail;
4654 }
4655 resultobj = SWIG_From_long(static_cast< long >(result));
4656 return resultobj;
4657 fail:
4658 return NULL;
4659 }
4660
4661
4662 SWIGINTERN PyObject *_wrap_RegisterId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4663 PyObject *resultobj = 0;
4664 long arg1 ;
4665 long val1 ;
4666 int ecode1 = 0 ;
4667 PyObject * obj0 = 0 ;
4668 char * kwnames[] = {
4669 (char *) "id", NULL
4670 };
4671
4672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) SWIG_fail;
4673 ecode1 = SWIG_AsVal_long(obj0, &val1);
4674 if (!SWIG_IsOK(ecode1)) {
4675 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "RegisterId" "', expected argument " "1"" of type '" "long""'");
4676 }
4677 arg1 = static_cast< long >(val1);
4678 {
4679 PyThreadState* __tstate = wxPyBeginAllowThreads();
4680 wxRegisterId(arg1);
4681 wxPyEndAllowThreads(__tstate);
4682 if (PyErr_Occurred()) SWIG_fail;
4683 }
4684 resultobj = SWIG_Py_Void();
4685 return resultobj;
4686 fail:
4687 return NULL;
4688 }
4689
4690
4691 SWIGINTERN PyObject *_wrap_GetCurrentId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4692 PyObject *resultobj = 0;
4693 long result;
4694
4695 if (!SWIG_Python_UnpackTuple(args,"GetCurrentId",0,0,0)) SWIG_fail;
4696 {
4697 PyThreadState* __tstate = wxPyBeginAllowThreads();
4698 result = (long)wxGetCurrentId();
4699 wxPyEndAllowThreads(__tstate);
4700 if (PyErr_Occurred()) SWIG_fail;
4701 }
4702 resultobj = SWIG_From_long(static_cast< long >(result));
4703 return resultobj;
4704 fail:
4705 return NULL;
4706 }
4707
4708
4709 SWIGINTERN PyObject *_wrap_IsStockID(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4710 PyObject *resultobj = 0;
4711 int arg1 ;
4712 bool result;
4713 int val1 ;
4714 int ecode1 = 0 ;
4715 PyObject * obj0 = 0 ;
4716 char * kwnames[] = {
4717 (char *) "id", NULL
4718 };
4719
4720 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) SWIG_fail;
4721 ecode1 = SWIG_AsVal_int(obj0, &val1);
4722 if (!SWIG_IsOK(ecode1)) {
4723 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockID" "', expected argument " "1"" of type '" "int""'");
4724 }
4725 arg1 = static_cast< int >(val1);
4726 {
4727 PyThreadState* __tstate = wxPyBeginAllowThreads();
4728 result = (bool)wxIsStockID(arg1);
4729 wxPyEndAllowThreads(__tstate);
4730 if (PyErr_Occurred()) SWIG_fail;
4731 }
4732 {
4733 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4734 }
4735 return resultobj;
4736 fail:
4737 return NULL;
4738 }
4739
4740
4741 SWIGINTERN PyObject *_wrap_IsStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4742 PyObject *resultobj = 0;
4743 int arg1 ;
4744 wxString *arg2 = 0 ;
4745 bool result;
4746 int val1 ;
4747 int ecode1 = 0 ;
4748 bool temp2 = false ;
4749 PyObject * obj0 = 0 ;
4750 PyObject * obj1 = 0 ;
4751 char * kwnames[] = {
4752 (char *) "id",(char *) "label", NULL
4753 };
4754
4755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) SWIG_fail;
4756 ecode1 = SWIG_AsVal_int(obj0, &val1);
4757 if (!SWIG_IsOK(ecode1)) {
4758 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockLabel" "', expected argument " "1"" of type '" "int""'");
4759 }
4760 arg1 = static_cast< int >(val1);
4761 {
4762 arg2 = wxString_in_helper(obj1);
4763 if (arg2 == NULL) SWIG_fail;
4764 temp2 = true;
4765 }
4766 {
4767 PyThreadState* __tstate = wxPyBeginAllowThreads();
4768 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
4769 wxPyEndAllowThreads(__tstate);
4770 if (PyErr_Occurred()) SWIG_fail;
4771 }
4772 {
4773 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4774 }
4775 {
4776 if (temp2)
4777 delete arg2;
4778 }
4779 return resultobj;
4780 fail:
4781 {
4782 if (temp2)
4783 delete arg2;
4784 }
4785 return NULL;
4786 }
4787
4788
4789 SWIGINTERN PyObject *_wrap_GetStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4790 PyObject *resultobj = 0;
4791 int arg1 ;
4792 bool arg2 = (bool) true ;
4793 wxString arg3 = (wxString) wxPyEmptyString ;
4794 wxString result;
4795 int val1 ;
4796 int ecode1 = 0 ;
4797 bool val2 ;
4798 int ecode2 = 0 ;
4799 PyObject * obj0 = 0 ;
4800 PyObject * obj1 = 0 ;
4801 PyObject * obj2 = 0 ;
4802 char * kwnames[] = {
4803 (char *) "id",(char *) "withCodes",(char *) "accelerator", NULL
4804 };
4805
4806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GetStockLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4807 ecode1 = SWIG_AsVal_int(obj0, &val1);
4808 if (!SWIG_IsOK(ecode1)) {
4809 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetStockLabel" "', expected argument " "1"" of type '" "int""'");
4810 }
4811 arg1 = static_cast< int >(val1);
4812 if (obj1) {
4813 ecode2 = SWIG_AsVal_bool(obj1, &val2);
4814 if (!SWIG_IsOK(ecode2)) {
4815 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetStockLabel" "', expected argument " "2"" of type '" "bool""'");
4816 }
4817 arg2 = static_cast< bool >(val2);
4818 }
4819 if (obj2) {
4820 {
4821 wxString* sptr = wxString_in_helper(obj2);
4822 if (sptr == NULL) SWIG_fail;
4823 arg3 = *sptr;
4824 delete sptr;
4825 }
4826 }
4827 {
4828 PyThreadState* __tstate = wxPyBeginAllowThreads();
4829 result = wxGetStockLabel(arg1,arg2,arg3);
4830 wxPyEndAllowThreads(__tstate);
4831 if (PyErr_Occurred()) SWIG_fail;
4832 }
4833 {
4834 #if wxUSE_UNICODE
4835 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4836 #else
4837 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4838 #endif
4839 }
4840 return resultobj;
4841 fail:
4842 return NULL;
4843 }
4844
4845
4846 SWIGINTERN PyObject *_wrap_Bell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4847 PyObject *resultobj = 0;
4848
4849 if (!SWIG_Python_UnpackTuple(args,"Bell",0,0,0)) SWIG_fail;
4850 {
4851 if (!wxPyCheckForApp()) SWIG_fail;
4852 PyThreadState* __tstate = wxPyBeginAllowThreads();
4853 wxBell();
4854 wxPyEndAllowThreads(__tstate);
4855 if (PyErr_Occurred()) SWIG_fail;
4856 }
4857 resultobj = SWIG_Py_Void();
4858 return resultobj;
4859 fail:
4860 return NULL;
4861 }
4862
4863
4864 SWIGINTERN PyObject *_wrap_EndBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4865 PyObject *resultobj = 0;
4866
4867 if (!SWIG_Python_UnpackTuple(args,"EndBusyCursor",0,0,0)) SWIG_fail;
4868 {
4869 if (!wxPyCheckForApp()) SWIG_fail;
4870 PyThreadState* __tstate = wxPyBeginAllowThreads();
4871 wxEndBusyCursor();
4872 wxPyEndAllowThreads(__tstate);
4873 if (PyErr_Occurred()) SWIG_fail;
4874 }
4875 resultobj = SWIG_Py_Void();
4876 return resultobj;
4877 fail:
4878 return NULL;
4879 }
4880
4881
4882 SWIGINTERN PyObject *_wrap_GetElapsedTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4883 PyObject *resultobj = 0;
4884 bool arg1 = (bool) true ;
4885 long result;
4886 bool val1 ;
4887 int ecode1 = 0 ;
4888 PyObject * obj0 = 0 ;
4889 char * kwnames[] = {
4890 (char *) "resetTimer", NULL
4891 };
4892
4893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) SWIG_fail;
4894 if (obj0) {
4895 ecode1 = SWIG_AsVal_bool(obj0, &val1);
4896 if (!SWIG_IsOK(ecode1)) {
4897 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetElapsedTime" "', expected argument " "1"" of type '" "bool""'");
4898 }
4899 arg1 = static_cast< bool >(val1);
4900 }
4901 {
4902 PyThreadState* __tstate = wxPyBeginAllowThreads();
4903 result = (long)wxGetElapsedTime(arg1);
4904 wxPyEndAllowThreads(__tstate);
4905 if (PyErr_Occurred()) SWIG_fail;
4906 }
4907 resultobj = SWIG_From_long(static_cast< long >(result));
4908 return resultobj;
4909 fail:
4910 return NULL;
4911 }
4912
4913
4914 SWIGINTERN PyObject *_wrap_IsBusy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4915 PyObject *resultobj = 0;
4916 bool result;
4917
4918 if (!SWIG_Python_UnpackTuple(args,"IsBusy",0,0,0)) SWIG_fail;
4919 {
4920 PyThreadState* __tstate = wxPyBeginAllowThreads();
4921 result = (bool)wxIsBusy();
4922 wxPyEndAllowThreads(__tstate);
4923 if (PyErr_Occurred()) SWIG_fail;
4924 }
4925 {
4926 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4927 }
4928 return resultobj;
4929 fail:
4930 return NULL;
4931 }
4932
4933
4934 SWIGINTERN PyObject *_wrap_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4935 PyObject *resultobj = 0;
4936 wxString result;
4937
4938 if (!SWIG_Python_UnpackTuple(args,"Now",0,0,0)) SWIG_fail;
4939 {
4940 PyThreadState* __tstate = wxPyBeginAllowThreads();
4941 result = wxNow();
4942 wxPyEndAllowThreads(__tstate);
4943 if (PyErr_Occurred()) SWIG_fail;
4944 }
4945 {
4946 #if wxUSE_UNICODE
4947 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4948 #else
4949 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4950 #endif
4951 }
4952 return resultobj;
4953 fail:
4954 return NULL;
4955 }
4956
4957
4958 SWIGINTERN PyObject *_wrap_Shell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4959 PyObject *resultobj = 0;
4960 wxString const &arg1_defvalue = wxPyEmptyString ;
4961 wxString *arg1 = (wxString *) &arg1_defvalue ;
4962 bool result;
4963 bool temp1 = false ;
4964 PyObject * obj0 = 0 ;
4965 char * kwnames[] = {
4966 (char *) "command", NULL
4967 };
4968
4969 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) SWIG_fail;
4970 if (obj0) {
4971 {
4972 arg1 = wxString_in_helper(obj0);
4973 if (arg1 == NULL) SWIG_fail;
4974 temp1 = true;
4975 }
4976 }
4977 {
4978 PyThreadState* __tstate = wxPyBeginAllowThreads();
4979 result = (bool)wxShell((wxString const &)*arg1);
4980 wxPyEndAllowThreads(__tstate);
4981 if (PyErr_Occurred()) SWIG_fail;
4982 }
4983 {
4984 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4985 }
4986 {
4987 if (temp1)
4988 delete arg1;
4989 }
4990 return resultobj;
4991 fail:
4992 {
4993 if (temp1)
4994 delete arg1;
4995 }
4996 return NULL;
4997 }
4998
4999
5000 SWIGINTERN PyObject *_wrap_StartTimer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5001 PyObject *resultobj = 0;
5002
5003 if (!SWIG_Python_UnpackTuple(args,"StartTimer",0,0,0)) SWIG_fail;
5004 {
5005 PyThreadState* __tstate = wxPyBeginAllowThreads();
5006 wxStartTimer();
5007 wxPyEndAllowThreads(__tstate);
5008 if (PyErr_Occurred()) SWIG_fail;
5009 }
5010 resultobj = SWIG_Py_Void();
5011 return resultobj;
5012 fail:
5013 return NULL;
5014 }
5015
5016
5017 SWIGINTERN PyObject *_wrap_GetOsVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5018 PyObject *resultobj = 0;
5019 int *arg1 = (int *) 0 ;
5020 int *arg2 = (int *) 0 ;
5021 int result;
5022 int temp1 ;
5023 int res1 = SWIG_TMPOBJ ;
5024 int temp2 ;
5025 int res2 = SWIG_TMPOBJ ;
5026
5027 arg1 = &temp1;
5028 arg2 = &temp2;
5029 if (!SWIG_Python_UnpackTuple(args,"GetOsVersion",0,0,0)) SWIG_fail;
5030 {
5031 PyThreadState* __tstate = wxPyBeginAllowThreads();
5032 result = (int)wxGetOsVersion(arg1,arg2);
5033 wxPyEndAllowThreads(__tstate);
5034 if (PyErr_Occurred()) SWIG_fail;
5035 }
5036 resultobj = SWIG_From_int(static_cast< int >(result));
5037 if (SWIG_IsTmpObj(res1)) {
5038 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
5039 } else {
5040 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5041 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
5042 }
5043 if (SWIG_IsTmpObj(res2)) {
5044 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
5045 } else {
5046 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5047 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
5048 }
5049 return resultobj;
5050 fail:
5051 return NULL;
5052 }
5053
5054
5055 SWIGINTERN PyObject *_wrap_GetOsDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5056 PyObject *resultobj = 0;
5057 wxString result;
5058
5059 if (!SWIG_Python_UnpackTuple(args,"GetOsDescription",0,0,0)) SWIG_fail;
5060 {
5061 PyThreadState* __tstate = wxPyBeginAllowThreads();
5062 result = wxGetOsDescription();
5063 wxPyEndAllowThreads(__tstate);
5064 if (PyErr_Occurred()) SWIG_fail;
5065 }
5066 {
5067 #if wxUSE_UNICODE
5068 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5069 #else
5070 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5071 #endif
5072 }
5073 return resultobj;
5074 fail:
5075 return NULL;
5076 }
5077
5078
5079 SWIGINTERN PyObject *_wrap_IsPlatformLittleEndian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5080 PyObject *resultobj = 0;
5081 bool result;
5082
5083 if (!SWIG_Python_UnpackTuple(args,"IsPlatformLittleEndian",0,0,0)) SWIG_fail;
5084 {
5085 PyThreadState* __tstate = wxPyBeginAllowThreads();
5086 result = (bool)wxIsPlatformLittleEndian();
5087 wxPyEndAllowThreads(__tstate);
5088 if (PyErr_Occurred()) SWIG_fail;
5089 }
5090 {
5091 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5092 }
5093 return resultobj;
5094 fail:
5095 return NULL;
5096 }
5097
5098
5099 SWIGINTERN PyObject *_wrap_IsPlatform64Bit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5100 PyObject *resultobj = 0;
5101 bool result;
5102
5103 if (!SWIG_Python_UnpackTuple(args,"IsPlatform64Bit",0,0,0)) SWIG_fail;
5104 {
5105 PyThreadState* __tstate = wxPyBeginAllowThreads();
5106 result = (bool)wxIsPlatform64Bit();
5107 wxPyEndAllowThreads(__tstate);
5108 if (PyErr_Occurred()) SWIG_fail;
5109 }
5110 {
5111 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5112 }
5113 return resultobj;
5114 fail:
5115 return NULL;
5116 }
5117
5118
5119 SWIGINTERN PyObject *_wrap_GetFreeMemory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5120 PyObject *resultobj = 0;
5121 wxMemorySize result;
5122
5123 if (!SWIG_Python_UnpackTuple(args,"GetFreeMemory",0,0,0)) SWIG_fail;
5124 {
5125 PyThreadState* __tstate = wxPyBeginAllowThreads();
5126 result = wxGetFreeMemory();
5127 wxPyEndAllowThreads(__tstate);
5128 if (PyErr_Occurred()) SWIG_fail;
5129 }
5130 {
5131 #if wxUSE_LONGLONG
5132 resultobj = PyLong_FromLongLong((&result)->GetValue());
5133 #else
5134 resultobj = PyInt_FromLong(result);
5135 #endif
5136 }
5137 return resultobj;
5138 fail:
5139 return NULL;
5140 }
5141
5142
5143 SWIGINTERN PyObject *_wrap_Shutdown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5144 PyObject *resultobj = 0;
5145 wxShutdownFlags arg1 ;
5146 bool result;
5147 int val1 ;
5148 int ecode1 = 0 ;
5149 PyObject * obj0 = 0 ;
5150 char * kwnames[] = {
5151 (char *) "wFlags", NULL
5152 };
5153
5154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) SWIG_fail;
5155 ecode1 = SWIG_AsVal_int(obj0, &val1);
5156 if (!SWIG_IsOK(ecode1)) {
5157 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Shutdown" "', expected argument " "1"" of type '" "wxShutdownFlags""'");
5158 }
5159 arg1 = static_cast< wxShutdownFlags >(val1);
5160 {
5161 if (!wxPyCheckForApp()) SWIG_fail;
5162 PyThreadState* __tstate = wxPyBeginAllowThreads();
5163 result = (bool)wxShutdown(arg1);
5164 wxPyEndAllowThreads(__tstate);
5165 if (PyErr_Occurred()) SWIG_fail;
5166 }
5167 {
5168 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5169 }
5170 return resultobj;
5171 fail:
5172 return NULL;
5173 }
5174
5175
5176 SWIGINTERN PyObject *_wrap_Sleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5177 PyObject *resultobj = 0;
5178 int arg1 ;
5179 int val1 ;
5180 int ecode1 = 0 ;
5181 PyObject * obj0 = 0 ;
5182 char * kwnames[] = {
5183 (char *) "secs", NULL
5184 };
5185
5186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) SWIG_fail;
5187 ecode1 = SWIG_AsVal_int(obj0, &val1);
5188 if (!SWIG_IsOK(ecode1)) {
5189 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Sleep" "', expected argument " "1"" of type '" "int""'");
5190 }
5191 arg1 = static_cast< int >(val1);
5192 {
5193 PyThreadState* __tstate = wxPyBeginAllowThreads();
5194 wxSleep(arg1);
5195 wxPyEndAllowThreads(__tstate);
5196 if (PyErr_Occurred()) SWIG_fail;
5197 }
5198 resultobj = SWIG_Py_Void();
5199 return resultobj;
5200 fail:
5201 return NULL;
5202 }
5203
5204
5205 SWIGINTERN PyObject *_wrap_MilliSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5206 PyObject *resultobj = 0;
5207 unsigned long arg1 ;
5208 unsigned long val1 ;
5209 int ecode1 = 0 ;
5210 PyObject * obj0 = 0 ;
5211 char * kwnames[] = {
5212 (char *) "milliseconds", NULL
5213 };
5214
5215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) SWIG_fail;
5216 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5217 if (!SWIG_IsOK(ecode1)) {
5218 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MilliSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5219 }
5220 arg1 = static_cast< unsigned long >(val1);
5221 {
5222 PyThreadState* __tstate = wxPyBeginAllowThreads();
5223 wxMilliSleep(arg1);
5224 wxPyEndAllowThreads(__tstate);
5225 if (PyErr_Occurred()) SWIG_fail;
5226 }
5227 resultobj = SWIG_Py_Void();
5228 return resultobj;
5229 fail:
5230 return NULL;
5231 }
5232
5233
5234 SWIGINTERN PyObject *_wrap_MicroSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5235 PyObject *resultobj = 0;
5236 unsigned long arg1 ;
5237 unsigned long val1 ;
5238 int ecode1 = 0 ;
5239 PyObject * obj0 = 0 ;
5240 char * kwnames[] = {
5241 (char *) "microseconds", NULL
5242 };
5243
5244 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) SWIG_fail;
5245 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5246 if (!SWIG_IsOK(ecode1)) {
5247 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MicroSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5248 }
5249 arg1 = static_cast< unsigned long >(val1);
5250 {
5251 PyThreadState* __tstate = wxPyBeginAllowThreads();
5252 wxMicroSleep(arg1);
5253 wxPyEndAllowThreads(__tstate);
5254 if (PyErr_Occurred()) SWIG_fail;
5255 }
5256 resultobj = SWIG_Py_Void();
5257 return resultobj;
5258 fail:
5259 return NULL;
5260 }
5261
5262
5263 SWIGINTERN PyObject *_wrap_EnableTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5264 PyObject *resultobj = 0;
5265 bool arg1 ;
5266 bool val1 ;
5267 int ecode1 = 0 ;
5268 PyObject * obj0 = 0 ;
5269 char * kwnames[] = {
5270 (char *) "enable", NULL
5271 };
5272
5273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) SWIG_fail;
5274 ecode1 = SWIG_AsVal_bool(obj0, &val1);
5275 if (!SWIG_IsOK(ecode1)) {
5276 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "EnableTopLevelWindows" "', expected argument " "1"" of type '" "bool""'");
5277 }
5278 arg1 = static_cast< bool >(val1);
5279 {
5280 PyThreadState* __tstate = wxPyBeginAllowThreads();
5281 wxEnableTopLevelWindows(arg1);
5282 wxPyEndAllowThreads(__tstate);
5283 if (PyErr_Occurred()) SWIG_fail;
5284 }
5285 resultobj = SWIG_Py_Void();
5286 return resultobj;
5287 fail:
5288 return NULL;
5289 }
5290
5291
5292 SWIGINTERN PyObject *_wrap_StripMenuCodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5293 PyObject *resultobj = 0;
5294 wxString *arg1 = 0 ;
5295 wxString result;
5296 bool temp1 = false ;
5297 PyObject * obj0 = 0 ;
5298 char * kwnames[] = {
5299 (char *) "in", NULL
5300 };
5301
5302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) SWIG_fail;
5303 {
5304 arg1 = wxString_in_helper(obj0);
5305 if (arg1 == NULL) SWIG_fail;
5306 temp1 = true;
5307 }
5308 {
5309 PyThreadState* __tstate = wxPyBeginAllowThreads();
5310 result = wxStripMenuCodes((wxString const &)*arg1);
5311 wxPyEndAllowThreads(__tstate);
5312 if (PyErr_Occurred()) SWIG_fail;
5313 }
5314 {
5315 #if wxUSE_UNICODE
5316 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5317 #else
5318 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5319 #endif
5320 }
5321 {
5322 if (temp1)
5323 delete arg1;
5324 }
5325 return resultobj;
5326 fail:
5327 {
5328 if (temp1)
5329 delete arg1;
5330 }
5331 return NULL;
5332 }
5333
5334
5335 SWIGINTERN PyObject *_wrap_GetEmailAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5336 PyObject *resultobj = 0;
5337 wxString result;
5338
5339 if (!SWIG_Python_UnpackTuple(args,"GetEmailAddress",0,0,0)) SWIG_fail;
5340 {
5341 PyThreadState* __tstate = wxPyBeginAllowThreads();
5342 result = wxGetEmailAddress();
5343 wxPyEndAllowThreads(__tstate);
5344 if (PyErr_Occurred()) SWIG_fail;
5345 }
5346 {
5347 #if wxUSE_UNICODE
5348 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5349 #else
5350 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5351 #endif
5352 }
5353 return resultobj;
5354 fail:
5355 return NULL;
5356 }
5357
5358
5359 SWIGINTERN PyObject *_wrap_GetHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5360 PyObject *resultobj = 0;
5361 wxString result;
5362
5363 if (!SWIG_Python_UnpackTuple(args,"GetHostName",0,0,0)) SWIG_fail;
5364 {
5365 PyThreadState* __tstate = wxPyBeginAllowThreads();
5366 result = wxGetHostName();
5367 wxPyEndAllowThreads(__tstate);
5368 if (PyErr_Occurred()) SWIG_fail;
5369 }
5370 {
5371 #if wxUSE_UNICODE
5372 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5373 #else
5374 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5375 #endif
5376 }
5377 return resultobj;
5378 fail:
5379 return NULL;
5380 }
5381
5382
5383 SWIGINTERN PyObject *_wrap_GetFullHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5384 PyObject *resultobj = 0;
5385 wxString result;
5386
5387 if (!SWIG_Python_UnpackTuple(args,"GetFullHostName",0,0,0)) SWIG_fail;
5388 {
5389 PyThreadState* __tstate = wxPyBeginAllowThreads();
5390 result = wxGetFullHostName();
5391 wxPyEndAllowThreads(__tstate);
5392 if (PyErr_Occurred()) SWIG_fail;
5393 }
5394 {
5395 #if wxUSE_UNICODE
5396 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5397 #else
5398 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5399 #endif
5400 }
5401 return resultobj;
5402 fail:
5403 return NULL;
5404 }
5405
5406
5407 SWIGINTERN PyObject *_wrap_GetUserId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5408 PyObject *resultobj = 0;
5409 wxString result;
5410
5411 if (!SWIG_Python_UnpackTuple(args,"GetUserId",0,0,0)) SWIG_fail;
5412 {
5413 PyThreadState* __tstate = wxPyBeginAllowThreads();
5414 result = wxGetUserId();
5415 wxPyEndAllowThreads(__tstate);
5416 if (PyErr_Occurred()) SWIG_fail;
5417 }
5418 {
5419 #if wxUSE_UNICODE
5420 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5421 #else
5422 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5423 #endif
5424 }
5425 return resultobj;
5426 fail:
5427 return NULL;
5428 }
5429
5430
5431 SWIGINTERN PyObject *_wrap_GetUserName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5432 PyObject *resultobj = 0;
5433 wxString result;
5434
5435 if (!SWIG_Python_UnpackTuple(args,"GetUserName",0,0,0)) SWIG_fail;
5436 {
5437 PyThreadState* __tstate = wxPyBeginAllowThreads();
5438 result = wxGetUserName();
5439 wxPyEndAllowThreads(__tstate);
5440 if (PyErr_Occurred()) SWIG_fail;
5441 }
5442 {
5443 #if wxUSE_UNICODE
5444 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5445 #else
5446 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5447 #endif
5448 }
5449 return resultobj;
5450 fail:
5451 return NULL;
5452 }
5453
5454
5455 SWIGINTERN PyObject *_wrap_GetHomeDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5456 PyObject *resultobj = 0;
5457 wxString result;
5458
5459 if (!SWIG_Python_UnpackTuple(args,"GetHomeDir",0,0,0)) SWIG_fail;
5460 {
5461 PyThreadState* __tstate = wxPyBeginAllowThreads();
5462 result = wxGetHomeDir();
5463 wxPyEndAllowThreads(__tstate);
5464 if (PyErr_Occurred()) SWIG_fail;
5465 }
5466 {
5467 #if wxUSE_UNICODE
5468 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5469 #else
5470 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5471 #endif
5472 }
5473 return resultobj;
5474 fail:
5475 return NULL;
5476 }
5477
5478
5479 SWIGINTERN PyObject *_wrap_GetUserHome(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5480 PyObject *resultobj = 0;
5481 wxString const &arg1_defvalue = wxPyEmptyString ;
5482 wxString *arg1 = (wxString *) &arg1_defvalue ;
5483 wxString result;
5484 bool temp1 = false ;
5485 PyObject * obj0 = 0 ;
5486 char * kwnames[] = {
5487 (char *) "user", NULL
5488 };
5489
5490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) SWIG_fail;
5491 if (obj0) {
5492 {
5493 arg1 = wxString_in_helper(obj0);
5494 if (arg1 == NULL) SWIG_fail;
5495 temp1 = true;
5496 }
5497 }
5498 {
5499 PyThreadState* __tstate = wxPyBeginAllowThreads();
5500 result = wxGetUserHome((wxString const &)*arg1);
5501 wxPyEndAllowThreads(__tstate);
5502 if (PyErr_Occurred()) SWIG_fail;
5503 }
5504 {
5505 #if wxUSE_UNICODE
5506 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5507 #else
5508 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5509 #endif
5510 }
5511 {
5512 if (temp1)
5513 delete arg1;
5514 }
5515 return resultobj;
5516 fail:
5517 {
5518 if (temp1)
5519 delete arg1;
5520 }
5521 return NULL;
5522 }
5523
5524
5525 SWIGINTERN PyObject *_wrap_GetProcessId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5526 PyObject *resultobj = 0;
5527 unsigned long result;
5528
5529 if (!SWIG_Python_UnpackTuple(args,"GetProcessId",0,0,0)) SWIG_fail;
5530 {
5531 PyThreadState* __tstate = wxPyBeginAllowThreads();
5532 result = (unsigned long)wxGetProcessId();
5533 wxPyEndAllowThreads(__tstate);
5534 if (PyErr_Occurred()) SWIG_fail;
5535 }
5536 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
5537 return resultobj;
5538 fail:
5539 return NULL;
5540 }
5541
5542
5543 SWIGINTERN PyObject *_wrap_Trap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5544 PyObject *resultobj = 0;
5545
5546 if (!SWIG_Python_UnpackTuple(args,"Trap",0,0,0)) SWIG_fail;
5547 {
5548 PyThreadState* __tstate = wxPyBeginAllowThreads();
5549 wxTrap();
5550 wxPyEndAllowThreads(__tstate);
5551 if (PyErr_Occurred()) SWIG_fail;
5552 }
5553 resultobj = SWIG_Py_Void();
5554 return resultobj;
5555 fail:
5556 return NULL;
5557 }
5558
5559
5560 SWIGINTERN PyObject *_wrap_FileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5561 PyObject *resultobj = 0;
5562 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
5563 wxString *arg1 = (wxString *) &arg1_defvalue ;
5564 wxString const &arg2_defvalue = wxPyEmptyString ;
5565 wxString *arg2 = (wxString *) &arg2_defvalue ;
5566 wxString const &arg3_defvalue = wxPyEmptyString ;
5567 wxString *arg3 = (wxString *) &arg3_defvalue ;
5568 wxString const &arg4_defvalue = wxPyEmptyString ;
5569 wxString *arg4 = (wxString *) &arg4_defvalue ;
5570 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
5571 wxString *arg5 = (wxString *) &arg5_defvalue ;
5572 int arg6 = (int) 0 ;
5573 wxWindow *arg7 = (wxWindow *) NULL ;
5574 int arg8 = (int) -1 ;
5575 int arg9 = (int) -1 ;
5576 wxString result;
5577 bool temp1 = false ;
5578 bool temp2 = false ;
5579 bool temp3 = false ;
5580 bool temp4 = false ;
5581 bool temp5 = false ;
5582 int val6 ;
5583 int ecode6 = 0 ;
5584 void *argp7 = 0 ;
5585 int res7 = 0 ;
5586 int val8 ;
5587 int ecode8 = 0 ;
5588 int val9 ;
5589 int ecode9 = 0 ;
5590 PyObject * obj0 = 0 ;
5591 PyObject * obj1 = 0 ;
5592 PyObject * obj2 = 0 ;
5593 PyObject * obj3 = 0 ;
5594 PyObject * obj4 = 0 ;
5595 PyObject * obj5 = 0 ;
5596 PyObject * obj6 = 0 ;
5597 PyObject * obj7 = 0 ;
5598 PyObject * obj8 = 0 ;
5599 char * kwnames[] = {
5600 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
5601 };
5602
5603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
5604 if (obj0) {
5605 {
5606 arg1 = wxString_in_helper(obj0);
5607 if (arg1 == NULL) SWIG_fail;
5608 temp1 = true;
5609 }
5610 }
5611 if (obj1) {
5612 {
5613 arg2 = wxString_in_helper(obj1);
5614 if (arg2 == NULL) SWIG_fail;
5615 temp2 = true;
5616 }
5617 }
5618 if (obj2) {
5619 {
5620 arg3 = wxString_in_helper(obj2);
5621 if (arg3 == NULL) SWIG_fail;
5622 temp3 = true;
5623 }
5624 }
5625 if (obj3) {
5626 {
5627 arg4 = wxString_in_helper(obj3);
5628 if (arg4 == NULL) SWIG_fail;
5629 temp4 = true;
5630 }
5631 }
5632 if (obj4) {
5633 {
5634 arg5 = wxString_in_helper(obj4);
5635 if (arg5 == NULL) SWIG_fail;
5636 temp5 = true;
5637 }
5638 }
5639 if (obj5) {
5640 ecode6 = SWIG_AsVal_int(obj5, &val6);
5641 if (!SWIG_IsOK(ecode6)) {
5642 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "FileSelector" "', expected argument " "6"" of type '" "int""'");
5643 }
5644 arg6 = static_cast< int >(val6);
5645 }
5646 if (obj6) {
5647 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_wxWindow, 0 | 0 );
5648 if (!SWIG_IsOK(res7)) {
5649 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "FileSelector" "', expected argument " "7"" of type '" "wxWindow *""'");
5650 }
5651 arg7 = reinterpret_cast< wxWindow * >(argp7);
5652 }
5653 if (obj7) {
5654 ecode8 = SWIG_AsVal_int(obj7, &val8);
5655 if (!SWIG_IsOK(ecode8)) {
5656 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "FileSelector" "', expected argument " "8"" of type '" "int""'");
5657 }
5658 arg8 = static_cast< int >(val8);
5659 }
5660 if (obj8) {
5661 ecode9 = SWIG_AsVal_int(obj8, &val9);
5662 if (!SWIG_IsOK(ecode9)) {
5663 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "FileSelector" "', expected argument " "9"" of type '" "int""'");
5664 }
5665 arg9 = static_cast< int >(val9);
5666 }
5667 {
5668 if (!wxPyCheckForApp()) SWIG_fail;
5669 PyThreadState* __tstate = wxPyBeginAllowThreads();
5670 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
5671 wxPyEndAllowThreads(__tstate);
5672 if (PyErr_Occurred()) SWIG_fail;
5673 }
5674 {
5675 #if wxUSE_UNICODE
5676 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5677 #else
5678 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5679 #endif
5680 }
5681 {
5682 if (temp1)
5683 delete arg1;
5684 }
5685 {
5686 if (temp2)
5687 delete arg2;
5688 }
5689 {
5690 if (temp3)
5691 delete arg3;
5692 }
5693 {
5694 if (temp4)
5695 delete arg4;
5696 }
5697 {
5698 if (temp5)
5699 delete arg5;
5700 }
5701 return resultobj;
5702 fail:
5703 {
5704 if (temp1)
5705 delete arg1;
5706 }
5707 {
5708 if (temp2)
5709 delete arg2;
5710 }
5711 {
5712 if (temp3)
5713 delete arg3;
5714 }
5715 {
5716 if (temp4)
5717 delete arg4;
5718 }
5719 {
5720 if (temp5)
5721 delete arg5;
5722 }
5723 return NULL;
5724 }
5725
5726
5727 SWIGINTERN PyObject *_wrap_LoadFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5728 PyObject *resultobj = 0;
5729 wxString *arg1 = 0 ;
5730 wxString *arg2 = 0 ;
5731 wxString const &arg3_defvalue = wxPyEmptyString ;
5732 wxString *arg3 = (wxString *) &arg3_defvalue ;
5733 wxWindow *arg4 = (wxWindow *) NULL ;
5734 wxString result;
5735 bool temp1 = false ;
5736 bool temp2 = false ;
5737 bool temp3 = false ;
5738 void *argp4 = 0 ;
5739 int res4 = 0 ;
5740 PyObject * obj0 = 0 ;
5741 PyObject * obj1 = 0 ;
5742 PyObject * obj2 = 0 ;
5743 PyObject * obj3 = 0 ;
5744 char * kwnames[] = {
5745 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5746 };
5747
5748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5749 {
5750 arg1 = wxString_in_helper(obj0);
5751 if (arg1 == NULL) SWIG_fail;
5752 temp1 = true;
5753 }
5754 {
5755 arg2 = wxString_in_helper(obj1);
5756 if (arg2 == NULL) SWIG_fail;
5757 temp2 = true;
5758 }
5759 if (obj2) {
5760 {
5761 arg3 = wxString_in_helper(obj2);
5762 if (arg3 == NULL) SWIG_fail;
5763 temp3 = true;
5764 }
5765 }
5766 if (obj3) {
5767 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5768 if (!SWIG_IsOK(res4)) {
5769 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LoadFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5770 }
5771 arg4 = reinterpret_cast< wxWindow * >(argp4);
5772 }
5773 {
5774 if (!wxPyCheckForApp()) SWIG_fail;
5775 PyThreadState* __tstate = wxPyBeginAllowThreads();
5776 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5777 wxPyEndAllowThreads(__tstate);
5778 if (PyErr_Occurred()) SWIG_fail;
5779 }
5780 {
5781 #if wxUSE_UNICODE
5782 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5783 #else
5784 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5785 #endif
5786 }
5787 {
5788 if (temp1)
5789 delete arg1;
5790 }
5791 {
5792 if (temp2)
5793 delete arg2;
5794 }
5795 {
5796 if (temp3)
5797 delete arg3;
5798 }
5799 return resultobj;
5800 fail:
5801 {
5802 if (temp1)
5803 delete arg1;
5804 }
5805 {
5806 if (temp2)
5807 delete arg2;
5808 }
5809 {
5810 if (temp3)
5811 delete arg3;
5812 }
5813 return NULL;
5814 }
5815
5816
5817 SWIGINTERN PyObject *_wrap_SaveFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5818 PyObject *resultobj = 0;
5819 wxString *arg1 = 0 ;
5820 wxString *arg2 = 0 ;
5821 wxString const &arg3_defvalue = wxPyEmptyString ;
5822 wxString *arg3 = (wxString *) &arg3_defvalue ;
5823 wxWindow *arg4 = (wxWindow *) NULL ;
5824 wxString result;
5825 bool temp1 = false ;
5826 bool temp2 = false ;
5827 bool temp3 = false ;
5828 void *argp4 = 0 ;
5829 int res4 = 0 ;
5830 PyObject * obj0 = 0 ;
5831 PyObject * obj1 = 0 ;
5832 PyObject * obj2 = 0 ;
5833 PyObject * obj3 = 0 ;
5834 char * kwnames[] = {
5835 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5836 };
5837
5838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5839 {
5840 arg1 = wxString_in_helper(obj0);
5841 if (arg1 == NULL) SWIG_fail;
5842 temp1 = true;
5843 }
5844 {
5845 arg2 = wxString_in_helper(obj1);
5846 if (arg2 == NULL) SWIG_fail;
5847 temp2 = true;
5848 }
5849 if (obj2) {
5850 {
5851 arg3 = wxString_in_helper(obj2);
5852 if (arg3 == NULL) SWIG_fail;
5853 temp3 = true;
5854 }
5855 }
5856 if (obj3) {
5857 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5858 if (!SWIG_IsOK(res4)) {
5859 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SaveFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5860 }
5861 arg4 = reinterpret_cast< wxWindow * >(argp4);
5862 }
5863 {
5864 if (!wxPyCheckForApp()) SWIG_fail;
5865 PyThreadState* __tstate = wxPyBeginAllowThreads();
5866 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5867 wxPyEndAllowThreads(__tstate);
5868 if (PyErr_Occurred()) SWIG_fail;
5869 }
5870 {
5871 #if wxUSE_UNICODE
5872 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5873 #else
5874 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5875 #endif
5876 }
5877 {
5878 if (temp1)
5879 delete arg1;
5880 }
5881 {
5882 if (temp2)
5883 delete arg2;
5884 }
5885 {
5886 if (temp3)
5887 delete arg3;
5888 }
5889 return resultobj;
5890 fail:
5891 {
5892 if (temp1)
5893 delete arg1;
5894 }
5895 {
5896 if (temp2)
5897 delete arg2;
5898 }
5899 {
5900 if (temp3)
5901 delete arg3;
5902 }
5903 return NULL;
5904 }
5905
5906
5907 SWIGINTERN PyObject *_wrap_DirSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5908 PyObject *resultobj = 0;
5909 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
5910 wxString *arg1 = (wxString *) &arg1_defvalue ;
5911 wxString const &arg2_defvalue = wxPyEmptyString ;
5912 wxString *arg2 = (wxString *) &arg2_defvalue ;
5913 long arg3 = (long) wxDD_DEFAULT_STYLE ;
5914 wxPoint const &arg4_defvalue = wxDefaultPosition ;
5915 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
5916 wxWindow *arg5 = (wxWindow *) NULL ;
5917 wxString result;
5918 bool temp1 = false ;
5919 bool temp2 = false ;
5920 long val3 ;
5921 int ecode3 = 0 ;
5922 wxPoint temp4 ;
5923 void *argp5 = 0 ;
5924 int res5 = 0 ;
5925 PyObject * obj0 = 0 ;
5926 PyObject * obj1 = 0 ;
5927 PyObject * obj2 = 0 ;
5928 PyObject * obj3 = 0 ;
5929 PyObject * obj4 = 0 ;
5930 char * kwnames[] = {
5931 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
5932 };
5933
5934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
5935 if (obj0) {
5936 {
5937 arg1 = wxString_in_helper(obj0);
5938 if (arg1 == NULL) SWIG_fail;
5939 temp1 = true;
5940 }
5941 }
5942 if (obj1) {
5943 {
5944 arg2 = wxString_in_helper(obj1);
5945 if (arg2 == NULL) SWIG_fail;
5946 temp2 = true;
5947 }
5948 }
5949 if (obj2) {
5950 ecode3 = SWIG_AsVal_long(obj2, &val3);
5951 if (!SWIG_IsOK(ecode3)) {
5952 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DirSelector" "', expected argument " "3"" of type '" "long""'");
5953 }
5954 arg3 = static_cast< long >(val3);
5955 }
5956 if (obj3) {
5957 {
5958 arg4 = &temp4;
5959 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
5960 }
5961 }
5962 if (obj4) {
5963 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
5964 if (!SWIG_IsOK(res5)) {
5965 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DirSelector" "', expected argument " "5"" of type '" "wxWindow *""'");
5966 }
5967 arg5 = reinterpret_cast< wxWindow * >(argp5);
5968 }
5969 {
5970 if (!wxPyCheckForApp()) SWIG_fail;
5971 PyThreadState* __tstate = wxPyBeginAllowThreads();
5972 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
5973 wxPyEndAllowThreads(__tstate);
5974 if (PyErr_Occurred()) SWIG_fail;
5975 }
5976 {
5977 #if wxUSE_UNICODE
5978 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5979 #else
5980 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5981 #endif
5982 }
5983 {
5984 if (temp1)
5985 delete arg1;
5986 }
5987 {
5988 if (temp2)
5989 delete arg2;
5990 }
5991 return resultobj;
5992 fail:
5993 {
5994 if (temp1)
5995 delete arg1;
5996 }
5997 {
5998 if (temp2)
5999 delete arg2;
6000 }
6001 return NULL;
6002 }
6003
6004
6005 SWIGINTERN PyObject *_wrap_GetTextFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6006 PyObject *resultobj = 0;
6007 wxString *arg1 = 0 ;
6008 wxString const &arg2_defvalue = wxPyEmptyString ;
6009 wxString *arg2 = (wxString *) &arg2_defvalue ;
6010 wxString const &arg3_defvalue = wxPyEmptyString ;
6011 wxString *arg3 = (wxString *) &arg3_defvalue ;
6012 wxWindow *arg4 = (wxWindow *) NULL ;
6013 int arg5 = (int) -1 ;
6014 int arg6 = (int) -1 ;
6015 bool arg7 = (bool) true ;
6016 wxString result;
6017 bool temp1 = false ;
6018 bool temp2 = false ;
6019 bool temp3 = false ;
6020 void *argp4 = 0 ;
6021 int res4 = 0 ;
6022 int val5 ;
6023 int ecode5 = 0 ;
6024 int val6 ;
6025 int ecode6 = 0 ;
6026 bool val7 ;
6027 int ecode7 = 0 ;
6028 PyObject * obj0 = 0 ;
6029 PyObject * obj1 = 0 ;
6030 PyObject * obj2 = 0 ;
6031 PyObject * obj3 = 0 ;
6032 PyObject * obj4 = 0 ;
6033 PyObject * obj5 = 0 ;
6034 PyObject * obj6 = 0 ;
6035 char * kwnames[] = {
6036 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
6037 };
6038
6039 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
6040 {
6041 arg1 = wxString_in_helper(obj0);
6042 if (arg1 == NULL) SWIG_fail;
6043 temp1 = true;
6044 }
6045 if (obj1) {
6046 {
6047 arg2 = wxString_in_helper(obj1);
6048 if (arg2 == NULL) SWIG_fail;
6049 temp2 = true;
6050 }
6051 }
6052 if (obj2) {
6053 {
6054 arg3 = wxString_in_helper(obj2);
6055 if (arg3 == NULL) SWIG_fail;
6056 temp3 = true;
6057 }
6058 }
6059 if (obj3) {
6060 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6061 if (!SWIG_IsOK(res4)) {
6062 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetTextFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6063 }
6064 arg4 = reinterpret_cast< wxWindow * >(argp4);
6065 }
6066 if (obj4) {
6067 ecode5 = SWIG_AsVal_int(obj4, &val5);
6068 if (!SWIG_IsOK(ecode5)) {
6069 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetTextFromUser" "', expected argument " "5"" of type '" "int""'");
6070 }
6071 arg5 = static_cast< int >(val5);
6072 }
6073 if (obj5) {
6074 ecode6 = SWIG_AsVal_int(obj5, &val6);
6075 if (!SWIG_IsOK(ecode6)) {
6076 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetTextFromUser" "', expected argument " "6"" of type '" "int""'");
6077 }
6078 arg6 = static_cast< int >(val6);
6079 }
6080 if (obj6) {
6081 ecode7 = SWIG_AsVal_bool(obj6, &val7);
6082 if (!SWIG_IsOK(ecode7)) {
6083 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetTextFromUser" "', expected argument " "7"" of type '" "bool""'");
6084 }
6085 arg7 = static_cast< bool >(val7);
6086 }
6087 {
6088 if (!wxPyCheckForApp()) SWIG_fail;
6089 PyThreadState* __tstate = wxPyBeginAllowThreads();
6090 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
6091 wxPyEndAllowThreads(__tstate);
6092 if (PyErr_Occurred()) SWIG_fail;
6093 }
6094 {
6095 #if wxUSE_UNICODE
6096 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6097 #else
6098 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6099 #endif
6100 }
6101 {
6102 if (temp1)
6103 delete arg1;
6104 }
6105 {
6106 if (temp2)
6107 delete arg2;
6108 }
6109 {
6110 if (temp3)
6111 delete arg3;
6112 }
6113 return resultobj;
6114 fail:
6115 {
6116 if (temp1)
6117 delete arg1;
6118 }
6119 {
6120 if (temp2)
6121 delete arg2;
6122 }
6123 {
6124 if (temp3)
6125 delete arg3;
6126 }
6127 return NULL;
6128 }
6129
6130
6131 SWIGINTERN PyObject *_wrap_GetPasswordFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6132 PyObject *resultobj = 0;
6133 wxString *arg1 = 0 ;
6134 wxString const &arg2_defvalue = wxPyEmptyString ;
6135 wxString *arg2 = (wxString *) &arg2_defvalue ;
6136 wxString const &arg3_defvalue = wxPyEmptyString ;
6137 wxString *arg3 = (wxString *) &arg3_defvalue ;
6138 wxWindow *arg4 = (wxWindow *) NULL ;
6139 wxString result;
6140 bool temp1 = false ;
6141 bool temp2 = false ;
6142 bool temp3 = false ;
6143 void *argp4 = 0 ;
6144 int res4 = 0 ;
6145 PyObject * obj0 = 0 ;
6146 PyObject * obj1 = 0 ;
6147 PyObject * obj2 = 0 ;
6148 PyObject * obj3 = 0 ;
6149 char * kwnames[] = {
6150 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
6151 };
6152
6153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6154 {
6155 arg1 = wxString_in_helper(obj0);
6156 if (arg1 == NULL) SWIG_fail;
6157 temp1 = true;
6158 }
6159 if (obj1) {
6160 {
6161 arg2 = wxString_in_helper(obj1);
6162 if (arg2 == NULL) SWIG_fail;
6163 temp2 = true;
6164 }
6165 }
6166 if (obj2) {
6167 {
6168 arg3 = wxString_in_helper(obj2);
6169 if (arg3 == NULL) SWIG_fail;
6170 temp3 = true;
6171 }
6172 }
6173 if (obj3) {
6174 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6175 if (!SWIG_IsOK(res4)) {
6176 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetPasswordFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6177 }
6178 arg4 = reinterpret_cast< wxWindow * >(argp4);
6179 }
6180 {
6181 if (!wxPyCheckForApp()) SWIG_fail;
6182 PyThreadState* __tstate = wxPyBeginAllowThreads();
6183 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
6184 wxPyEndAllowThreads(__tstate);
6185 if (PyErr_Occurred()) SWIG_fail;
6186 }
6187 {
6188 #if wxUSE_UNICODE
6189 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6190 #else
6191 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6192 #endif
6193 }
6194 {
6195 if (temp1)
6196 delete arg1;
6197 }
6198 {
6199 if (temp2)
6200 delete arg2;
6201 }
6202 {
6203 if (temp3)
6204 delete arg3;
6205 }
6206 return resultobj;
6207 fail:
6208 {
6209 if (temp1)
6210 delete arg1;
6211 }
6212 {
6213 if (temp2)
6214 delete arg2;
6215 }
6216 {
6217 if (temp3)
6218 delete arg3;
6219 }
6220 return NULL;
6221 }
6222
6223
6224 SWIGINTERN PyObject *_wrap_GetSingleChoice(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6225 PyObject *resultobj = 0;
6226 wxString *arg1 = 0 ;
6227 wxString *arg2 = 0 ;
6228 int arg3 ;
6229 wxString *arg4 = (wxString *) 0 ;
6230 wxWindow *arg5 = (wxWindow *) NULL ;
6231 int arg6 = (int) -1 ;
6232 int arg7 = (int) -1 ;
6233 bool arg8 = (bool) true ;
6234 int arg9 = (int) 150 ;
6235 int arg10 = (int) 200 ;
6236 wxString result;
6237 bool temp1 = false ;
6238 bool temp2 = false ;
6239 void *argp5 = 0 ;
6240 int res5 = 0 ;
6241 int val6 ;
6242 int ecode6 = 0 ;
6243 int val7 ;
6244 int ecode7 = 0 ;
6245 bool val8 ;
6246 int ecode8 = 0 ;
6247 int val9 ;
6248 int ecode9 = 0 ;
6249 int val10 ;
6250 int ecode10 = 0 ;
6251 PyObject * obj0 = 0 ;
6252 PyObject * obj1 = 0 ;
6253 PyObject * obj2 = 0 ;
6254 PyObject * obj3 = 0 ;
6255 PyObject * obj4 = 0 ;
6256 PyObject * obj5 = 0 ;
6257 PyObject * obj6 = 0 ;
6258 PyObject * obj7 = 0 ;
6259 PyObject * obj8 = 0 ;
6260 char * kwnames[] = {
6261 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6262 };
6263
6264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6265 {
6266 arg1 = wxString_in_helper(obj0);
6267 if (arg1 == NULL) SWIG_fail;
6268 temp1 = true;
6269 }
6270 {
6271 arg2 = wxString_in_helper(obj1);
6272 if (arg2 == NULL) SWIG_fail;
6273 temp2 = true;
6274 }
6275 {
6276 arg3 = PyList_Size(obj2);
6277 arg4 = wxString_LIST_helper(obj2);
6278 if (arg4 == NULL) SWIG_fail;
6279 }
6280 if (obj3) {
6281 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6282 if (!SWIG_IsOK(res5)) {
6283 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoice" "', expected argument " "5"" of type '" "wxWindow *""'");
6284 }
6285 arg5 = reinterpret_cast< wxWindow * >(argp5);
6286 }
6287 if (obj4) {
6288 ecode6 = SWIG_AsVal_int(obj4, &val6);
6289 if (!SWIG_IsOK(ecode6)) {
6290 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoice" "', expected argument " "6"" of type '" "int""'");
6291 }
6292 arg6 = static_cast< int >(val6);
6293 }
6294 if (obj5) {
6295 ecode7 = SWIG_AsVal_int(obj5, &val7);
6296 if (!SWIG_IsOK(ecode7)) {
6297 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoice" "', expected argument " "7"" of type '" "int""'");
6298 }
6299 arg7 = static_cast< int >(val7);
6300 }
6301 if (obj6) {
6302 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6303 if (!SWIG_IsOK(ecode8)) {
6304 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoice" "', expected argument " "8"" of type '" "bool""'");
6305 }
6306 arg8 = static_cast< bool >(val8);
6307 }
6308 if (obj7) {
6309 ecode9 = SWIG_AsVal_int(obj7, &val9);
6310 if (!SWIG_IsOK(ecode9)) {
6311 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoice" "', expected argument " "9"" of type '" "int""'");
6312 }
6313 arg9 = static_cast< int >(val9);
6314 }
6315 if (obj8) {
6316 ecode10 = SWIG_AsVal_int(obj8, &val10);
6317 if (!SWIG_IsOK(ecode10)) {
6318 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoice" "', expected argument " "10"" of type '" "int""'");
6319 }
6320 arg10 = static_cast< int >(val10);
6321 }
6322 {
6323 if (!wxPyCheckForApp()) SWIG_fail;
6324 PyThreadState* __tstate = wxPyBeginAllowThreads();
6325 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6326 wxPyEndAllowThreads(__tstate);
6327 if (PyErr_Occurred()) SWIG_fail;
6328 }
6329 {
6330 #if wxUSE_UNICODE
6331 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6332 #else
6333 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6334 #endif
6335 }
6336 {
6337 if (temp1)
6338 delete arg1;
6339 }
6340 {
6341 if (temp2)
6342 delete arg2;
6343 }
6344 {
6345 if (arg4) delete [] arg4;
6346 }
6347 return resultobj;
6348 fail:
6349 {
6350 if (temp1)
6351 delete arg1;
6352 }
6353 {
6354 if (temp2)
6355 delete arg2;
6356 }
6357 {
6358 if (arg4) delete [] arg4;
6359 }
6360 return NULL;
6361 }
6362
6363
6364 SWIGINTERN PyObject *_wrap_GetSingleChoiceIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6365 PyObject *resultobj = 0;
6366 wxString *arg1 = 0 ;
6367 wxString *arg2 = 0 ;
6368 int arg3 ;
6369 wxString *arg4 = (wxString *) 0 ;
6370 wxWindow *arg5 = (wxWindow *) NULL ;
6371 int arg6 = (int) -1 ;
6372 int arg7 = (int) -1 ;
6373 bool arg8 = (bool) true ;
6374 int arg9 = (int) 150 ;
6375 int arg10 = (int) 200 ;
6376 int result;
6377 bool temp1 = false ;
6378 bool temp2 = false ;
6379 void *argp5 = 0 ;
6380 int res5 = 0 ;
6381 int val6 ;
6382 int ecode6 = 0 ;
6383 int val7 ;
6384 int ecode7 = 0 ;
6385 bool val8 ;
6386 int ecode8 = 0 ;
6387 int val9 ;
6388 int ecode9 = 0 ;
6389 int val10 ;
6390 int ecode10 = 0 ;
6391 PyObject * obj0 = 0 ;
6392 PyObject * obj1 = 0 ;
6393 PyObject * obj2 = 0 ;
6394 PyObject * obj3 = 0 ;
6395 PyObject * obj4 = 0 ;
6396 PyObject * obj5 = 0 ;
6397 PyObject * obj6 = 0 ;
6398 PyObject * obj7 = 0 ;
6399 PyObject * obj8 = 0 ;
6400 char * kwnames[] = {
6401 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6402 };
6403
6404 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6405 {
6406 arg1 = wxString_in_helper(obj0);
6407 if (arg1 == NULL) SWIG_fail;
6408 temp1 = true;
6409 }
6410 {
6411 arg2 = wxString_in_helper(obj1);
6412 if (arg2 == NULL) SWIG_fail;
6413 temp2 = true;
6414 }
6415 {
6416 arg3 = PyList_Size(obj2);
6417 arg4 = wxString_LIST_helper(obj2);
6418 if (arg4 == NULL) SWIG_fail;
6419 }
6420 if (obj3) {
6421 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6422 if (!SWIG_IsOK(res5)) {
6423 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoiceIndex" "', expected argument " "5"" of type '" "wxWindow *""'");
6424 }
6425 arg5 = reinterpret_cast< wxWindow * >(argp5);
6426 }
6427 if (obj4) {
6428 ecode6 = SWIG_AsVal_int(obj4, &val6);
6429 if (!SWIG_IsOK(ecode6)) {
6430 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoiceIndex" "', expected argument " "6"" of type '" "int""'");
6431 }
6432 arg6 = static_cast< int >(val6);
6433 }
6434 if (obj5) {
6435 ecode7 = SWIG_AsVal_int(obj5, &val7);
6436 if (!SWIG_IsOK(ecode7)) {
6437 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoiceIndex" "', expected argument " "7"" of type '" "int""'");
6438 }
6439 arg7 = static_cast< int >(val7);
6440 }
6441 if (obj6) {
6442 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6443 if (!SWIG_IsOK(ecode8)) {
6444 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoiceIndex" "', expected argument " "8"" of type '" "bool""'");
6445 }
6446 arg8 = static_cast< bool >(val8);
6447 }
6448 if (obj7) {
6449 ecode9 = SWIG_AsVal_int(obj7, &val9);
6450 if (!SWIG_IsOK(ecode9)) {
6451 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoiceIndex" "', expected argument " "9"" of type '" "int""'");
6452 }
6453 arg9 = static_cast< int >(val9);
6454 }
6455 if (obj8) {
6456 ecode10 = SWIG_AsVal_int(obj8, &val10);
6457 if (!SWIG_IsOK(ecode10)) {
6458 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoiceIndex" "', expected argument " "10"" of type '" "int""'");
6459 }
6460 arg10 = static_cast< int >(val10);
6461 }
6462 {
6463 if (!wxPyCheckForApp()) SWIG_fail;
6464 PyThreadState* __tstate = wxPyBeginAllowThreads();
6465 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6466 wxPyEndAllowThreads(__tstate);
6467 if (PyErr_Occurred()) SWIG_fail;
6468 }
6469 resultobj = SWIG_From_int(static_cast< int >(result));
6470 {
6471 if (temp1)
6472 delete arg1;
6473 }
6474 {
6475 if (temp2)
6476 delete arg2;
6477 }
6478 {
6479 if (arg4) delete [] arg4;
6480 }
6481 return resultobj;
6482 fail:
6483 {
6484 if (temp1)
6485 delete arg1;
6486 }
6487 {
6488 if (temp2)
6489 delete arg2;
6490 }
6491 {
6492 if (arg4) delete [] arg4;
6493 }
6494 return NULL;
6495 }
6496
6497
6498 SWIGINTERN PyObject *_wrap_MessageBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6499 PyObject *resultobj = 0;
6500 wxString *arg1 = 0 ;
6501 wxString const &arg2_defvalue = wxPyEmptyString ;
6502 wxString *arg2 = (wxString *) &arg2_defvalue ;
6503 int arg3 = (int) wxOK|wxCENTRE ;
6504 wxWindow *arg4 = (wxWindow *) NULL ;
6505 int arg5 = (int) -1 ;
6506 int arg6 = (int) -1 ;
6507 int result;
6508 bool temp1 = false ;
6509 bool temp2 = false ;
6510 int val3 ;
6511 int ecode3 = 0 ;
6512 void *argp4 = 0 ;
6513 int res4 = 0 ;
6514 int val5 ;
6515 int ecode5 = 0 ;
6516 int val6 ;
6517 int ecode6 = 0 ;
6518 PyObject * obj0 = 0 ;
6519 PyObject * obj1 = 0 ;
6520 PyObject * obj2 = 0 ;
6521 PyObject * obj3 = 0 ;
6522 PyObject * obj4 = 0 ;
6523 PyObject * obj5 = 0 ;
6524 char * kwnames[] = {
6525 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
6526 };
6527
6528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
6529 {
6530 arg1 = wxString_in_helper(obj0);
6531 if (arg1 == NULL) SWIG_fail;
6532 temp1 = true;
6533 }
6534 if (obj1) {
6535 {
6536 arg2 = wxString_in_helper(obj1);
6537 if (arg2 == NULL) SWIG_fail;
6538 temp2 = true;
6539 }
6540 }
6541 if (obj2) {
6542 ecode3 = SWIG_AsVal_int(obj2, &val3);
6543 if (!SWIG_IsOK(ecode3)) {
6544 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MessageBox" "', expected argument " "3"" of type '" "int""'");
6545 }
6546 arg3 = static_cast< int >(val3);
6547 }
6548 if (obj3) {
6549 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6550 if (!SWIG_IsOK(res4)) {
6551 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MessageBox" "', expected argument " "4"" of type '" "wxWindow *""'");
6552 }
6553 arg4 = reinterpret_cast< wxWindow * >(argp4);
6554 }
6555 if (obj4) {
6556 ecode5 = SWIG_AsVal_int(obj4, &val5);
6557 if (!SWIG_IsOK(ecode5)) {
6558 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "MessageBox" "', expected argument " "5"" of type '" "int""'");
6559 }
6560 arg5 = static_cast< int >(val5);
6561 }
6562 if (obj5) {
6563 ecode6 = SWIG_AsVal_int(obj5, &val6);
6564 if (!SWIG_IsOK(ecode6)) {
6565 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "MessageBox" "', expected argument " "6"" of type '" "int""'");
6566 }
6567 arg6 = static_cast< int >(val6);
6568 }
6569 {
6570 if (!wxPyCheckForApp()) SWIG_fail;
6571 PyThreadState* __tstate = wxPyBeginAllowThreads();
6572 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
6573 wxPyEndAllowThreads(__tstate);
6574 if (PyErr_Occurred()) SWIG_fail;
6575 }
6576 resultobj = SWIG_From_int(static_cast< int >(result));
6577 {
6578 if (temp1)
6579 delete arg1;
6580 }
6581 {
6582 if (temp2)
6583 delete arg2;
6584 }
6585 return resultobj;
6586 fail:
6587 {
6588 if (temp1)
6589 delete arg1;
6590 }
6591 {
6592 if (temp2)
6593 delete arg2;
6594 }
6595 return NULL;
6596 }
6597
6598
6599 SWIGINTERN PyObject *_wrap_GetNumberFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6600 PyObject *resultobj = 0;
6601 wxString *arg1 = 0 ;
6602 wxString *arg2 = 0 ;
6603 wxString *arg3 = 0 ;
6604 long arg4 ;
6605 long arg5 = (long) 0 ;
6606 long arg6 = (long) 100 ;
6607 wxWindow *arg7 = (wxWindow *) NULL ;
6608 wxPoint const &arg8_defvalue = wxDefaultPosition ;
6609 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
6610 long result;
6611 bool temp1 = false ;
6612 bool temp2 = false ;
6613 bool temp3 = false ;
6614 long val4 ;
6615 int ecode4 = 0 ;
6616 long val5 ;
6617 int ecode5 = 0 ;
6618 long val6 ;
6619 int ecode6 = 0 ;
6620 void *argp7 = 0 ;
6621 int res7 = 0 ;
6622 wxPoint temp8 ;
6623 PyObject * obj0 = 0 ;
6624 PyObject * obj1 = 0 ;
6625 PyObject * obj2 = 0 ;
6626 PyObject * obj3 = 0 ;
6627 PyObject * obj4 = 0 ;
6628 PyObject * obj5 = 0 ;
6629 PyObject * obj6 = 0 ;
6630 PyObject * obj7 = 0 ;
6631 char * kwnames[] = {
6632 (char *) "message",(char *) "prompt",(char *) "caption",(char *) "value",(char *) "min",(char *) "max",(char *) "parent",(char *) "pos", NULL
6633 };
6634
6635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOOO:GetNumberFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
6636 {
6637 arg1 = wxString_in_helper(obj0);
6638 if (arg1 == NULL) SWIG_fail;
6639 temp1 = true;
6640 }
6641 {
6642 arg2 = wxString_in_helper(obj1);
6643 if (arg2 == NULL) SWIG_fail;
6644 temp2 = true;
6645 }
6646 {
6647 arg3 = wxString_in_helper(obj2);
6648 if (arg3 == NULL) SWIG_fail;
6649 temp3 = true;
6650 }
6651 ecode4 = SWIG_AsVal_long(obj3, &val4);
6652 if (!SWIG_IsOK(ecode4)) {
6653 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GetNumberFromUser" "', expected argument " "4"" of type '" "long""'");
6654 }
6655 arg4 = static_cast< long >(val4);
6656 if (obj4) {
6657 ecode5 = SWIG_AsVal_long(obj4, &val5);
6658 if (!SWIG_IsOK(ecode5)) {
6659 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetNumberFromUser" "', expected argument " "5"" of type '" "long""'");
6660 }
6661 arg5 = static_cast< long >(val5);
6662 }
6663 if (obj5) {
6664 ecode6 = SWIG_AsVal_long(obj5, &val6);
6665 if (!SWIG_IsOK(ecode6)) {
6666 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetNumberFromUser" "', expected argument " "6"" of type '" "long""'");
6667 }
6668 arg6 = static_cast< long >(val6);
6669 }
6670 if (obj6) {
6671 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_wxWindow, 0 | 0 );
6672 if (!SWIG_IsOK(res7)) {
6673 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "GetNumberFromUser" "', expected argument " "7"" of type '" "wxWindow *""'");
6674 }
6675 arg7 = reinterpret_cast< wxWindow * >(argp7);
6676 }
6677 if (obj7) {
6678 {
6679 arg8 = &temp8;
6680 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
6681 }
6682 }
6683 {
6684 if (!wxPyCheckForApp()) SWIG_fail;
6685 PyThreadState* __tstate = wxPyBeginAllowThreads();
6686 result = (long)wxGetNumberFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7,(wxPoint const &)*arg8);
6687 wxPyEndAllowThreads(__tstate);
6688 if (PyErr_Occurred()) SWIG_fail;
6689 }
6690 resultobj = SWIG_From_long(static_cast< long >(result));
6691 {
6692 if (temp1)
6693 delete arg1;
6694 }
6695 {
6696 if (temp2)
6697 delete arg2;
6698 }
6699 {
6700 if (temp3)
6701 delete arg3;
6702 }
6703 return resultobj;
6704 fail:
6705 {
6706 if (temp1)
6707 delete arg1;
6708 }
6709 {
6710 if (temp2)
6711 delete arg2;
6712 }
6713 {
6714 if (temp3)
6715 delete arg3;
6716 }
6717 return NULL;
6718 }
6719
6720
6721 SWIGINTERN PyObject *_wrap_ColourDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6722 PyObject *resultobj = 0;
6723 bool result;
6724
6725 if (!SWIG_Python_UnpackTuple(args,"ColourDisplay",0,0,0)) SWIG_fail;
6726 {
6727 if (!wxPyCheckForApp()) SWIG_fail;
6728 PyThreadState* __tstate = wxPyBeginAllowThreads();
6729 result = (bool)wxColourDisplay();
6730 wxPyEndAllowThreads(__tstate);
6731 if (PyErr_Occurred()) SWIG_fail;
6732 }
6733 {
6734 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6735 }
6736 return resultobj;
6737 fail:
6738 return NULL;
6739 }
6740
6741
6742 SWIGINTERN PyObject *_wrap_DisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6743 PyObject *resultobj = 0;
6744 int result;
6745
6746 if (!SWIG_Python_UnpackTuple(args,"DisplayDepth",0,0,0)) SWIG_fail;
6747 {
6748 if (!wxPyCheckForApp()) SWIG_fail;
6749 PyThreadState* __tstate = wxPyBeginAllowThreads();
6750 result = (int)wxDisplayDepth();
6751 wxPyEndAllowThreads(__tstate);
6752 if (PyErr_Occurred()) SWIG_fail;
6753 }
6754 resultobj = SWIG_From_int(static_cast< int >(result));
6755 return resultobj;
6756 fail:
6757 return NULL;
6758 }
6759
6760
6761 SWIGINTERN PyObject *_wrap_GetDisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6762 PyObject *resultobj = 0;
6763 int result;
6764
6765 if (!SWIG_Python_UnpackTuple(args,"GetDisplayDepth",0,0,0)) SWIG_fail;
6766 {
6767 if (!wxPyCheckForApp()) SWIG_fail;
6768 PyThreadState* __tstate = wxPyBeginAllowThreads();
6769 result = (int)wxGetDisplayDepth();
6770 wxPyEndAllowThreads(__tstate);
6771 if (PyErr_Occurred()) SWIG_fail;
6772 }
6773 resultobj = SWIG_From_int(static_cast< int >(result));
6774 return resultobj;
6775 fail:
6776 return NULL;
6777 }
6778
6779
6780 SWIGINTERN PyObject *_wrap_DisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6781 PyObject *resultobj = 0;
6782 int *arg1 = (int *) 0 ;
6783 int *arg2 = (int *) 0 ;
6784 int temp1 ;
6785 int res1 = SWIG_TMPOBJ ;
6786 int temp2 ;
6787 int res2 = SWIG_TMPOBJ ;
6788
6789 arg1 = &temp1;
6790 arg2 = &temp2;
6791 if (!SWIG_Python_UnpackTuple(args,"DisplaySize",0,0,0)) SWIG_fail;
6792 {
6793 if (!wxPyCheckForApp()) SWIG_fail;
6794 PyThreadState* __tstate = wxPyBeginAllowThreads();
6795 wxDisplaySize(arg1,arg2);
6796 wxPyEndAllowThreads(__tstate);
6797 if (PyErr_Occurred()) SWIG_fail;
6798 }
6799 resultobj = SWIG_Py_Void();
6800 if (SWIG_IsTmpObj(res1)) {
6801 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6802 } else {
6803 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6804 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6805 }
6806 if (SWIG_IsTmpObj(res2)) {
6807 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6808 } else {
6809 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6810 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6811 }
6812 return resultobj;
6813 fail:
6814 return NULL;
6815 }
6816
6817
6818 SWIGINTERN PyObject *_wrap_GetDisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6819 PyObject *resultobj = 0;
6820 wxSize result;
6821
6822 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySize",0,0,0)) SWIG_fail;
6823 {
6824 if (!wxPyCheckForApp()) SWIG_fail;
6825 PyThreadState* __tstate = wxPyBeginAllowThreads();
6826 result = wxGetDisplaySize();
6827 wxPyEndAllowThreads(__tstate);
6828 if (PyErr_Occurred()) SWIG_fail;
6829 }
6830 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6831 return resultobj;
6832 fail:
6833 return NULL;
6834 }
6835
6836
6837 SWIGINTERN PyObject *_wrap_DisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6838 PyObject *resultobj = 0;
6839 int *arg1 = (int *) 0 ;
6840 int *arg2 = (int *) 0 ;
6841 int temp1 ;
6842 int res1 = SWIG_TMPOBJ ;
6843 int temp2 ;
6844 int res2 = SWIG_TMPOBJ ;
6845
6846 arg1 = &temp1;
6847 arg2 = &temp2;
6848 if (!SWIG_Python_UnpackTuple(args,"DisplaySizeMM",0,0,0)) SWIG_fail;
6849 {
6850 if (!wxPyCheckForApp()) SWIG_fail;
6851 PyThreadState* __tstate = wxPyBeginAllowThreads();
6852 wxDisplaySizeMM(arg1,arg2);
6853 wxPyEndAllowThreads(__tstate);
6854 if (PyErr_Occurred()) SWIG_fail;
6855 }
6856 resultobj = SWIG_Py_Void();
6857 if (SWIG_IsTmpObj(res1)) {
6858 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6859 } else {
6860 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6861 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6862 }
6863 if (SWIG_IsTmpObj(res2)) {
6864 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6865 } else {
6866 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6867 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6868 }
6869 return resultobj;
6870 fail:
6871 return NULL;
6872 }
6873
6874
6875 SWIGINTERN PyObject *_wrap_GetDisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6876 PyObject *resultobj = 0;
6877 wxSize result;
6878
6879 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySizeMM",0,0,0)) SWIG_fail;
6880 {
6881 if (!wxPyCheckForApp()) SWIG_fail;
6882 PyThreadState* __tstate = wxPyBeginAllowThreads();
6883 result = wxGetDisplaySizeMM();
6884 wxPyEndAllowThreads(__tstate);
6885 if (PyErr_Occurred()) SWIG_fail;
6886 }
6887 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6888 return resultobj;
6889 fail:
6890 return NULL;
6891 }
6892
6893
6894 SWIGINTERN PyObject *_wrap_ClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6895 PyObject *resultobj = 0;
6896 int *arg1 = (int *) 0 ;
6897 int *arg2 = (int *) 0 ;
6898 int *arg3 = (int *) 0 ;
6899 int *arg4 = (int *) 0 ;
6900 int temp1 ;
6901 int res1 = SWIG_TMPOBJ ;
6902 int temp2 ;
6903 int res2 = SWIG_TMPOBJ ;
6904 int temp3 ;
6905 int res3 = SWIG_TMPOBJ ;
6906 int temp4 ;
6907 int res4 = SWIG_TMPOBJ ;
6908
6909 arg1 = &temp1;
6910 arg2 = &temp2;
6911 arg3 = &temp3;
6912 arg4 = &temp4;
6913 if (!SWIG_Python_UnpackTuple(args,"ClientDisplayRect",0,0,0)) SWIG_fail;
6914 {
6915 if (!wxPyCheckForApp()) SWIG_fail;
6916 PyThreadState* __tstate = wxPyBeginAllowThreads();
6917 wxClientDisplayRect(arg1,arg2,arg3,arg4);
6918 wxPyEndAllowThreads(__tstate);
6919 if (PyErr_Occurred()) SWIG_fail;
6920 }
6921 resultobj = SWIG_Py_Void();
6922 if (SWIG_IsTmpObj(res1)) {
6923 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6924 } else {
6925 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6926 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6927 }
6928 if (SWIG_IsTmpObj(res2)) {
6929 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6930 } else {
6931 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6932 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6933 }
6934 if (SWIG_IsTmpObj(res3)) {
6935 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6936 } else {
6937 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6938 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6939 }
6940 if (SWIG_IsTmpObj(res4)) {
6941 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
6942 } else {
6943 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6944 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
6945 }
6946 return resultobj;
6947 fail:
6948 return NULL;
6949 }
6950
6951
6952 SWIGINTERN PyObject *_wrap_GetClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6953 PyObject *resultobj = 0;
6954 wxRect result;
6955
6956 if (!SWIG_Python_UnpackTuple(args,"GetClientDisplayRect",0,0,0)) SWIG_fail;
6957 {
6958 if (!wxPyCheckForApp()) SWIG_fail;
6959 PyThreadState* __tstate = wxPyBeginAllowThreads();
6960 result = wxGetClientDisplayRect();
6961 wxPyEndAllowThreads(__tstate);
6962 if (PyErr_Occurred()) SWIG_fail;
6963 }
6964 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6965 return resultobj;
6966 fail:
6967 return NULL;
6968 }
6969
6970
6971 SWIGINTERN PyObject *_wrap_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6972 PyObject *resultobj = 0;
6973 wxCursor *arg1 = 0 ;
6974 void *argp1 = 0 ;
6975 int res1 = 0 ;
6976 PyObject * obj0 = 0 ;
6977 char * kwnames[] = {
6978 (char *) "cursor", NULL
6979 };
6980
6981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) SWIG_fail;
6982 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxCursor, 0 );
6983 if (!SWIG_IsOK(res1)) {
6984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
6985 }
6986 if (!argp1) {
6987 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
6988 }
6989 arg1 = reinterpret_cast< wxCursor * >(argp1);
6990 {
6991 if (!wxPyCheckForApp()) SWIG_fail;
6992 PyThreadState* __tstate = wxPyBeginAllowThreads();
6993 wxSetCursor(*arg1);
6994 wxPyEndAllowThreads(__tstate);
6995 if (PyErr_Occurred()) SWIG_fail;
6996 }
6997 resultobj = SWIG_Py_Void();
6998 return resultobj;
6999 fail:
7000 return NULL;
7001 }
7002
7003
7004 SWIGINTERN PyObject *_wrap_GetXDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7005 PyObject *resultobj = 0;
7006 void *result = 0 ;
7007
7008 if (!SWIG_Python_UnpackTuple(args,"GetXDisplay",0,0,0)) SWIG_fail;
7009 {
7010 if (!wxPyCheckForApp()) SWIG_fail;
7011 PyThreadState* __tstate = wxPyBeginAllowThreads();
7012 result = (void *)wxGetXDisplay();
7013 wxPyEndAllowThreads(__tstate);
7014 if (PyErr_Occurred()) SWIG_fail;
7015 }
7016 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
7017 return resultobj;
7018 fail:
7019 return NULL;
7020 }
7021
7022
7023 SWIGINTERN PyObject *_wrap_BeginBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7024 PyObject *resultobj = 0;
7025 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
7026 void *argp1 = 0 ;
7027 int res1 = 0 ;
7028 PyObject * obj0 = 0 ;
7029 char * kwnames[] = {
7030 (char *) "cursor", NULL
7031 };
7032
7033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) SWIG_fail;
7034 if (obj0) {
7035 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
7036 if (!SWIG_IsOK(res1)) {
7037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeginBusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
7038 }
7039 arg1 = reinterpret_cast< wxCursor * >(argp1);
7040 }
7041 {
7042 if (!wxPyCheckForApp()) SWIG_fail;
7043 PyThreadState* __tstate = wxPyBeginAllowThreads();
7044 wxBeginBusyCursor(arg1);
7045 wxPyEndAllowThreads(__tstate);
7046 if (PyErr_Occurred()) SWIG_fail;
7047 }
7048 resultobj = SWIG_Py_Void();
7049 return resultobj;
7050 fail:
7051 return NULL;
7052 }
7053
7054
7055 SWIGINTERN PyObject *_wrap_GetMousePosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7056 PyObject *resultobj = 0;
7057 wxPoint result;
7058
7059 if (!SWIG_Python_UnpackTuple(args,"GetMousePosition",0,0,0)) SWIG_fail;
7060 {
7061 if (!wxPyCheckForApp()) SWIG_fail;
7062 PyThreadState* __tstate = wxPyBeginAllowThreads();
7063 result = wxGetMousePosition();
7064 wxPyEndAllowThreads(__tstate);
7065 if (PyErr_Occurred()) SWIG_fail;
7066 }
7067 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
7068 return resultobj;
7069 fail:
7070 return NULL;
7071 }
7072
7073
7074 SWIGINTERN PyObject *_wrap_FindWindowAtPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7075 PyObject *resultobj = 0;
7076 wxWindow *result = 0 ;
7077
7078 if (!SWIG_Python_UnpackTuple(args,"FindWindowAtPointer",0,0,0)) SWIG_fail;
7079 {
7080 if (!wxPyCheckForApp()) SWIG_fail;
7081 PyThreadState* __tstate = wxPyBeginAllowThreads();
7082 result = (wxWindow *)FindWindowAtPointer();
7083 wxPyEndAllowThreads(__tstate);
7084 if (PyErr_Occurred()) SWIG_fail;
7085 }
7086 {
7087 resultobj = wxPyMake_wxObject(result, 0);
7088 }
7089 return resultobj;
7090 fail:
7091 return NULL;
7092 }
7093
7094
7095 SWIGINTERN PyObject *_wrap_GetActiveWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7096 PyObject *resultobj = 0;
7097 wxWindow *result = 0 ;
7098
7099 if (!SWIG_Python_UnpackTuple(args,"GetActiveWindow",0,0,0)) SWIG_fail;
7100 {
7101 if (!wxPyCheckForApp()) SWIG_fail;
7102 PyThreadState* __tstate = wxPyBeginAllowThreads();
7103 result = (wxWindow *)wxGetActiveWindow();
7104 wxPyEndAllowThreads(__tstate);
7105 if (PyErr_Occurred()) SWIG_fail;
7106 }
7107 {
7108 resultobj = wxPyMake_wxObject(result, 0);
7109 }
7110 return resultobj;
7111 fail:
7112 return NULL;
7113 }
7114
7115
7116 SWIGINTERN PyObject *_wrap_GenericFindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7117 PyObject *resultobj = 0;
7118 wxPoint *arg1 = 0 ;
7119 wxWindow *result = 0 ;
7120 wxPoint temp1 ;
7121 PyObject * obj0 = 0 ;
7122 char * kwnames[] = {
7123 (char *) "pt", NULL
7124 };
7125
7126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
7127 {
7128 arg1 = &temp1;
7129 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
7130 }
7131 {
7132 if (!wxPyCheckForApp()) SWIG_fail;
7133 PyThreadState* __tstate = wxPyBeginAllowThreads();
7134 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
7135 wxPyEndAllowThreads(__tstate);
7136 if (PyErr_Occurred()) SWIG_fail;
7137 }
7138 {
7139 resultobj = wxPyMake_wxObject(result, 0);
7140 }
7141 return resultobj;
7142 fail:
7143 return NULL;
7144 }
7145
7146
7147 SWIGINTERN PyObject *_wrap_FindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7148 PyObject *resultobj = 0;
7149 wxPoint *arg1 = 0 ;
7150 wxWindow *result = 0 ;
7151 wxPoint temp1 ;
7152 PyObject * obj0 = 0 ;
7153 char * kwnames[] = {
7154 (char *) "pt", NULL
7155 };
7156
7157 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
7158 {
7159 arg1 = &temp1;
7160 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
7161 }
7162 {
7163 if (!wxPyCheckForApp()) SWIG_fail;
7164 PyThreadState* __tstate = wxPyBeginAllowThreads();
7165 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
7166 wxPyEndAllowThreads(__tstate);
7167 if (PyErr_Occurred()) SWIG_fail;
7168 }
7169 {
7170 resultobj = wxPyMake_wxObject(result, 0);
7171 }
7172 return resultobj;
7173 fail:
7174 return NULL;
7175 }
7176
7177
7178 SWIGINTERN PyObject *_wrap_GetTopLevelParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7179 PyObject *resultobj = 0;
7180 wxWindow *arg1 = (wxWindow *) 0 ;
7181 wxWindow *result = 0 ;
7182 void *argp1 = 0 ;
7183 int res1 = 0 ;
7184 PyObject * obj0 = 0 ;
7185 char * kwnames[] = {
7186 (char *) "win", NULL
7187 };
7188
7189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) SWIG_fail;
7190 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
7191 if (!SWIG_IsOK(res1)) {
7192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetTopLevelParent" "', expected argument " "1"" of type '" "wxWindow *""'");
7193 }
7194 arg1 = reinterpret_cast< wxWindow * >(argp1);
7195 {
7196 if (!wxPyCheckForApp()) SWIG_fail;
7197 PyThreadState* __tstate = wxPyBeginAllowThreads();
7198 result = (wxWindow *)wxGetTopLevelParent(arg1);
7199 wxPyEndAllowThreads(__tstate);
7200 if (PyErr_Occurred()) SWIG_fail;
7201 }
7202 {
7203 resultobj = wxPyMake_wxObject(result, 0);
7204 }
7205 return resultobj;
7206 fail:
7207 return NULL;
7208 }
7209
7210
7211 SWIGINTERN PyObject *_wrap_LaunchDefaultBrowser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7212 PyObject *resultobj = 0;
7213 wxString *arg1 = 0 ;
7214 bool result;
7215 bool temp1 = false ;
7216 PyObject * obj0 = 0 ;
7217 char * kwnames[] = {
7218 (char *) "url", NULL
7219 };
7220
7221 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LaunchDefaultBrowser",kwnames,&obj0)) SWIG_fail;
7222 {
7223 arg1 = wxString_in_helper(obj0);
7224 if (arg1 == NULL) SWIG_fail;
7225 temp1 = true;
7226 }
7227 {
7228 PyThreadState* __tstate = wxPyBeginAllowThreads();
7229 result = (bool)wxLaunchDefaultBrowser((wxString const &)*arg1);
7230 wxPyEndAllowThreads(__tstate);
7231 if (PyErr_Occurred()) SWIG_fail;
7232 }
7233 {
7234 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7235 }
7236 {
7237 if (temp1)
7238 delete arg1;
7239 }
7240 return resultobj;
7241 fail:
7242 {
7243 if (temp1)
7244 delete arg1;
7245 }
7246 return NULL;
7247 }
7248
7249
7250 SWIGINTERN PyObject *_wrap_GetKeyState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7251 PyObject *resultobj = 0;
7252 wxKeyCode arg1 ;
7253 bool result;
7254 int val1 ;
7255 int ecode1 = 0 ;
7256 PyObject * obj0 = 0 ;
7257 char * kwnames[] = {
7258 (char *) "key", NULL
7259 };
7260
7261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) SWIG_fail;
7262 ecode1 = SWIG_AsVal_int(obj0, &val1);
7263 if (!SWIG_IsOK(ecode1)) {
7264 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetKeyState" "', expected argument " "1"" of type '" "wxKeyCode""'");
7265 }
7266 arg1 = static_cast< wxKeyCode >(val1);
7267 {
7268 if (!wxPyCheckForApp()) SWIG_fail;
7269 PyThreadState* __tstate = wxPyBeginAllowThreads();
7270 result = (bool)wxGetKeyState(arg1);
7271 wxPyEndAllowThreads(__tstate);
7272 if (PyErr_Occurred()) SWIG_fail;
7273 }
7274 {
7275 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7276 }
7277 return resultobj;
7278 fail:
7279 return NULL;
7280 }
7281
7282
7283 SWIGINTERN PyObject *_wrap_new_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7284 PyObject *resultobj = 0;
7285 wxMouseState *result = 0 ;
7286
7287 if (!SWIG_Python_UnpackTuple(args,"new_MouseState",0,0,0)) SWIG_fail;
7288 {
7289 PyThreadState* __tstate = wxPyBeginAllowThreads();
7290 result = (wxMouseState *)new wxMouseState();
7291 wxPyEndAllowThreads(__tstate);
7292 if (PyErr_Occurred()) SWIG_fail;
7293 }
7294 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseState, SWIG_POINTER_NEW | 0 );
7295 return resultobj;
7296 fail:
7297 return NULL;
7298 }
7299
7300
7301 SWIGINTERN PyObject *_wrap_delete_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7302 PyObject *resultobj = 0;
7303 wxMouseState *arg1 = (wxMouseState *) 0 ;
7304 void *argp1 = 0 ;
7305 int res1 = 0 ;
7306 PyObject *swig_obj[1] ;
7307
7308 if (!args) SWIG_fail;
7309 swig_obj[0] = args;
7310 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, SWIG_POINTER_DISOWN | 0 );
7311 if (!SWIG_IsOK(res1)) {
7312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MouseState" "', expected argument " "1"" of type '" "wxMouseState *""'");
7313 }
7314 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7315 {
7316 PyThreadState* __tstate = wxPyBeginAllowThreads();
7317 delete arg1;
7318
7319 wxPyEndAllowThreads(__tstate);
7320 if (PyErr_Occurred()) SWIG_fail;
7321 }
7322 resultobj = SWIG_Py_Void();
7323 return resultobj;
7324 fail:
7325 return NULL;
7326 }
7327
7328
7329 SWIGINTERN PyObject *_wrap_MouseState_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7330 PyObject *resultobj = 0;
7331 wxMouseState *arg1 = (wxMouseState *) 0 ;
7332 int result;
7333 void *argp1 = 0 ;
7334 int res1 = 0 ;
7335 PyObject *swig_obj[1] ;
7336
7337 if (!args) SWIG_fail;
7338 swig_obj[0] = args;
7339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7340 if (!SWIG_IsOK(res1)) {
7341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7342 }
7343 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7344 {
7345 PyThreadState* __tstate = wxPyBeginAllowThreads();
7346 result = (int)(arg1)->GetX();
7347 wxPyEndAllowThreads(__tstate);
7348 if (PyErr_Occurred()) SWIG_fail;
7349 }
7350 resultobj = SWIG_From_int(static_cast< int >(result));
7351 return resultobj;
7352 fail:
7353 return NULL;
7354 }
7355
7356
7357 SWIGINTERN PyObject *_wrap_MouseState_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7358 PyObject *resultobj = 0;
7359 wxMouseState *arg1 = (wxMouseState *) 0 ;
7360 int result;
7361 void *argp1 = 0 ;
7362 int res1 = 0 ;
7363 PyObject *swig_obj[1] ;
7364
7365 if (!args) SWIG_fail;
7366 swig_obj[0] = args;
7367 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7368 if (!SWIG_IsOK(res1)) {
7369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7370 }
7371 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7372 {
7373 PyThreadState* __tstate = wxPyBeginAllowThreads();
7374 result = (int)(arg1)->GetY();
7375 wxPyEndAllowThreads(__tstate);
7376 if (PyErr_Occurred()) SWIG_fail;
7377 }
7378 resultobj = SWIG_From_int(static_cast< int >(result));
7379 return resultobj;
7380 fail:
7381 return NULL;
7382 }
7383
7384
7385 SWIGINTERN PyObject *_wrap_MouseState_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7386 PyObject *resultobj = 0;
7387 wxMouseState *arg1 = (wxMouseState *) 0 ;
7388 bool result;
7389 void *argp1 = 0 ;
7390 int res1 = 0 ;
7391 PyObject *swig_obj[1] ;
7392
7393 if (!args) SWIG_fail;
7394 swig_obj[0] = args;
7395 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7396 if (!SWIG_IsOK(res1)) {
7397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_LeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7398 }
7399 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7400 {
7401 PyThreadState* __tstate = wxPyBeginAllowThreads();
7402 result = (bool)(arg1)->LeftDown();
7403 wxPyEndAllowThreads(__tstate);
7404 if (PyErr_Occurred()) SWIG_fail;
7405 }
7406 {
7407 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7408 }
7409 return resultobj;
7410 fail:
7411 return NULL;
7412 }
7413
7414
7415 SWIGINTERN PyObject *_wrap_MouseState_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7416 PyObject *resultobj = 0;
7417 wxMouseState *arg1 = (wxMouseState *) 0 ;
7418 bool result;
7419 void *argp1 = 0 ;
7420 int res1 = 0 ;
7421 PyObject *swig_obj[1] ;
7422
7423 if (!args) SWIG_fail;
7424 swig_obj[0] = args;
7425 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7426 if (!SWIG_IsOK(res1)) {
7427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7428 }
7429 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7430 {
7431 PyThreadState* __tstate = wxPyBeginAllowThreads();
7432 result = (bool)(arg1)->MiddleDown();
7433 wxPyEndAllowThreads(__tstate);
7434 if (PyErr_Occurred()) SWIG_fail;
7435 }
7436 {
7437 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7438 }
7439 return resultobj;
7440 fail:
7441 return NULL;
7442 }
7443
7444
7445 SWIGINTERN PyObject *_wrap_MouseState_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7446 PyObject *resultobj = 0;
7447 wxMouseState *arg1 = (wxMouseState *) 0 ;
7448 bool result;
7449 void *argp1 = 0 ;
7450 int res1 = 0 ;
7451 PyObject *swig_obj[1] ;
7452
7453 if (!args) SWIG_fail;
7454 swig_obj[0] = args;
7455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7456 if (!SWIG_IsOK(res1)) {
7457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_RightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7458 }
7459 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7460 {
7461 PyThreadState* __tstate = wxPyBeginAllowThreads();
7462 result = (bool)(arg1)->RightDown();
7463 wxPyEndAllowThreads(__tstate);
7464 if (PyErr_Occurred()) SWIG_fail;
7465 }
7466 {
7467 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7468 }
7469 return resultobj;
7470 fail:
7471 return NULL;
7472 }
7473
7474
7475 SWIGINTERN PyObject *_wrap_MouseState_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7476 PyObject *resultobj = 0;
7477 wxMouseState *arg1 = (wxMouseState *) 0 ;
7478 bool result;
7479 void *argp1 = 0 ;
7480 int res1 = 0 ;
7481 PyObject *swig_obj[1] ;
7482
7483 if (!args) SWIG_fail;
7484 swig_obj[0] = args;
7485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7486 if (!SWIG_IsOK(res1)) {
7487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7488 }
7489 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7490 {
7491 PyThreadState* __tstate = wxPyBeginAllowThreads();
7492 result = (bool)(arg1)->ControlDown();
7493 wxPyEndAllowThreads(__tstate);
7494 if (PyErr_Occurred()) SWIG_fail;
7495 }
7496 {
7497 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7498 }
7499 return resultobj;
7500 fail:
7501 return NULL;
7502 }
7503
7504
7505 SWIGINTERN PyObject *_wrap_MouseState_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7506 PyObject *resultobj = 0;
7507 wxMouseState *arg1 = (wxMouseState *) 0 ;
7508 bool result;
7509 void *argp1 = 0 ;
7510 int res1 = 0 ;
7511 PyObject *swig_obj[1] ;
7512
7513 if (!args) SWIG_fail;
7514 swig_obj[0] = args;
7515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7516 if (!SWIG_IsOK(res1)) {
7517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7518 }
7519 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7520 {
7521 PyThreadState* __tstate = wxPyBeginAllowThreads();
7522 result = (bool)(arg1)->ShiftDown();
7523 wxPyEndAllowThreads(__tstate);
7524 if (PyErr_Occurred()) SWIG_fail;
7525 }
7526 {
7527 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7528 }
7529 return resultobj;
7530 fail:
7531 return NULL;
7532 }
7533
7534
7535 SWIGINTERN PyObject *_wrap_MouseState_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7536 PyObject *resultobj = 0;
7537 wxMouseState *arg1 = (wxMouseState *) 0 ;
7538 bool result;
7539 void *argp1 = 0 ;
7540 int res1 = 0 ;
7541 PyObject *swig_obj[1] ;
7542
7543 if (!args) SWIG_fail;
7544 swig_obj[0] = args;
7545 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7546 if (!SWIG_IsOK(res1)) {
7547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_AltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7548 }
7549 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7550 {
7551 PyThreadState* __tstate = wxPyBeginAllowThreads();
7552 result = (bool)(arg1)->AltDown();
7553 wxPyEndAllowThreads(__tstate);
7554 if (PyErr_Occurred()) SWIG_fail;
7555 }
7556 {
7557 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7558 }
7559 return resultobj;
7560 fail:
7561 return NULL;
7562 }
7563
7564
7565 SWIGINTERN PyObject *_wrap_MouseState_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7566 PyObject *resultobj = 0;
7567 wxMouseState *arg1 = (wxMouseState *) 0 ;
7568 bool result;
7569 void *argp1 = 0 ;
7570 int res1 = 0 ;
7571 PyObject *swig_obj[1] ;
7572
7573 if (!args) SWIG_fail;
7574 swig_obj[0] = args;
7575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7576 if (!SWIG_IsOK(res1)) {
7577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7578 }
7579 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7580 {
7581 PyThreadState* __tstate = wxPyBeginAllowThreads();
7582 result = (bool)(arg1)->MetaDown();
7583 wxPyEndAllowThreads(__tstate);
7584 if (PyErr_Occurred()) SWIG_fail;
7585 }
7586 {
7587 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7588 }
7589 return resultobj;
7590 fail:
7591 return NULL;
7592 }
7593
7594
7595 SWIGINTERN PyObject *_wrap_MouseState_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7596 PyObject *resultobj = 0;
7597 wxMouseState *arg1 = (wxMouseState *) 0 ;
7598 bool result;
7599 void *argp1 = 0 ;
7600 int res1 = 0 ;
7601 PyObject *swig_obj[1] ;
7602
7603 if (!args) SWIG_fail;
7604 swig_obj[0] = args;
7605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7606 if (!SWIG_IsOK(res1)) {
7607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_CmdDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7608 }
7609 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7610 {
7611 PyThreadState* __tstate = wxPyBeginAllowThreads();
7612 result = (bool)(arg1)->CmdDown();
7613 wxPyEndAllowThreads(__tstate);
7614 if (PyErr_Occurred()) SWIG_fail;
7615 }
7616 {
7617 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7618 }
7619 return resultobj;
7620 fail:
7621 return NULL;
7622 }
7623
7624
7625 SWIGINTERN PyObject *_wrap_MouseState_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7626 PyObject *resultobj = 0;
7627 wxMouseState *arg1 = (wxMouseState *) 0 ;
7628 int arg2 ;
7629 void *argp1 = 0 ;
7630 int res1 = 0 ;
7631 int val2 ;
7632 int ecode2 = 0 ;
7633 PyObject * obj0 = 0 ;
7634 PyObject * obj1 = 0 ;
7635 char * kwnames[] = {
7636 (char *) "self",(char *) "x", NULL
7637 };
7638
7639 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
7640 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7641 if (!SWIG_IsOK(res1)) {
7642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7643 }
7644 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7645 ecode2 = SWIG_AsVal_int(obj1, &val2);
7646 if (!SWIG_IsOK(ecode2)) {
7647 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetX" "', expected argument " "2"" of type '" "int""'");
7648 }
7649 arg2 = static_cast< int >(val2);
7650 {
7651 PyThreadState* __tstate = wxPyBeginAllowThreads();
7652 (arg1)->SetX(arg2);
7653 wxPyEndAllowThreads(__tstate);
7654 if (PyErr_Occurred()) SWIG_fail;
7655 }
7656 resultobj = SWIG_Py_Void();
7657 return resultobj;
7658 fail:
7659 return NULL;
7660 }
7661
7662
7663 SWIGINTERN PyObject *_wrap_MouseState_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7664 PyObject *resultobj = 0;
7665 wxMouseState *arg1 = (wxMouseState *) 0 ;
7666 int arg2 ;
7667 void *argp1 = 0 ;
7668 int res1 = 0 ;
7669 int val2 ;
7670 int ecode2 = 0 ;
7671 PyObject * obj0 = 0 ;
7672 PyObject * obj1 = 0 ;
7673 char * kwnames[] = {
7674 (char *) "self",(char *) "y", NULL
7675 };
7676
7677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
7678 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7679 if (!SWIG_IsOK(res1)) {
7680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7681 }
7682 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7683 ecode2 = SWIG_AsVal_int(obj1, &val2);
7684 if (!SWIG_IsOK(ecode2)) {
7685 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetY" "', expected argument " "2"" of type '" "int""'");
7686 }
7687 arg2 = static_cast< int >(val2);
7688 {
7689 PyThreadState* __tstate = wxPyBeginAllowThreads();
7690 (arg1)->SetY(arg2);
7691 wxPyEndAllowThreads(__tstate);
7692 if (PyErr_Occurred()) SWIG_fail;
7693 }
7694 resultobj = SWIG_Py_Void();
7695 return resultobj;
7696 fail:
7697 return NULL;
7698 }
7699
7700
7701 SWIGINTERN PyObject *_wrap_MouseState_SetLeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7702 PyObject *resultobj = 0;
7703 wxMouseState *arg1 = (wxMouseState *) 0 ;
7704 bool arg2 ;
7705 void *argp1 = 0 ;
7706 int res1 = 0 ;
7707 bool val2 ;
7708 int ecode2 = 0 ;
7709 PyObject * obj0 = 0 ;
7710 PyObject * obj1 = 0 ;
7711 char * kwnames[] = {
7712 (char *) "self",(char *) "down", NULL
7713 };
7714
7715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetLeftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7716 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7717 if (!SWIG_IsOK(res1)) {
7718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetLeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7719 }
7720 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7721 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7722 if (!SWIG_IsOK(ecode2)) {
7723 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetLeftDown" "', expected argument " "2"" of type '" "bool""'");
7724 }
7725 arg2 = static_cast< bool >(val2);
7726 {
7727 PyThreadState* __tstate = wxPyBeginAllowThreads();
7728 (arg1)->SetLeftDown(arg2);
7729 wxPyEndAllowThreads(__tstate);
7730 if (PyErr_Occurred()) SWIG_fail;
7731 }
7732 resultobj = SWIG_Py_Void();
7733 return resultobj;
7734 fail:
7735 return NULL;
7736 }
7737
7738
7739 SWIGINTERN PyObject *_wrap_MouseState_SetMiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7740 PyObject *resultobj = 0;
7741 wxMouseState *arg1 = (wxMouseState *) 0 ;
7742 bool arg2 ;
7743 void *argp1 = 0 ;
7744 int res1 = 0 ;
7745 bool val2 ;
7746 int ecode2 = 0 ;
7747 PyObject * obj0 = 0 ;
7748 PyObject * obj1 = 0 ;
7749 char * kwnames[] = {
7750 (char *) "self",(char *) "down", NULL
7751 };
7752
7753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMiddleDown",kwnames,&obj0,&obj1)) SWIG_fail;
7754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7755 if (!SWIG_IsOK(res1)) {
7756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7757 }
7758 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7759 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7760 if (!SWIG_IsOK(ecode2)) {
7761 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMiddleDown" "', expected argument " "2"" of type '" "bool""'");
7762 }
7763 arg2 = static_cast< bool >(val2);
7764 {
7765 PyThreadState* __tstate = wxPyBeginAllowThreads();
7766 (arg1)->SetMiddleDown(arg2);
7767 wxPyEndAllowThreads(__tstate);
7768 if (PyErr_Occurred()) SWIG_fail;
7769 }
7770 resultobj = SWIG_Py_Void();
7771 return resultobj;
7772 fail:
7773 return NULL;
7774 }
7775
7776
7777 SWIGINTERN PyObject *_wrap_MouseState_SetRightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7778 PyObject *resultobj = 0;
7779 wxMouseState *arg1 = (wxMouseState *) 0 ;
7780 bool arg2 ;
7781 void *argp1 = 0 ;
7782 int res1 = 0 ;
7783 bool val2 ;
7784 int ecode2 = 0 ;
7785 PyObject * obj0 = 0 ;
7786 PyObject * obj1 = 0 ;
7787 char * kwnames[] = {
7788 (char *) "self",(char *) "down", NULL
7789 };
7790
7791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetRightDown",kwnames,&obj0,&obj1)) SWIG_fail;
7792 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7793 if (!SWIG_IsOK(res1)) {
7794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetRightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7795 }
7796 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7797 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7798 if (!SWIG_IsOK(ecode2)) {
7799 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetRightDown" "', expected argument " "2"" of type '" "bool""'");
7800 }
7801 arg2 = static_cast< bool >(val2);
7802 {
7803 PyThreadState* __tstate = wxPyBeginAllowThreads();
7804 (arg1)->SetRightDown(arg2);
7805 wxPyEndAllowThreads(__tstate);
7806 if (PyErr_Occurred()) SWIG_fail;
7807 }
7808 resultobj = SWIG_Py_Void();
7809 return resultobj;
7810 fail:
7811 return NULL;
7812 }
7813
7814
7815 SWIGINTERN PyObject *_wrap_MouseState_SetControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7816 PyObject *resultobj = 0;
7817 wxMouseState *arg1 = (wxMouseState *) 0 ;
7818 bool arg2 ;
7819 void *argp1 = 0 ;
7820 int res1 = 0 ;
7821 bool val2 ;
7822 int ecode2 = 0 ;
7823 PyObject * obj0 = 0 ;
7824 PyObject * obj1 = 0 ;
7825 char * kwnames[] = {
7826 (char *) "self",(char *) "down", NULL
7827 };
7828
7829 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetControlDown",kwnames,&obj0,&obj1)) SWIG_fail;
7830 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7831 if (!SWIG_IsOK(res1)) {
7832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7833 }
7834 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7835 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7836 if (!SWIG_IsOK(ecode2)) {
7837 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetControlDown" "', expected argument " "2"" of type '" "bool""'");
7838 }
7839 arg2 = static_cast< bool >(val2);
7840 {
7841 PyThreadState* __tstate = wxPyBeginAllowThreads();
7842 (arg1)->SetControlDown(arg2);
7843 wxPyEndAllowThreads(__tstate);
7844 if (PyErr_Occurred()) SWIG_fail;
7845 }
7846 resultobj = SWIG_Py_Void();
7847 return resultobj;
7848 fail:
7849 return NULL;
7850 }
7851
7852
7853 SWIGINTERN PyObject *_wrap_MouseState_SetShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7854 PyObject *resultobj = 0;
7855 wxMouseState *arg1 = (wxMouseState *) 0 ;
7856 bool arg2 ;
7857 void *argp1 = 0 ;
7858 int res1 = 0 ;
7859 bool val2 ;
7860 int ecode2 = 0 ;
7861 PyObject * obj0 = 0 ;
7862 PyObject * obj1 = 0 ;
7863 char * kwnames[] = {
7864 (char *) "self",(char *) "down", NULL
7865 };
7866
7867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetShiftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7869 if (!SWIG_IsOK(res1)) {
7870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7871 }
7872 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7873 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7874 if (!SWIG_IsOK(ecode2)) {
7875 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetShiftDown" "', expected argument " "2"" of type '" "bool""'");
7876 }
7877 arg2 = static_cast< bool >(val2);
7878 {
7879 PyThreadState* __tstate = wxPyBeginAllowThreads();
7880 (arg1)->SetShiftDown(arg2);
7881 wxPyEndAllowThreads(__tstate);
7882 if (PyErr_Occurred()) SWIG_fail;
7883 }
7884 resultobj = SWIG_Py_Void();
7885 return resultobj;
7886 fail:
7887 return NULL;
7888 }
7889
7890
7891 SWIGINTERN PyObject *_wrap_MouseState_SetAltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7892 PyObject *resultobj = 0;
7893 wxMouseState *arg1 = (wxMouseState *) 0 ;
7894 bool arg2 ;
7895 void *argp1 = 0 ;
7896 int res1 = 0 ;
7897 bool val2 ;
7898 int ecode2 = 0 ;
7899 PyObject * obj0 = 0 ;
7900 PyObject * obj1 = 0 ;
7901 char * kwnames[] = {
7902 (char *) "self",(char *) "down", NULL
7903 };
7904
7905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetAltDown",kwnames,&obj0,&obj1)) SWIG_fail;
7906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7907 if (!SWIG_IsOK(res1)) {
7908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetAltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7909 }
7910 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7911 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7912 if (!SWIG_IsOK(ecode2)) {
7913 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetAltDown" "', expected argument " "2"" of type '" "bool""'");
7914 }
7915 arg2 = static_cast< bool >(val2);
7916 {
7917 PyThreadState* __tstate = wxPyBeginAllowThreads();
7918 (arg1)->SetAltDown(arg2);
7919 wxPyEndAllowThreads(__tstate);
7920 if (PyErr_Occurred()) SWIG_fail;
7921 }
7922 resultobj = SWIG_Py_Void();
7923 return resultobj;
7924 fail:
7925 return NULL;
7926 }
7927
7928
7929 SWIGINTERN PyObject *_wrap_MouseState_SetMetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7930 PyObject *resultobj = 0;
7931 wxMouseState *arg1 = (wxMouseState *) 0 ;
7932 bool arg2 ;
7933 void *argp1 = 0 ;
7934 int res1 = 0 ;
7935 bool val2 ;
7936 int ecode2 = 0 ;
7937 PyObject * obj0 = 0 ;
7938 PyObject * obj1 = 0 ;
7939 char * kwnames[] = {
7940 (char *) "self",(char *) "down", NULL
7941 };
7942
7943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMetaDown",kwnames,&obj0,&obj1)) SWIG_fail;
7944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7945 if (!SWIG_IsOK(res1)) {
7946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7947 }
7948 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7949 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7950 if (!SWIG_IsOK(ecode2)) {
7951 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMetaDown" "', expected argument " "2"" of type '" "bool""'");
7952 }
7953 arg2 = static_cast< bool >(val2);
7954 {
7955 PyThreadState* __tstate = wxPyBeginAllowThreads();
7956 (arg1)->SetMetaDown(arg2);
7957 wxPyEndAllowThreads(__tstate);
7958 if (PyErr_Occurred()) SWIG_fail;
7959 }
7960 resultobj = SWIG_Py_Void();
7961 return resultobj;
7962 fail:
7963 return NULL;
7964 }
7965
7966
7967 SWIGINTERN PyObject *MouseState_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7968 PyObject *obj;
7969 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7970 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseState, SWIG_NewClientData(obj));
7971 return SWIG_Py_Void();
7972 }
7973
7974 SWIGINTERN PyObject *MouseState_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7975 return SWIG_Python_InitShadowInstance(args);
7976 }
7977
7978 SWIGINTERN PyObject *_wrap_GetMouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7979 PyObject *resultobj = 0;
7980 wxMouseState result;
7981
7982 if (!SWIG_Python_UnpackTuple(args,"GetMouseState",0,0,0)) SWIG_fail;
7983 {
7984 PyThreadState* __tstate = wxPyBeginAllowThreads();
7985 result = wxGetMouseState();
7986 wxPyEndAllowThreads(__tstate);
7987 if (PyErr_Occurred()) SWIG_fail;
7988 }
7989 resultobj = SWIG_NewPointerObj((new wxMouseState(static_cast< const wxMouseState& >(result))), SWIGTYPE_p_wxMouseState, SWIG_POINTER_OWN | 0 );
7990 return resultobj;
7991 fail:
7992 return NULL;
7993 }
7994
7995
7996 SWIGINTERN PyObject *_wrap_WakeUpMainThread(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7997 PyObject *resultobj = 0;
7998
7999 if (!SWIG_Python_UnpackTuple(args,"WakeUpMainThread",0,0,0)) SWIG_fail;
8000 {
8001 if (!wxPyCheckForApp()) SWIG_fail;
8002 PyThreadState* __tstate = wxPyBeginAllowThreads();
8003 wxWakeUpMainThread();
8004 wxPyEndAllowThreads(__tstate);
8005 if (PyErr_Occurred()) SWIG_fail;
8006 }
8007 resultobj = SWIG_Py_Void();
8008 return resultobj;
8009 fail:
8010 return NULL;
8011 }
8012
8013
8014 SWIGINTERN PyObject *_wrap_MutexGuiEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8015 PyObject *resultobj = 0;
8016
8017 if (!SWIG_Python_UnpackTuple(args,"MutexGuiEnter",0,0,0)) SWIG_fail;
8018 {
8019 if (!wxPyCheckForApp()) SWIG_fail;
8020 PyThreadState* __tstate = wxPyBeginAllowThreads();
8021 wxMutexGuiEnter();
8022 wxPyEndAllowThreads(__tstate);
8023 if (PyErr_Occurred()) SWIG_fail;
8024 }
8025 resultobj = SWIG_Py_Void();
8026 return resultobj;
8027 fail:
8028 return NULL;
8029 }
8030
8031
8032 SWIGINTERN PyObject *_wrap_MutexGuiLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8033 PyObject *resultobj = 0;
8034
8035 if (!SWIG_Python_UnpackTuple(args,"MutexGuiLeave",0,0,0)) SWIG_fail;
8036 {
8037 if (!wxPyCheckForApp()) SWIG_fail;
8038 PyThreadState* __tstate = wxPyBeginAllowThreads();
8039 wxMutexGuiLeave();
8040 wxPyEndAllowThreads(__tstate);
8041 if (PyErr_Occurred()) SWIG_fail;
8042 }
8043 resultobj = SWIG_Py_Void();
8044 return resultobj;
8045 fail:
8046 return NULL;
8047 }
8048
8049
8050 SWIGINTERN PyObject *_wrap_new_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8051 PyObject *resultobj = 0;
8052 wxMutexGuiLocker *result = 0 ;
8053
8054 if (!SWIG_Python_UnpackTuple(args,"new_MutexGuiLocker",0,0,0)) SWIG_fail;
8055 {
8056 if (!wxPyCheckForApp()) SWIG_fail;
8057 PyThreadState* __tstate = wxPyBeginAllowThreads();
8058 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
8059 wxPyEndAllowThreads(__tstate);
8060 if (PyErr_Occurred()) SWIG_fail;
8061 }
8062 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_NEW | 0 );
8063 return resultobj;
8064 fail:
8065 return NULL;
8066 }
8067
8068
8069 SWIGINTERN PyObject *_wrap_delete_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8070 PyObject *resultobj = 0;
8071 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
8072 void *argp1 = 0 ;
8073 int res1 = 0 ;
8074 PyObject *swig_obj[1] ;
8075
8076 if (!args) SWIG_fail;
8077 swig_obj[0] = args;
8078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_DISOWN | 0 );
8079 if (!SWIG_IsOK(res1)) {
8080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MutexGuiLocker" "', expected argument " "1"" of type '" "wxMutexGuiLocker *""'");
8081 }
8082 arg1 = reinterpret_cast< wxMutexGuiLocker * >(argp1);
8083 {
8084 PyThreadState* __tstate = wxPyBeginAllowThreads();
8085 delete arg1;
8086
8087 wxPyEndAllowThreads(__tstate);
8088 if (PyErr_Occurred()) SWIG_fail;
8089 }
8090 resultobj = SWIG_Py_Void();
8091 return resultobj;
8092 fail:
8093 return NULL;
8094 }
8095
8096
8097 SWIGINTERN PyObject *MutexGuiLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8098 PyObject *obj;
8099 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8100 SWIG_TypeNewClientData(SWIGTYPE_p_wxMutexGuiLocker, SWIG_NewClientData(obj));
8101 return SWIG_Py_Void();
8102 }
8103
8104 SWIGINTERN PyObject *MutexGuiLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8105 return SWIG_Python_InitShadowInstance(args);
8106 }
8107
8108 SWIGINTERN PyObject *_wrap_Thread_IsMain(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8109 PyObject *resultobj = 0;
8110 bool result;
8111
8112 if (!SWIG_Python_UnpackTuple(args,"Thread_IsMain",0,0,0)) SWIG_fail;
8113 {
8114 PyThreadState* __tstate = wxPyBeginAllowThreads();
8115 result = (bool)wxThread_IsMain();
8116 wxPyEndAllowThreads(__tstate);
8117 if (PyErr_Occurred()) SWIG_fail;
8118 }
8119 {
8120 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8121 }
8122 return resultobj;
8123 fail:
8124 return NULL;
8125 }
8126
8127
8128 SWIGINTERN PyObject *_wrap_new_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8129 PyObject *resultobj = 0;
8130 wxString *arg1 = 0 ;
8131 wxToolTip *result = 0 ;
8132 bool temp1 = false ;
8133 PyObject * obj0 = 0 ;
8134 char * kwnames[] = {
8135 (char *) "tip", NULL
8136 };
8137
8138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) SWIG_fail;
8139 {
8140 arg1 = wxString_in_helper(obj0);
8141 if (arg1 == NULL) SWIG_fail;
8142 temp1 = true;
8143 }
8144 {
8145 if (!wxPyCheckForApp()) SWIG_fail;
8146 PyThreadState* __tstate = wxPyBeginAllowThreads();
8147 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
8148 wxPyEndAllowThreads(__tstate);
8149 if (PyErr_Occurred()) SWIG_fail;
8150 }
8151 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxToolTip, SWIG_POINTER_NEW | 0 );
8152 {
8153 if (temp1)
8154 delete arg1;
8155 }
8156 return resultobj;
8157 fail:
8158 {
8159 if (temp1)
8160 delete arg1;
8161 }
8162 return NULL;
8163 }
8164
8165
8166 SWIGINTERN PyObject *_wrap_delete_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8167 PyObject *resultobj = 0;
8168 wxToolTip *arg1 = (wxToolTip *) 0 ;
8169 void *argp1 = 0 ;
8170 int res1 = 0 ;
8171 PyObject *swig_obj[1] ;
8172
8173 if (!args) SWIG_fail;
8174 swig_obj[0] = args;
8175 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
8176 if (!SWIG_IsOK(res1)) {
8177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ToolTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8178 }
8179 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8180 {
8181 PyThreadState* __tstate = wxPyBeginAllowThreads();
8182 delete arg1;
8183
8184 wxPyEndAllowThreads(__tstate);
8185 if (PyErr_Occurred()) SWIG_fail;
8186 }
8187 resultobj = SWIG_Py_Void();
8188 return resultobj;
8189 fail:
8190 return NULL;
8191 }
8192
8193
8194 SWIGINTERN PyObject *_wrap_ToolTip_SetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8195 PyObject *resultobj = 0;
8196 wxToolTip *arg1 = (wxToolTip *) 0 ;
8197 wxString *arg2 = 0 ;
8198 void *argp1 = 0 ;
8199 int res1 = 0 ;
8200 bool temp2 = false ;
8201 PyObject * obj0 = 0 ;
8202 PyObject * obj1 = 0 ;
8203 char * kwnames[] = {
8204 (char *) "self",(char *) "tip", NULL
8205 };
8206
8207 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) SWIG_fail;
8208 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8209 if (!SWIG_IsOK(res1)) {
8210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_SetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8211 }
8212 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8213 {
8214 arg2 = wxString_in_helper(obj1);
8215 if (arg2 == NULL) SWIG_fail;
8216 temp2 = true;
8217 }
8218 {
8219 PyThreadState* __tstate = wxPyBeginAllowThreads();
8220 (arg1)->SetTip((wxString const &)*arg2);
8221 wxPyEndAllowThreads(__tstate);
8222 if (PyErr_Occurred()) SWIG_fail;
8223 }
8224 resultobj = SWIG_Py_Void();
8225 {
8226 if (temp2)
8227 delete arg2;
8228 }
8229 return resultobj;
8230 fail:
8231 {
8232 if (temp2)
8233 delete arg2;
8234 }
8235 return NULL;
8236 }
8237
8238
8239 SWIGINTERN PyObject *_wrap_ToolTip_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8240 PyObject *resultobj = 0;
8241 wxToolTip *arg1 = (wxToolTip *) 0 ;
8242 wxString result;
8243 void *argp1 = 0 ;
8244 int res1 = 0 ;
8245 PyObject *swig_obj[1] ;
8246
8247 if (!args) SWIG_fail;
8248 swig_obj[0] = args;
8249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8250 if (!SWIG_IsOK(res1)) {
8251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8252 }
8253 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8254 {
8255 PyThreadState* __tstate = wxPyBeginAllowThreads();
8256 result = (arg1)->GetTip();
8257 wxPyEndAllowThreads(__tstate);
8258 if (PyErr_Occurred()) SWIG_fail;
8259 }
8260 {
8261 #if wxUSE_UNICODE
8262 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8263 #else
8264 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8265 #endif
8266 }
8267 return resultobj;
8268 fail:
8269 return NULL;
8270 }
8271
8272
8273 SWIGINTERN PyObject *_wrap_ToolTip_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8274 PyObject *resultobj = 0;
8275 wxToolTip *arg1 = (wxToolTip *) 0 ;
8276 wxWindow *result = 0 ;
8277 void *argp1 = 0 ;
8278 int res1 = 0 ;
8279 PyObject *swig_obj[1] ;
8280
8281 if (!args) SWIG_fail;
8282 swig_obj[0] = args;
8283 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8284 if (!SWIG_IsOK(res1)) {
8285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetWindow" "', expected argument " "1"" of type '" "wxToolTip *""'");
8286 }
8287 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8288 {
8289 PyThreadState* __tstate = wxPyBeginAllowThreads();
8290 result = (wxWindow *)(arg1)->GetWindow();
8291 wxPyEndAllowThreads(__tstate);
8292 if (PyErr_Occurred()) SWIG_fail;
8293 }
8294 {
8295 resultobj = wxPyMake_wxObject(result, 0);
8296 }
8297 return resultobj;
8298 fail:
8299 return NULL;
8300 }
8301
8302
8303 SWIGINTERN PyObject *_wrap_ToolTip_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8304 PyObject *resultobj = 0;
8305 bool arg1 ;
8306 bool val1 ;
8307 int ecode1 = 0 ;
8308 PyObject * obj0 = 0 ;
8309 char * kwnames[] = {
8310 (char *) "flag", NULL
8311 };
8312
8313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) SWIG_fail;
8314 ecode1 = SWIG_AsVal_bool(obj0, &val1);
8315 if (!SWIG_IsOK(ecode1)) {
8316 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_Enable" "', expected argument " "1"" of type '" "bool""'");
8317 }
8318 arg1 = static_cast< bool >(val1);
8319 {
8320 PyThreadState* __tstate = wxPyBeginAllowThreads();
8321 wxToolTip::Enable(arg1);
8322 wxPyEndAllowThreads(__tstate);
8323 if (PyErr_Occurred()) SWIG_fail;
8324 }
8325 resultobj = SWIG_Py_Void();
8326 return resultobj;
8327 fail:
8328 return NULL;
8329 }
8330
8331
8332 SWIGINTERN PyObject *_wrap_ToolTip_SetDelay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8333 PyObject *resultobj = 0;
8334 long arg1 ;
8335 long val1 ;
8336 int ecode1 = 0 ;
8337 PyObject * obj0 = 0 ;
8338 char * kwnames[] = {
8339 (char *) "milliseconds", NULL
8340 };
8341
8342 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) SWIG_fail;
8343 ecode1 = SWIG_AsVal_long(obj0, &val1);
8344 if (!SWIG_IsOK(ecode1)) {
8345 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_SetDelay" "', expected argument " "1"" of type '" "long""'");
8346 }
8347 arg1 = static_cast< long >(val1);
8348 {
8349 PyThreadState* __tstate = wxPyBeginAllowThreads();
8350 wxToolTip::SetDelay(arg1);
8351 wxPyEndAllowThreads(__tstate);
8352 if (PyErr_Occurred()) SWIG_fail;
8353 }
8354 resultobj = SWIG_Py_Void();
8355 return resultobj;
8356 fail:
8357 return NULL;
8358 }
8359
8360
8361 SWIGINTERN PyObject *ToolTip_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8362 PyObject *obj;
8363 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8364 SWIG_TypeNewClientData(SWIGTYPE_p_wxToolTip, SWIG_NewClientData(obj));
8365 return SWIG_Py_Void();
8366 }
8367
8368 SWIGINTERN PyObject *ToolTip_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8369 return SWIG_Python_InitShadowInstance(args);
8370 }
8371
8372 SWIGINTERN PyObject *_wrap_new_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8373 PyObject *resultobj = 0;
8374 wxWindow *arg1 = (wxWindow *) 0 ;
8375 wxSize *arg2 = 0 ;
8376 wxCaret *result = 0 ;
8377 void *argp1 = 0 ;
8378 int res1 = 0 ;
8379 wxSize temp2 ;
8380 PyObject * obj0 = 0 ;
8381 PyObject * obj1 = 0 ;
8382 char * kwnames[] = {
8383 (char *) "window",(char *) "size", NULL
8384 };
8385
8386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) SWIG_fail;
8387 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
8388 if (!SWIG_IsOK(res1)) {
8389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Caret" "', expected argument " "1"" of type '" "wxWindow *""'");
8390 }
8391 arg1 = reinterpret_cast< wxWindow * >(argp1);
8392 {
8393 arg2 = &temp2;
8394 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8395 }
8396 {
8397 if (!wxPyCheckForApp()) SWIG_fail;
8398 PyThreadState* __tstate = wxPyBeginAllowThreads();
8399 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
8400 wxPyEndAllowThreads(__tstate);
8401 if (PyErr_Occurred()) SWIG_fail;
8402 }
8403 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, SWIG_POINTER_NEW | 0 );
8404 return resultobj;
8405 fail:
8406 return NULL;
8407 }
8408
8409
8410 SWIGINTERN PyObject *_wrap_delete_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8411 PyObject *resultobj = 0;
8412 wxCaret *arg1 = (wxCaret *) 0 ;
8413 void *argp1 = 0 ;
8414 int res1 = 0 ;
8415 PyObject *swig_obj[1] ;
8416
8417 if (!args) SWIG_fail;
8418 swig_obj[0] = args;
8419 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
8420 if (!SWIG_IsOK(res1)) {
8421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Caret" "', expected argument " "1"" of type '" "wxCaret *""'");
8422 }
8423 arg1 = reinterpret_cast< wxCaret * >(argp1);
8424 {
8425 PyThreadState* __tstate = wxPyBeginAllowThreads();
8426 delete arg1;
8427
8428 wxPyEndAllowThreads(__tstate);
8429 if (PyErr_Occurred()) SWIG_fail;
8430 }
8431 resultobj = SWIG_Py_Void();
8432 return resultobj;
8433 fail:
8434 return NULL;
8435 }
8436
8437
8438 SWIGINTERN PyObject *_wrap_Caret_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8439 PyObject *resultobj = 0;
8440 wxCaret *arg1 = (wxCaret *) 0 ;
8441 void *argp1 = 0 ;
8442 int res1 = 0 ;
8443 PyObject *swig_obj[1] ;
8444
8445 if (!args) SWIG_fail;
8446 swig_obj[0] = args;
8447 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8448 if (!SWIG_IsOK(res1)) {
8449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Destroy" "', expected argument " "1"" of type '" "wxCaret *""'");
8450 }
8451 arg1 = reinterpret_cast< wxCaret * >(argp1);
8452 {
8453 PyThreadState* __tstate = wxPyBeginAllowThreads();
8454 wxCaret_Destroy(arg1);
8455 wxPyEndAllowThreads(__tstate);
8456 if (PyErr_Occurred()) SWIG_fail;
8457 }
8458 resultobj = SWIG_Py_Void();
8459 return resultobj;
8460 fail:
8461 return NULL;
8462 }
8463
8464
8465 SWIGINTERN PyObject *_wrap_Caret_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8466 PyObject *resultobj = 0;
8467 wxCaret *arg1 = (wxCaret *) 0 ;
8468 bool result;
8469 void *argp1 = 0 ;
8470 int res1 = 0 ;
8471 PyObject *swig_obj[1] ;
8472
8473 if (!args) SWIG_fail;
8474 swig_obj[0] = args;
8475 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8476 if (!SWIG_IsOK(res1)) {
8477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsOk" "', expected argument " "1"" of type '" "wxCaret *""'");
8478 }
8479 arg1 = reinterpret_cast< wxCaret * >(argp1);
8480 {
8481 PyThreadState* __tstate = wxPyBeginAllowThreads();
8482 result = (bool)(arg1)->IsOk();
8483 wxPyEndAllowThreads(__tstate);
8484 if (PyErr_Occurred()) SWIG_fail;
8485 }
8486 {
8487 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8488 }
8489 return resultobj;
8490 fail:
8491 return NULL;
8492 }
8493
8494
8495 SWIGINTERN PyObject *_wrap_Caret_IsVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8496 PyObject *resultobj = 0;
8497 wxCaret *arg1 = (wxCaret *) 0 ;
8498 bool result;
8499 void *argp1 = 0 ;
8500 int res1 = 0 ;
8501 PyObject *swig_obj[1] ;
8502
8503 if (!args) SWIG_fail;
8504 swig_obj[0] = args;
8505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8506 if (!SWIG_IsOK(res1)) {
8507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsVisible" "', expected argument " "1"" of type '" "wxCaret *""'");
8508 }
8509 arg1 = reinterpret_cast< wxCaret * >(argp1);
8510 {
8511 PyThreadState* __tstate = wxPyBeginAllowThreads();
8512 result = (bool)(arg1)->IsVisible();
8513 wxPyEndAllowThreads(__tstate);
8514 if (PyErr_Occurred()) SWIG_fail;
8515 }
8516 {
8517 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8518 }
8519 return resultobj;
8520 fail:
8521 return NULL;
8522 }
8523
8524
8525 SWIGINTERN PyObject *_wrap_Caret_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8526 PyObject *resultobj = 0;
8527 wxCaret *arg1 = (wxCaret *) 0 ;
8528 wxPoint result;
8529 void *argp1 = 0 ;
8530 int res1 = 0 ;
8531 PyObject *swig_obj[1] ;
8532
8533 if (!args) SWIG_fail;
8534 swig_obj[0] = args;
8535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8536 if (!SWIG_IsOK(res1)) {
8537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPosition" "', expected argument " "1"" of type '" "wxCaret *""'");
8538 }
8539 arg1 = reinterpret_cast< wxCaret * >(argp1);
8540 {
8541 PyThreadState* __tstate = wxPyBeginAllowThreads();
8542 result = (arg1)->GetPosition();
8543 wxPyEndAllowThreads(__tstate);
8544 if (PyErr_Occurred()) SWIG_fail;
8545 }
8546 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
8547 return resultobj;
8548 fail:
8549 return NULL;
8550 }
8551
8552
8553 SWIGINTERN PyObject *_wrap_Caret_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8554 PyObject *resultobj = 0;
8555 wxCaret *arg1 = (wxCaret *) 0 ;
8556 int *arg2 = (int *) 0 ;
8557 int *arg3 = (int *) 0 ;
8558 void *argp1 = 0 ;
8559 int res1 = 0 ;
8560 int temp2 ;
8561 int res2 = SWIG_TMPOBJ ;
8562 int temp3 ;
8563 int res3 = SWIG_TMPOBJ ;
8564 PyObject *swig_obj[1] ;
8565
8566 arg2 = &temp2;
8567 arg3 = &temp3;
8568 if (!args) SWIG_fail;
8569 swig_obj[0] = args;
8570 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8571 if (!SWIG_IsOK(res1)) {
8572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPositionTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8573 }
8574 arg1 = reinterpret_cast< wxCaret * >(argp1);
8575 {
8576 PyThreadState* __tstate = wxPyBeginAllowThreads();
8577 (arg1)->GetPosition(arg2,arg3);
8578 wxPyEndAllowThreads(__tstate);
8579 if (PyErr_Occurred()) SWIG_fail;
8580 }
8581 resultobj = SWIG_Py_Void();
8582 if (SWIG_IsTmpObj(res2)) {
8583 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8584 } else {
8585 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8586 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8587 }
8588 if (SWIG_IsTmpObj(res3)) {
8589 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8590 } else {
8591 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8592 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8593 }
8594 return resultobj;
8595 fail:
8596 return NULL;
8597 }
8598
8599
8600 SWIGINTERN PyObject *_wrap_Caret_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8601 PyObject *resultobj = 0;
8602 wxCaret *arg1 = (wxCaret *) 0 ;
8603 wxSize result;
8604 void *argp1 = 0 ;
8605 int res1 = 0 ;
8606 PyObject *swig_obj[1] ;
8607
8608 if (!args) SWIG_fail;
8609 swig_obj[0] = args;
8610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8611 if (!SWIG_IsOK(res1)) {
8612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8613 }
8614 arg1 = reinterpret_cast< wxCaret * >(argp1);
8615 {
8616 PyThreadState* __tstate = wxPyBeginAllowThreads();
8617 result = (arg1)->GetSize();
8618 wxPyEndAllowThreads(__tstate);
8619 if (PyErr_Occurred()) SWIG_fail;
8620 }
8621 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
8622 return resultobj;
8623 fail:
8624 return NULL;
8625 }
8626
8627
8628 SWIGINTERN PyObject *_wrap_Caret_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8629 PyObject *resultobj = 0;
8630 wxCaret *arg1 = (wxCaret *) 0 ;
8631 int *arg2 = (int *) 0 ;
8632 int *arg3 = (int *) 0 ;
8633 void *argp1 = 0 ;
8634 int res1 = 0 ;
8635 int temp2 ;
8636 int res2 = SWIG_TMPOBJ ;
8637 int temp3 ;
8638 int res3 = SWIG_TMPOBJ ;
8639 PyObject *swig_obj[1] ;
8640
8641 arg2 = &temp2;
8642 arg3 = &temp3;
8643 if (!args) SWIG_fail;
8644 swig_obj[0] = args;
8645 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8646 if (!SWIG_IsOK(res1)) {
8647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSizeTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8648 }
8649 arg1 = reinterpret_cast< wxCaret * >(argp1);
8650 {
8651 PyThreadState* __tstate = wxPyBeginAllowThreads();
8652 (arg1)->GetSize(arg2,arg3);
8653 wxPyEndAllowThreads(__tstate);
8654 if (PyErr_Occurred()) SWIG_fail;
8655 }
8656 resultobj = SWIG_Py_Void();
8657 if (SWIG_IsTmpObj(res2)) {
8658 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8659 } else {
8660 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8661 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8662 }
8663 if (SWIG_IsTmpObj(res3)) {
8664 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8665 } else {
8666 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8667 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8668 }
8669 return resultobj;
8670 fail:
8671 return NULL;
8672 }
8673
8674
8675 SWIGINTERN PyObject *_wrap_Caret_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8676 PyObject *resultobj = 0;
8677 wxCaret *arg1 = (wxCaret *) 0 ;
8678 wxWindow *result = 0 ;
8679 void *argp1 = 0 ;
8680 int res1 = 0 ;
8681 PyObject *swig_obj[1] ;
8682
8683 if (!args) SWIG_fail;
8684 swig_obj[0] = args;
8685 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8686 if (!SWIG_IsOK(res1)) {
8687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetWindow" "', expected argument " "1"" of type '" "wxCaret *""'");
8688 }
8689 arg1 = reinterpret_cast< wxCaret * >(argp1);
8690 {
8691 PyThreadState* __tstate = wxPyBeginAllowThreads();
8692 result = (wxWindow *)(arg1)->GetWindow();
8693 wxPyEndAllowThreads(__tstate);
8694 if (PyErr_Occurred()) SWIG_fail;
8695 }
8696 {
8697 resultobj = wxPyMake_wxObject(result, 0);
8698 }
8699 return resultobj;
8700 fail:
8701 return NULL;
8702 }
8703
8704
8705 SWIGINTERN PyObject *_wrap_Caret_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8706 PyObject *resultobj = 0;
8707 wxCaret *arg1 = (wxCaret *) 0 ;
8708 int arg2 ;
8709 int arg3 ;
8710 void *argp1 = 0 ;
8711 int res1 = 0 ;
8712 int val2 ;
8713 int ecode2 = 0 ;
8714 int val3 ;
8715 int ecode3 = 0 ;
8716 PyObject * obj0 = 0 ;
8717 PyObject * obj1 = 0 ;
8718 PyObject * obj2 = 0 ;
8719 char * kwnames[] = {
8720 (char *) "self",(char *) "x",(char *) "y", NULL
8721 };
8722
8723 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8724 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8725 if (!SWIG_IsOK(res1)) {
8726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_MoveXY" "', expected argument " "1"" of type '" "wxCaret *""'");
8727 }
8728 arg1 = reinterpret_cast< wxCaret * >(argp1);
8729 ecode2 = SWIG_AsVal_int(obj1, &val2);
8730 if (!SWIG_IsOK(ecode2)) {
8731 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_MoveXY" "', expected argument " "2"" of type '" "int""'");
8732 }
8733 arg2 = static_cast< int >(val2);
8734 ecode3 = SWIG_AsVal_int(obj2, &val3);
8735 if (!SWIG_IsOK(ecode3)) {
8736 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_MoveXY" "', expected argument " "3"" of type '" "int""'");
8737 }
8738 arg3 = static_cast< int >(val3);
8739 {
8740 PyThreadState* __tstate = wxPyBeginAllowThreads();
8741 (arg1)->Move(arg2,arg3);
8742 wxPyEndAllowThreads(__tstate);
8743 if (PyErr_Occurred()) SWIG_fail;
8744 }
8745 resultobj = SWIG_Py_Void();
8746 return resultobj;
8747 fail:
8748 return NULL;
8749 }
8750
8751
8752 SWIGINTERN PyObject *_wrap_Caret_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8753 PyObject *resultobj = 0;
8754 wxCaret *arg1 = (wxCaret *) 0 ;
8755 wxPoint *arg2 = 0 ;
8756 void *argp1 = 0 ;
8757 int res1 = 0 ;
8758 wxPoint temp2 ;
8759 PyObject * obj0 = 0 ;
8760 PyObject * obj1 = 0 ;
8761 char * kwnames[] = {
8762 (char *) "self",(char *) "pt", NULL
8763 };
8764
8765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) SWIG_fail;
8766 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8767 if (!SWIG_IsOK(res1)) {
8768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Move" "', expected argument " "1"" of type '" "wxCaret *""'");
8769 }
8770 arg1 = reinterpret_cast< wxCaret * >(argp1);
8771 {
8772 arg2 = &temp2;
8773 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
8774 }
8775 {
8776 PyThreadState* __tstate = wxPyBeginAllowThreads();
8777 (arg1)->Move((wxPoint const &)*arg2);
8778 wxPyEndAllowThreads(__tstate);
8779 if (PyErr_Occurred()) SWIG_fail;
8780 }
8781 resultobj = SWIG_Py_Void();
8782 return resultobj;
8783 fail:
8784 return NULL;
8785 }
8786
8787
8788 SWIGINTERN PyObject *_wrap_Caret_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8789 PyObject *resultobj = 0;
8790 wxCaret *arg1 = (wxCaret *) 0 ;
8791 int arg2 ;
8792 int arg3 ;
8793 void *argp1 = 0 ;
8794 int res1 = 0 ;
8795 int val2 ;
8796 int ecode2 = 0 ;
8797 int val3 ;
8798 int ecode3 = 0 ;
8799 PyObject * obj0 = 0 ;
8800 PyObject * obj1 = 0 ;
8801 PyObject * obj2 = 0 ;
8802 char * kwnames[] = {
8803 (char *) "self",(char *) "width",(char *) "height", NULL
8804 };
8805
8806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8808 if (!SWIG_IsOK(res1)) {
8809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSizeWH" "', expected argument " "1"" of type '" "wxCaret *""'");
8810 }
8811 arg1 = reinterpret_cast< wxCaret * >(argp1);
8812 ecode2 = SWIG_AsVal_int(obj1, &val2);
8813 if (!SWIG_IsOK(ecode2)) {
8814 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
8815 }
8816 arg2 = static_cast< int >(val2);
8817 ecode3 = SWIG_AsVal_int(obj2, &val3);
8818 if (!SWIG_IsOK(ecode3)) {
8819 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
8820 }
8821 arg3 = static_cast< int >(val3);
8822 {
8823 PyThreadState* __tstate = wxPyBeginAllowThreads();
8824 (arg1)->SetSize(arg2,arg3);
8825 wxPyEndAllowThreads(__tstate);
8826 if (PyErr_Occurred()) SWIG_fail;
8827 }
8828 resultobj = SWIG_Py_Void();
8829 return resultobj;
8830 fail:
8831 return NULL;
8832 }
8833
8834
8835 SWIGINTERN PyObject *_wrap_Caret_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8836 PyObject *resultobj = 0;
8837 wxCaret *arg1 = (wxCaret *) 0 ;
8838 wxSize *arg2 = 0 ;
8839 void *argp1 = 0 ;
8840 int res1 = 0 ;
8841 wxSize temp2 ;
8842 PyObject * obj0 = 0 ;
8843 PyObject * obj1 = 0 ;
8844 char * kwnames[] = {
8845 (char *) "self",(char *) "size", NULL
8846 };
8847
8848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
8849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8850 if (!SWIG_IsOK(res1)) {
8851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8852 }
8853 arg1 = reinterpret_cast< wxCaret * >(argp1);
8854 {
8855 arg2 = &temp2;
8856 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8857 }
8858 {
8859 PyThreadState* __tstate = wxPyBeginAllowThreads();
8860 (arg1)->SetSize((wxSize const &)*arg2);
8861 wxPyEndAllowThreads(__tstate);
8862 if (PyErr_Occurred()) SWIG_fail;
8863 }
8864 resultobj = SWIG_Py_Void();
8865 return resultobj;
8866 fail:
8867 return NULL;
8868 }
8869
8870
8871 SWIGINTERN PyObject *_wrap_Caret_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8872 PyObject *resultobj = 0;
8873 wxCaret *arg1 = (wxCaret *) 0 ;
8874 int arg2 = (int) true ;
8875 void *argp1 = 0 ;
8876 int res1 = 0 ;
8877 int val2 ;
8878 int ecode2 = 0 ;
8879 PyObject * obj0 = 0 ;
8880 PyObject * obj1 = 0 ;
8881 char * kwnames[] = {
8882 (char *) "self",(char *) "show", NULL
8883 };
8884
8885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) SWIG_fail;
8886 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8887 if (!SWIG_IsOK(res1)) {
8888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Show" "', expected argument " "1"" of type '" "wxCaret *""'");
8889 }
8890 arg1 = reinterpret_cast< wxCaret * >(argp1);
8891 if (obj1) {
8892 ecode2 = SWIG_AsVal_int(obj1, &val2);
8893 if (!SWIG_IsOK(ecode2)) {
8894 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_Show" "', expected argument " "2"" of type '" "int""'");
8895 }
8896 arg2 = static_cast< int >(val2);
8897 }
8898 {
8899 PyThreadState* __tstate = wxPyBeginAllowThreads();
8900 (arg1)->Show(arg2);
8901 wxPyEndAllowThreads(__tstate);
8902 if (PyErr_Occurred()) SWIG_fail;
8903 }
8904 resultobj = SWIG_Py_Void();
8905 return resultobj;
8906 fail:
8907 return NULL;
8908 }
8909
8910
8911 SWIGINTERN PyObject *_wrap_Caret_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8912 PyObject *resultobj = 0;
8913 wxCaret *arg1 = (wxCaret *) 0 ;
8914 void *argp1 = 0 ;
8915 int res1 = 0 ;
8916 PyObject *swig_obj[1] ;
8917
8918 if (!args) SWIG_fail;
8919 swig_obj[0] = args;
8920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8921 if (!SWIG_IsOK(res1)) {
8922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Hide" "', expected argument " "1"" of type '" "wxCaret *""'");
8923 }
8924 arg1 = reinterpret_cast< wxCaret * >(argp1);
8925 {
8926 PyThreadState* __tstate = wxPyBeginAllowThreads();
8927 (arg1)->Hide();
8928 wxPyEndAllowThreads(__tstate);
8929 if (PyErr_Occurred()) SWIG_fail;
8930 }
8931 resultobj = SWIG_Py_Void();
8932 return resultobj;
8933 fail:
8934 return NULL;
8935 }
8936
8937
8938 SWIGINTERN PyObject *_wrap_Caret_GetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8939 PyObject *resultobj = 0;
8940 int result;
8941
8942 if (!SWIG_Python_UnpackTuple(args,"Caret_GetBlinkTime",0,0,0)) SWIG_fail;
8943 {
8944 PyThreadState* __tstate = wxPyBeginAllowThreads();
8945 result = (int)wxCaret::GetBlinkTime();
8946 wxPyEndAllowThreads(__tstate);
8947 if (PyErr_Occurred()) SWIG_fail;
8948 }
8949 resultobj = SWIG_From_int(static_cast< int >(result));
8950 return resultobj;
8951 fail:
8952 return NULL;
8953 }
8954
8955
8956 SWIGINTERN PyObject *_wrap_Caret_SetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8957 PyObject *resultobj = 0;
8958 int arg1 ;
8959 int val1 ;
8960 int ecode1 = 0 ;
8961 PyObject * obj0 = 0 ;
8962 char * kwnames[] = {
8963 (char *) "milliseconds", NULL
8964 };
8965
8966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) SWIG_fail;
8967 ecode1 = SWIG_AsVal_int(obj0, &val1);
8968 if (!SWIG_IsOK(ecode1)) {
8969 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Caret_SetBlinkTime" "', expected argument " "1"" of type '" "int""'");
8970 }
8971 arg1 = static_cast< int >(val1);
8972 {
8973 PyThreadState* __tstate = wxPyBeginAllowThreads();
8974 wxCaret::SetBlinkTime(arg1);
8975 wxPyEndAllowThreads(__tstate);
8976 if (PyErr_Occurred()) SWIG_fail;
8977 }
8978 resultobj = SWIG_Py_Void();
8979 return resultobj;
8980 fail:
8981 return NULL;
8982 }
8983
8984
8985 SWIGINTERN PyObject *Caret_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8986 PyObject *obj;
8987 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8988 SWIG_TypeNewClientData(SWIGTYPE_p_wxCaret, SWIG_NewClientData(obj));
8989 return SWIG_Py_Void();
8990 }
8991
8992 SWIGINTERN PyObject *Caret_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8993 return SWIG_Python_InitShadowInstance(args);
8994 }
8995
8996 SWIGINTERN PyObject *_wrap_new_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8997 PyObject *resultobj = 0;
8998 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
8999 wxBusyCursor *result = 0 ;
9000 void *argp1 = 0 ;
9001 int res1 = 0 ;
9002 PyObject * obj0 = 0 ;
9003 char * kwnames[] = {
9004 (char *) "cursor", NULL
9005 };
9006
9007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) SWIG_fail;
9008 if (obj0) {
9009 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
9010 if (!SWIG_IsOK(res1)) {
9011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
9012 }
9013 arg1 = reinterpret_cast< wxCursor * >(argp1);
9014 }
9015 {
9016 if (!wxPyCheckForApp()) SWIG_fail;
9017 PyThreadState* __tstate = wxPyBeginAllowThreads();
9018 result = (wxBusyCursor *)new wxBusyCursor(arg1);
9019 wxPyEndAllowThreads(__tstate);
9020 if (PyErr_Occurred()) SWIG_fail;
9021 }
9022 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_NEW | 0 );
9023 return resultobj;
9024 fail:
9025 return NULL;
9026 }
9027
9028
9029 SWIGINTERN PyObject *_wrap_delete_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9030 PyObject *resultobj = 0;
9031 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
9032 void *argp1 = 0 ;
9033 int res1 = 0 ;
9034 PyObject *swig_obj[1] ;
9035
9036 if (!args) SWIG_fail;
9037 swig_obj[0] = args;
9038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_DISOWN | 0 );
9039 if (!SWIG_IsOK(res1)) {
9040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyCursor" "', expected argument " "1"" of type '" "wxBusyCursor *""'");
9041 }
9042 arg1 = reinterpret_cast< wxBusyCursor * >(argp1);
9043 {
9044 PyThreadState* __tstate = wxPyBeginAllowThreads();
9045 delete arg1;
9046
9047 wxPyEndAllowThreads(__tstate);
9048 if (PyErr_Occurred()) SWIG_fail;
9049 }
9050 resultobj = SWIG_Py_Void();
9051 return resultobj;
9052 fail:
9053 return NULL;
9054 }
9055
9056
9057 SWIGINTERN PyObject *BusyCursor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9058 PyObject *obj;
9059 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9060 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyCursor, SWIG_NewClientData(obj));
9061 return SWIG_Py_Void();
9062 }
9063
9064 SWIGINTERN PyObject *BusyCursor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9065 return SWIG_Python_InitShadowInstance(args);
9066 }
9067
9068 SWIGINTERN PyObject *_wrap_new_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9069 PyObject *resultobj = 0;
9070 wxWindow *arg1 = (wxWindow *) NULL ;
9071 wxWindowDisabler *result = 0 ;
9072 void *argp1 = 0 ;
9073 int res1 = 0 ;
9074 PyObject * obj0 = 0 ;
9075 char * kwnames[] = {
9076 (char *) "winToSkip", NULL
9077 };
9078
9079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) SWIG_fail;
9080 if (obj0) {
9081 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
9082 if (!SWIG_IsOK(res1)) {
9083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDisabler" "', expected argument " "1"" of type '" "wxWindow *""'");
9084 }
9085 arg1 = reinterpret_cast< wxWindow * >(argp1);
9086 }
9087 {
9088 if (!wxPyCheckForApp()) SWIG_fail;
9089 PyThreadState* __tstate = wxPyBeginAllowThreads();
9090 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
9091 wxPyEndAllowThreads(__tstate);
9092 if (PyErr_Occurred()) SWIG_fail;
9093 }
9094 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_NEW | 0 );
9095 return resultobj;
9096 fail:
9097 return NULL;
9098 }
9099
9100
9101 SWIGINTERN PyObject *_wrap_delete_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9102 PyObject *resultobj = 0;
9103 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
9104 void *argp1 = 0 ;
9105 int res1 = 0 ;
9106 PyObject *swig_obj[1] ;
9107
9108 if (!args) SWIG_fail;
9109 swig_obj[0] = args;
9110 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_DISOWN | 0 );
9111 if (!SWIG_IsOK(res1)) {
9112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_WindowDisabler" "', expected argument " "1"" of type '" "wxWindowDisabler *""'");
9113 }
9114 arg1 = reinterpret_cast< wxWindowDisabler * >(argp1);
9115 {
9116 PyThreadState* __tstate = wxPyBeginAllowThreads();
9117 delete arg1;
9118
9119 wxPyEndAllowThreads(__tstate);
9120 if (PyErr_Occurred()) SWIG_fail;
9121 }
9122 resultobj = SWIG_Py_Void();
9123 return resultobj;
9124 fail:
9125 return NULL;
9126 }
9127
9128
9129 SWIGINTERN PyObject *WindowDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9130 PyObject *obj;
9131 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9132 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDisabler, SWIG_NewClientData(obj));
9133 return SWIG_Py_Void();
9134 }
9135
9136 SWIGINTERN PyObject *WindowDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9137 return SWIG_Python_InitShadowInstance(args);
9138 }
9139
9140 SWIGINTERN PyObject *_wrap_new_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9141 PyObject *resultobj = 0;
9142 wxString *arg1 = 0 ;
9143 wxBusyInfo *result = 0 ;
9144 bool temp1 = false ;
9145 PyObject * obj0 = 0 ;
9146 char * kwnames[] = {
9147 (char *) "message", NULL
9148 };
9149
9150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) SWIG_fail;
9151 {
9152 arg1 = wxString_in_helper(obj0);
9153 if (arg1 == NULL) SWIG_fail;
9154 temp1 = true;
9155 }
9156 {
9157 if (!wxPyCheckForApp()) SWIG_fail;
9158 PyThreadState* __tstate = wxPyBeginAllowThreads();
9159 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
9160 wxPyEndAllowThreads(__tstate);
9161 if (PyErr_Occurred()) SWIG_fail;
9162 }
9163 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_NEW | 0 );
9164 {
9165 if (temp1)
9166 delete arg1;
9167 }
9168 return resultobj;
9169 fail:
9170 {
9171 if (temp1)
9172 delete arg1;
9173 }
9174 return NULL;
9175 }
9176
9177
9178 SWIGINTERN PyObject *_wrap_delete_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9179 PyObject *resultobj = 0;
9180 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
9181 void *argp1 = 0 ;
9182 int res1 = 0 ;
9183 PyObject *swig_obj[1] ;
9184
9185 if (!args) SWIG_fail;
9186 swig_obj[0] = args;
9187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_DISOWN | 0 );
9188 if (!SWIG_IsOK(res1)) {
9189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyInfo" "', expected argument " "1"" of type '" "wxBusyInfo *""'");
9190 }
9191 arg1 = reinterpret_cast< wxBusyInfo * >(argp1);
9192 {
9193 PyThreadState* __tstate = wxPyBeginAllowThreads();
9194 delete arg1;
9195
9196 wxPyEndAllowThreads(__tstate);
9197 if (PyErr_Occurred()) SWIG_fail;
9198 }
9199 resultobj = SWIG_Py_Void();
9200 return resultobj;
9201 fail:
9202 return NULL;
9203 }
9204
9205
9206 SWIGINTERN PyObject *BusyInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9207 PyObject *obj;
9208 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9209 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyInfo, SWIG_NewClientData(obj));
9210 return SWIG_Py_Void();
9211 }
9212
9213 SWIGINTERN PyObject *BusyInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9214 return SWIG_Python_InitShadowInstance(args);
9215 }
9216
9217 SWIGINTERN PyObject *_wrap_new_StopWatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9218 PyObject *resultobj = 0;
9219 wxStopWatch *result = 0 ;
9220
9221 if (!SWIG_Python_UnpackTuple(args,"new_StopWatch",0,0,0)) SWIG_fail;
9222 {
9223 PyThreadState* __tstate = wxPyBeginAllowThreads();
9224 result = (wxStopWatch *)new wxStopWatch();
9225 wxPyEndAllowThreads(__tstate);
9226 if (PyErr_Occurred()) SWIG_fail;
9227 }
9228 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStopWatch, SWIG_POINTER_NEW | 0 );
9229 return resultobj;
9230 fail:
9231 return NULL;
9232 }
9233
9234
9235 SWIGINTERN PyObject *_wrap_StopWatch_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9236 PyObject *resultobj = 0;
9237 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9238 long arg2 = (long) 0 ;
9239 void *argp1 = 0 ;
9240 int res1 = 0 ;
9241 long val2 ;
9242 int ecode2 = 0 ;
9243 PyObject * obj0 = 0 ;
9244 PyObject * obj1 = 0 ;
9245 char * kwnames[] = {
9246 (char *) "self",(char *) "t0", NULL
9247 };
9248
9249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) SWIG_fail;
9250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9251 if (!SWIG_IsOK(res1)) {
9252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Start" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9253 }
9254 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9255 if (obj1) {
9256 ecode2 = SWIG_AsVal_long(obj1, &val2);
9257 if (!SWIG_IsOK(ecode2)) {
9258 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StopWatch_Start" "', expected argument " "2"" of type '" "long""'");
9259 }
9260 arg2 = static_cast< long >(val2);
9261 }
9262 {
9263 PyThreadState* __tstate = wxPyBeginAllowThreads();
9264 (arg1)->Start(arg2);
9265 wxPyEndAllowThreads(__tstate);
9266 if (PyErr_Occurred()) SWIG_fail;
9267 }
9268 resultobj = SWIG_Py_Void();
9269 return resultobj;
9270 fail:
9271 return NULL;
9272 }
9273
9274
9275 SWIGINTERN PyObject *_wrap_StopWatch_Pause(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9276 PyObject *resultobj = 0;
9277 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9278 void *argp1 = 0 ;
9279 int res1 = 0 ;
9280 PyObject *swig_obj[1] ;
9281
9282 if (!args) SWIG_fail;
9283 swig_obj[0] = args;
9284 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9285 if (!SWIG_IsOK(res1)) {
9286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Pause" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9287 }
9288 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9289 {
9290 PyThreadState* __tstate = wxPyBeginAllowThreads();
9291 (arg1)->Pause();
9292 wxPyEndAllowThreads(__tstate);
9293 if (PyErr_Occurred()) SWIG_fail;
9294 }
9295 resultobj = SWIG_Py_Void();
9296 return resultobj;
9297 fail:
9298 return NULL;
9299 }
9300
9301
9302 SWIGINTERN PyObject *_wrap_StopWatch_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9303 PyObject *resultobj = 0;
9304 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9305 void *argp1 = 0 ;
9306 int res1 = 0 ;
9307 PyObject *swig_obj[1] ;
9308
9309 if (!args) SWIG_fail;
9310 swig_obj[0] = args;
9311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9312 if (!SWIG_IsOK(res1)) {
9313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Resume" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9314 }
9315 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9316 {
9317 PyThreadState* __tstate = wxPyBeginAllowThreads();
9318 (arg1)->Resume();
9319 wxPyEndAllowThreads(__tstate);
9320 if (PyErr_Occurred()) SWIG_fail;
9321 }
9322 resultobj = SWIG_Py_Void();
9323 return resultobj;
9324 fail:
9325 return NULL;
9326 }
9327
9328
9329 SWIGINTERN PyObject *_wrap_StopWatch_Time(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9330 PyObject *resultobj = 0;
9331 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9332 long result;
9333 void *argp1 = 0 ;
9334 int res1 = 0 ;
9335 PyObject *swig_obj[1] ;
9336
9337 if (!args) SWIG_fail;
9338 swig_obj[0] = args;
9339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9340 if (!SWIG_IsOK(res1)) {
9341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Time" "', expected argument " "1"" of type '" "wxStopWatch const *""'");
9342 }
9343 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9344 {
9345 PyThreadState* __tstate = wxPyBeginAllowThreads();
9346 result = (long)((wxStopWatch const *)arg1)->Time();
9347 wxPyEndAllowThreads(__tstate);
9348 if (PyErr_Occurred()) SWIG_fail;
9349 }
9350 resultobj = SWIG_From_long(static_cast< long >(result));
9351 return resultobj;
9352 fail:
9353 return NULL;
9354 }
9355
9356
9357 SWIGINTERN PyObject *StopWatch_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9358 PyObject *obj;
9359 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9360 SWIG_TypeNewClientData(SWIGTYPE_p_wxStopWatch, SWIG_NewClientData(obj));
9361 return SWIG_Py_Void();
9362 }
9363
9364 SWIGINTERN PyObject *StopWatch_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9365 return SWIG_Python_InitShadowInstance(args);
9366 }
9367
9368 SWIGINTERN PyObject *_wrap_new_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9369 PyObject *resultobj = 0;
9370 int arg1 = (int) 9 ;
9371 int arg2 = (int) wxID_FILE1 ;
9372 wxFileHistory *result = 0 ;
9373 int val1 ;
9374 int ecode1 = 0 ;
9375 int val2 ;
9376 int ecode2 = 0 ;
9377 PyObject * obj0 = 0 ;
9378 PyObject * obj1 = 0 ;
9379 char * kwnames[] = {
9380 (char *) "maxFiles",(char *) "idBase", NULL
9381 };
9382
9383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9384 if (obj0) {
9385 ecode1 = SWIG_AsVal_int(obj0, &val1);
9386 if (!SWIG_IsOK(ecode1)) {
9387 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FileHistory" "', expected argument " "1"" of type '" "int""'");
9388 }
9389 arg1 = static_cast< int >(val1);
9390 }
9391 if (obj1) {
9392 ecode2 = SWIG_AsVal_int(obj1, &val2);
9393 if (!SWIG_IsOK(ecode2)) {
9394 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FileHistory" "', expected argument " "2"" of type '" "int""'");
9395 }
9396 arg2 = static_cast< int >(val2);
9397 }
9398 {
9399 PyThreadState* __tstate = wxPyBeginAllowThreads();
9400 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
9401 wxPyEndAllowThreads(__tstate);
9402 if (PyErr_Occurred()) SWIG_fail;
9403 }
9404 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileHistory, SWIG_POINTER_NEW | 0 );
9405 return resultobj;
9406 fail:
9407 return NULL;
9408 }
9409
9410
9411 SWIGINTERN PyObject *_wrap_delete_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9412 PyObject *resultobj = 0;
9413 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9414 void *argp1 = 0 ;
9415 int res1 = 0 ;
9416 PyObject *swig_obj[1] ;
9417
9418 if (!args) SWIG_fail;
9419 swig_obj[0] = args;
9420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, SWIG_POINTER_DISOWN | 0 );
9421 if (!SWIG_IsOK(res1)) {
9422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9423 }
9424 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9425 {
9426 PyThreadState* __tstate = wxPyBeginAllowThreads();
9427 delete arg1;
9428
9429 wxPyEndAllowThreads(__tstate);
9430 if (PyErr_Occurred()) SWIG_fail;
9431 }
9432 resultobj = SWIG_Py_Void();
9433 return resultobj;
9434 fail:
9435 return NULL;
9436 }
9437
9438
9439 SWIGINTERN PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9440 PyObject *resultobj = 0;
9441 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9442 wxString *arg2 = 0 ;
9443 void *argp1 = 0 ;
9444 int res1 = 0 ;
9445 bool temp2 = false ;
9446 PyObject * obj0 = 0 ;
9447 PyObject * obj1 = 0 ;
9448 char * kwnames[] = {
9449 (char *) "self",(char *) "file", NULL
9450 };
9451
9452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9453 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9454 if (!SWIG_IsOK(res1)) {
9455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFileToHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9456 }
9457 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9458 {
9459 arg2 = wxString_in_helper(obj1);
9460 if (arg2 == NULL) SWIG_fail;
9461 temp2 = true;
9462 }
9463 {
9464 PyThreadState* __tstate = wxPyBeginAllowThreads();
9465 (arg1)->AddFileToHistory((wxString const &)*arg2);
9466 wxPyEndAllowThreads(__tstate);
9467 if (PyErr_Occurred()) SWIG_fail;
9468 }
9469 resultobj = SWIG_Py_Void();
9470 {
9471 if (temp2)
9472 delete arg2;
9473 }
9474 return resultobj;
9475 fail:
9476 {
9477 if (temp2)
9478 delete arg2;
9479 }
9480 return NULL;
9481 }
9482
9483
9484 SWIGINTERN PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9485 PyObject *resultobj = 0;
9486 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9487 int arg2 ;
9488 void *argp1 = 0 ;
9489 int res1 = 0 ;
9490 int val2 ;
9491 int ecode2 = 0 ;
9492 PyObject * obj0 = 0 ;
9493 PyObject * obj1 = 0 ;
9494 char * kwnames[] = {
9495 (char *) "self",(char *) "i", NULL
9496 };
9497
9498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9499 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9500 if (!SWIG_IsOK(res1)) {
9501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9502 }
9503 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9504 ecode2 = SWIG_AsVal_int(obj1, &val2);
9505 if (!SWIG_IsOK(ecode2)) {
9506 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "2"" of type '" "int""'");
9507 }
9508 arg2 = static_cast< int >(val2);
9509 {
9510 PyThreadState* __tstate = wxPyBeginAllowThreads();
9511 (arg1)->RemoveFileFromHistory(arg2);
9512 wxPyEndAllowThreads(__tstate);
9513 if (PyErr_Occurred()) SWIG_fail;
9514 }
9515 resultobj = SWIG_Py_Void();
9516 return resultobj;
9517 fail:
9518 return NULL;
9519 }
9520
9521
9522 SWIGINTERN PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9523 PyObject *resultobj = 0;
9524 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9525 int result;
9526 void *argp1 = 0 ;
9527 int res1 = 0 ;
9528 PyObject *swig_obj[1] ;
9529
9530 if (!args) SWIG_fail;
9531 swig_obj[0] = args;
9532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9533 if (!SWIG_IsOK(res1)) {
9534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetMaxFiles" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9535 }
9536 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9537 {
9538 PyThreadState* __tstate = wxPyBeginAllowThreads();
9539 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
9540 wxPyEndAllowThreads(__tstate);
9541 if (PyErr_Occurred()) SWIG_fail;
9542 }
9543 resultobj = SWIG_From_int(static_cast< int >(result));
9544 return resultobj;
9545 fail:
9546 return NULL;
9547 }
9548
9549
9550 SWIGINTERN PyObject *_wrap_FileHistory_UseMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9551 PyObject *resultobj = 0;
9552 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9553 wxMenu *arg2 = (wxMenu *) 0 ;
9554 void *argp1 = 0 ;
9555 int res1 = 0 ;
9556 void *argp2 = 0 ;
9557 int res2 = 0 ;
9558 PyObject * obj0 = 0 ;
9559 PyObject * obj1 = 0 ;
9560 char * kwnames[] = {
9561 (char *) "self",(char *) "menu", NULL
9562 };
9563
9564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9565 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9566 if (!SWIG_IsOK(res1)) {
9567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_UseMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9568 }
9569 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9570 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9571 if (!SWIG_IsOK(res2)) {
9572 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_UseMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9573 }
9574 arg2 = reinterpret_cast< wxMenu * >(argp2);
9575 {
9576 PyThreadState* __tstate = wxPyBeginAllowThreads();
9577 (arg1)->UseMenu(arg2);
9578 wxPyEndAllowThreads(__tstate);
9579 if (PyErr_Occurred()) SWIG_fail;
9580 }
9581 resultobj = SWIG_Py_Void();
9582 return resultobj;
9583 fail:
9584 return NULL;
9585 }
9586
9587
9588 SWIGINTERN PyObject *_wrap_FileHistory_RemoveMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9589 PyObject *resultobj = 0;
9590 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9591 wxMenu *arg2 = (wxMenu *) 0 ;
9592 void *argp1 = 0 ;
9593 int res1 = 0 ;
9594 void *argp2 = 0 ;
9595 int res2 = 0 ;
9596 PyObject * obj0 = 0 ;
9597 PyObject * obj1 = 0 ;
9598 char * kwnames[] = {
9599 (char *) "self",(char *) "menu", NULL
9600 };
9601
9602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9603 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9604 if (!SWIG_IsOK(res1)) {
9605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9606 }
9607 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9608 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9609 if (!SWIG_IsOK(res2)) {
9610 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_RemoveMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9611 }
9612 arg2 = reinterpret_cast< wxMenu * >(argp2);
9613 {
9614 PyThreadState* __tstate = wxPyBeginAllowThreads();
9615 (arg1)->RemoveMenu(arg2);
9616 wxPyEndAllowThreads(__tstate);
9617 if (PyErr_Occurred()) SWIG_fail;
9618 }
9619 resultobj = SWIG_Py_Void();
9620 return resultobj;
9621 fail:
9622 return NULL;
9623 }
9624
9625
9626 SWIGINTERN PyObject *_wrap_FileHistory_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9627 PyObject *resultobj = 0;
9628 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9629 wxConfigBase *arg2 = 0 ;
9630 void *argp1 = 0 ;
9631 int res1 = 0 ;
9632 void *argp2 = 0 ;
9633 int res2 = 0 ;
9634 PyObject * obj0 = 0 ;
9635 PyObject * obj1 = 0 ;
9636 char * kwnames[] = {
9637 (char *) "self",(char *) "config", NULL
9638 };
9639
9640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) SWIG_fail;
9641 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9642 if (!SWIG_IsOK(res1)) {
9643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Load" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9644 }
9645 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9646 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9647 if (!SWIG_IsOK(res2)) {
9648 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9649 }
9650 if (!argp2) {
9651 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9652 }
9653 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9654 {
9655 PyThreadState* __tstate = wxPyBeginAllowThreads();
9656 (arg1)->Load(*arg2);
9657 wxPyEndAllowThreads(__tstate);
9658 if (PyErr_Occurred()) SWIG_fail;
9659 }
9660 resultobj = SWIG_Py_Void();
9661 return resultobj;
9662 fail:
9663 return NULL;
9664 }
9665
9666
9667 SWIGINTERN PyObject *_wrap_FileHistory_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9668 PyObject *resultobj = 0;
9669 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9670 wxConfigBase *arg2 = 0 ;
9671 void *argp1 = 0 ;
9672 int res1 = 0 ;
9673 void *argp2 = 0 ;
9674 int res2 = 0 ;
9675 PyObject * obj0 = 0 ;
9676 PyObject * obj1 = 0 ;
9677 char * kwnames[] = {
9678 (char *) "self",(char *) "config", NULL
9679 };
9680
9681 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) SWIG_fail;
9682 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9683 if (!SWIG_IsOK(res1)) {
9684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Save" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9685 }
9686 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9687 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9688 if (!SWIG_IsOK(res2)) {
9689 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9690 }
9691 if (!argp2) {
9692 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9693 }
9694 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9695 {
9696 PyThreadState* __tstate = wxPyBeginAllowThreads();
9697 (arg1)->Save(*arg2);
9698 wxPyEndAllowThreads(__tstate);
9699 if (PyErr_Occurred()) SWIG_fail;
9700 }
9701 resultobj = SWIG_Py_Void();
9702 return resultobj;
9703 fail:
9704 return NULL;
9705 }
9706
9707
9708 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9709 PyObject *resultobj = 0;
9710 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9711 void *argp1 = 0 ;
9712 int res1 = 0 ;
9713 PyObject *swig_obj[1] ;
9714
9715 if (!args) SWIG_fail;
9716 swig_obj[0] = args;
9717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9718 if (!SWIG_IsOK(res1)) {
9719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9720 }
9721 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9722 {
9723 PyThreadState* __tstate = wxPyBeginAllowThreads();
9724 (arg1)->AddFilesToMenu();
9725 wxPyEndAllowThreads(__tstate);
9726 if (PyErr_Occurred()) SWIG_fail;
9727 }
9728 resultobj = SWIG_Py_Void();
9729 return resultobj;
9730 fail:
9731 return NULL;
9732 }
9733
9734
9735 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9736 PyObject *resultobj = 0;
9737 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9738 wxMenu *arg2 = (wxMenu *) 0 ;
9739 void *argp1 = 0 ;
9740 int res1 = 0 ;
9741 void *argp2 = 0 ;
9742 int res2 = 0 ;
9743 PyObject * obj0 = 0 ;
9744 PyObject * obj1 = 0 ;
9745 char * kwnames[] = {
9746 (char *) "self",(char *) "menu", NULL
9747 };
9748
9749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9751 if (!SWIG_IsOK(res1)) {
9752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9753 }
9754 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9755 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9756 if (!SWIG_IsOK(res2)) {
9757 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9758 }
9759 arg2 = reinterpret_cast< wxMenu * >(argp2);
9760 {
9761 PyThreadState* __tstate = wxPyBeginAllowThreads();
9762 (arg1)->AddFilesToMenu(arg2);
9763 wxPyEndAllowThreads(__tstate);
9764 if (PyErr_Occurred()) SWIG_fail;
9765 }
9766 resultobj = SWIG_Py_Void();
9767 return resultobj;
9768 fail:
9769 return NULL;
9770 }
9771
9772
9773 SWIGINTERN PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9774 PyObject *resultobj = 0;
9775 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9776 int arg2 ;
9777 wxString result;
9778 void *argp1 = 0 ;
9779 int res1 = 0 ;
9780 int val2 ;
9781 int ecode2 = 0 ;
9782 PyObject * obj0 = 0 ;
9783 PyObject * obj1 = 0 ;
9784 char * kwnames[] = {
9785 (char *) "self",(char *) "i", NULL
9786 };
9787
9788 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) SWIG_fail;
9789 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9790 if (!SWIG_IsOK(res1)) {
9791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9792 }
9793 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9794 ecode2 = SWIG_AsVal_int(obj1, &val2);
9795 if (!SWIG_IsOK(ecode2)) {
9796 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "2"" of type '" "int""'");
9797 }
9798 arg2 = static_cast< int >(val2);
9799 {
9800 PyThreadState* __tstate = wxPyBeginAllowThreads();
9801 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
9802 wxPyEndAllowThreads(__tstate);
9803 if (PyErr_Occurred()) SWIG_fail;
9804 }
9805 {
9806 #if wxUSE_UNICODE
9807 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9808 #else
9809 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9810 #endif
9811 }
9812 return resultobj;
9813 fail:
9814 return NULL;
9815 }
9816
9817
9818 SWIGINTERN PyObject *_wrap_FileHistory_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9819 PyObject *resultobj = 0;
9820 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9821 int result;
9822 void *argp1 = 0 ;
9823 int res1 = 0 ;
9824 PyObject *swig_obj[1] ;
9825
9826 if (!args) SWIG_fail;
9827 swig_obj[0] = args;
9828 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9829 if (!SWIG_IsOK(res1)) {
9830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetCount" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9831 }
9832 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9833 {
9834 PyThreadState* __tstate = wxPyBeginAllowThreads();
9835 result = (int)((wxFileHistory const *)arg1)->GetCount();
9836 wxPyEndAllowThreads(__tstate);
9837 if (PyErr_Occurred()) SWIG_fail;
9838 }
9839 resultobj = SWIG_From_int(static_cast< int >(result));
9840 return resultobj;
9841 fail:
9842 return NULL;
9843 }
9844
9845
9846 SWIGINTERN PyObject *FileHistory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9847 PyObject *obj;
9848 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9849 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileHistory, SWIG_NewClientData(obj));
9850 return SWIG_Py_Void();
9851 }
9852
9853 SWIGINTERN PyObject *FileHistory_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9854 return SWIG_Python_InitShadowInstance(args);
9855 }
9856
9857 SWIGINTERN PyObject *_wrap_new_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9858 PyObject *resultobj = 0;
9859 wxString *arg1 = 0 ;
9860 wxString const &arg2_defvalue = wxPyEmptyString ;
9861 wxString *arg2 = (wxString *) &arg2_defvalue ;
9862 wxSingleInstanceChecker *result = 0 ;
9863 bool temp1 = false ;
9864 bool temp2 = false ;
9865 PyObject * obj0 = 0 ;
9866 PyObject * obj1 = 0 ;
9867 char * kwnames[] = {
9868 (char *) "name",(char *) "path", NULL
9869 };
9870
9871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) SWIG_fail;
9872 {
9873 arg1 = wxString_in_helper(obj0);
9874 if (arg1 == NULL) SWIG_fail;
9875 temp1 = true;
9876 }
9877 if (obj1) {
9878 {
9879 arg2 = wxString_in_helper(obj1);
9880 if (arg2 == NULL) SWIG_fail;
9881 temp2 = true;
9882 }
9883 }
9884 {
9885 PyThreadState* __tstate = wxPyBeginAllowThreads();
9886 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
9887 wxPyEndAllowThreads(__tstate);
9888 if (PyErr_Occurred()) SWIG_fail;
9889 }
9890 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_NEW | 0 );
9891 {
9892 if (temp1)
9893 delete arg1;
9894 }
9895 {
9896 if (temp2)
9897 delete arg2;
9898 }
9899 return resultobj;
9900 fail:
9901 {
9902 if (temp1)
9903 delete arg1;
9904 }
9905 {
9906 if (temp2)
9907 delete arg2;
9908 }
9909 return NULL;
9910 }
9911
9912
9913 SWIGINTERN PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9914 PyObject *resultobj = 0;
9915 wxSingleInstanceChecker *result = 0 ;
9916
9917 if (!SWIG_Python_UnpackTuple(args,"new_PreSingleInstanceChecker",0,0,0)) SWIG_fail;
9918 {
9919 PyThreadState* __tstate = wxPyBeginAllowThreads();
9920 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
9921 wxPyEndAllowThreads(__tstate);
9922 if (PyErr_Occurred()) SWIG_fail;
9923 }
9924 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_OWN | 0 );
9925 return resultobj;
9926 fail:
9927 return NULL;
9928 }
9929
9930
9931 SWIGINTERN PyObject *_wrap_delete_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9932 PyObject *resultobj = 0;
9933 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
9934 void *argp1 = 0 ;
9935 int res1 = 0 ;
9936 PyObject *swig_obj[1] ;
9937
9938 if (!args) SWIG_fail;
9939 swig_obj[0] = args;
9940 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_DISOWN | 0 );
9941 if (!SWIG_IsOK(res1)) {
9942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SingleInstanceChecker" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
9943 }
9944 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
9945 {
9946 PyThreadState* __tstate = wxPyBeginAllowThreads();
9947 delete arg1;
9948
9949 wxPyEndAllowThreads(__tstate);
9950 if (PyErr_Occurred()) SWIG_fail;
9951 }
9952 resultobj = SWIG_Py_Void();
9953 return resultobj;
9954 fail:
9955 return NULL;
9956 }
9957
9958
9959 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9960 PyObject *resultobj = 0;
9961 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
9962 wxString *arg2 = 0 ;
9963 wxString const &arg3_defvalue = wxPyEmptyString ;
9964 wxString *arg3 = (wxString *) &arg3_defvalue ;
9965 bool result;
9966 void *argp1 = 0 ;
9967 int res1 = 0 ;
9968 bool temp2 = false ;
9969 bool temp3 = false ;
9970 PyObject * obj0 = 0 ;
9971 PyObject * obj1 = 0 ;
9972 PyObject * obj2 = 0 ;
9973 char * kwnames[] = {
9974 (char *) "self",(char *) "name",(char *) "path", NULL
9975 };
9976
9977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
9979 if (!SWIG_IsOK(res1)) {
9980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_Create" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
9981 }
9982 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
9983 {
9984 arg2 = wxString_in_helper(obj1);
9985 if (arg2 == NULL) SWIG_fail;
9986 temp2 = true;
9987 }
9988 if (obj2) {
9989 {
9990 arg3 = wxString_in_helper(obj2);
9991 if (arg3 == NULL) SWIG_fail;
9992 temp3 = true;
9993 }
9994 }
9995 {
9996 PyThreadState* __tstate = wxPyBeginAllowThreads();
9997 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
9998 wxPyEndAllowThreads(__tstate);
9999 if (PyErr_Occurred()) SWIG_fail;
10000 }
10001 {
10002 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10003 }
10004 {
10005 if (temp2)
10006 delete arg2;
10007 }
10008 {
10009 if (temp3)
10010 delete arg3;
10011 }
10012 return resultobj;
10013 fail:
10014 {
10015 if (temp2)
10016 delete arg2;
10017 }
10018 {
10019 if (temp3)
10020 delete arg3;
10021 }
10022 return NULL;
10023 }
10024
10025
10026 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10027 PyObject *resultobj = 0;
10028 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
10029 bool result;
10030 void *argp1 = 0 ;
10031 int res1 = 0 ;
10032 PyObject *swig_obj[1] ;
10033
10034 if (!args) SWIG_fail;
10035 swig_obj[0] = args;
10036 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
10037 if (!SWIG_IsOK(res1)) {
10038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_IsAnotherRunning" "', expected argument " "1"" of type '" "wxSingleInstanceChecker const *""'");
10039 }
10040 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
10041 {
10042 PyThreadState* __tstate = wxPyBeginAllowThreads();
10043 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
10044 wxPyEndAllowThreads(__tstate);
10045 if (PyErr_Occurred()) SWIG_fail;
10046 }
10047 {
10048 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10049 }
10050 return resultobj;
10051 fail:
10052 return NULL;
10053 }
10054
10055
10056 SWIGINTERN PyObject *SingleInstanceChecker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10057 PyObject *obj;
10058 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10059 SWIG_TypeNewClientData(SWIGTYPE_p_wxSingleInstanceChecker, SWIG_NewClientData(obj));
10060 return SWIG_Py_Void();
10061 }
10062
10063 SWIGINTERN PyObject *SingleInstanceChecker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10064 return SWIG_Python_InitShadowInstance(args);
10065 }
10066
10067 SWIGINTERN PyObject *_wrap_new_PlatformInformation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10068 PyObject *resultobj = 0;
10069 wxPlatformInfo *result = 0 ;
10070
10071 if (!SWIG_Python_UnpackTuple(args,"new_PlatformInformation",0,0,0)) SWIG_fail;
10072 {
10073 PyThreadState* __tstate = wxPyBeginAllowThreads();
10074 result = (wxPlatformInfo *)new wxPlatformInfo();
10075 wxPyEndAllowThreads(__tstate);
10076 if (PyErr_Occurred()) SWIG_fail;
10077 }
10078 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPlatformInfo, SWIG_POINTER_NEW | 0 );
10079 return resultobj;
10080 fail:
10081 return NULL;
10082 }
10083
10084
10085 SWIGINTERN PyObject *_wrap_PlatformInformation___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10086 PyObject *resultobj = 0;
10087 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10088 wxPlatformInfo *arg2 = 0 ;
10089 bool result;
10090 void *argp1 = 0 ;
10091 int res1 = 0 ;
10092 void *argp2 = 0 ;
10093 int res2 = 0 ;
10094 PyObject * obj0 = 0 ;
10095 PyObject * obj1 = 0 ;
10096 char * kwnames[] = {
10097 (char *) "self",(char *) "t", NULL
10098 };
10099
10100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
10101 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10102 if (!SWIG_IsOK(res1)) {
10103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation___eq__" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10104 }
10105 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10106 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPlatformInfo, 0 | 0);
10107 if (!SWIG_IsOK(res2)) {
10108 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PlatformInformation___eq__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10109 }
10110 if (!argp2) {
10111 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PlatformInformation___eq__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10112 }
10113 arg2 = reinterpret_cast< wxPlatformInfo * >(argp2);
10114 {
10115 PyThreadState* __tstate = wxPyBeginAllowThreads();
10116 result = (bool)((wxPlatformInfo const *)arg1)->operator ==((wxPlatformInfo const &)*arg2);
10117 wxPyEndAllowThreads(__tstate);
10118 if (PyErr_Occurred()) SWIG_fail;
10119 }
10120 {
10121 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10122 }
10123 return resultobj;
10124 fail:
10125 return NULL;
10126 }
10127
10128
10129 SWIGINTERN PyObject *_wrap_PlatformInformation___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10130 PyObject *resultobj = 0;
10131 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10132 wxPlatformInfo *arg2 = 0 ;
10133 bool result;
10134 void *argp1 = 0 ;
10135 int res1 = 0 ;
10136 void *argp2 = 0 ;
10137 int res2 = 0 ;
10138 PyObject * obj0 = 0 ;
10139 PyObject * obj1 = 0 ;
10140 char * kwnames[] = {
10141 (char *) "self",(char *) "t", NULL
10142 };
10143
10144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
10145 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10146 if (!SWIG_IsOK(res1)) {
10147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation___ne__" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10148 }
10149 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10150 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPlatformInfo, 0 | 0);
10151 if (!SWIG_IsOK(res2)) {
10152 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PlatformInformation___ne__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10153 }
10154 if (!argp2) {
10155 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PlatformInformation___ne__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10156 }
10157 arg2 = reinterpret_cast< wxPlatformInfo * >(argp2);
10158 {
10159 PyThreadState* __tstate = wxPyBeginAllowThreads();
10160 result = (bool)((wxPlatformInfo const *)arg1)->operator !=((wxPlatformInfo const &)*arg2);
10161 wxPyEndAllowThreads(__tstate);
10162 if (PyErr_Occurred()) SWIG_fail;
10163 }
10164 {
10165 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10166 }
10167 return resultobj;
10168 fail:
10169 return NULL;
10170 }
10171
10172
10173 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOSMajorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10174 PyObject *resultobj = 0;
10175 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10176 int result;
10177 void *argp1 = 0 ;
10178 int res1 = 0 ;
10179 PyObject *swig_obj[1] ;
10180
10181 if (!args) SWIG_fail;
10182 swig_obj[0] = args;
10183 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10184 if (!SWIG_IsOK(res1)) {
10185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOSMajorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10186 }
10187 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10188 {
10189 PyThreadState* __tstate = wxPyBeginAllowThreads();
10190 result = (int)((wxPlatformInfo const *)arg1)->GetOSMajorVersion();
10191 wxPyEndAllowThreads(__tstate);
10192 if (PyErr_Occurred()) SWIG_fail;
10193 }
10194 resultobj = SWIG_From_int(static_cast< int >(result));
10195 return resultobj;
10196 fail:
10197 return NULL;
10198 }
10199
10200
10201 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOSMinorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10202 PyObject *resultobj = 0;
10203 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10204 int result;
10205 void *argp1 = 0 ;
10206 int res1 = 0 ;
10207 PyObject *swig_obj[1] ;
10208
10209 if (!args) SWIG_fail;
10210 swig_obj[0] = args;
10211 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10212 if (!SWIG_IsOK(res1)) {
10213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOSMinorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10214 }
10215 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10216 {
10217 PyThreadState* __tstate = wxPyBeginAllowThreads();
10218 result = (int)((wxPlatformInfo const *)arg1)->GetOSMinorVersion();
10219 wxPyEndAllowThreads(__tstate);
10220 if (PyErr_Occurred()) SWIG_fail;
10221 }
10222 resultobj = SWIG_From_int(static_cast< int >(result));
10223 return resultobj;
10224 fail:
10225 return NULL;
10226 }
10227
10228
10229 SWIGINTERN PyObject *_wrap_PlatformInformation_GetToolkitMajorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10230 PyObject *resultobj = 0;
10231 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10232 int result;
10233 void *argp1 = 0 ;
10234 int res1 = 0 ;
10235 PyObject *swig_obj[1] ;
10236
10237 if (!args) SWIG_fail;
10238 swig_obj[0] = args;
10239 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10240 if (!SWIG_IsOK(res1)) {
10241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetToolkitMajorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10242 }
10243 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10244 {
10245 PyThreadState* __tstate = wxPyBeginAllowThreads();
10246 result = (int)((wxPlatformInfo const *)arg1)->GetToolkitMajorVersion();
10247 wxPyEndAllowThreads(__tstate);
10248 if (PyErr_Occurred()) SWIG_fail;
10249 }
10250 resultobj = SWIG_From_int(static_cast< int >(result));
10251 return resultobj;
10252 fail:
10253 return NULL;
10254 }
10255
10256
10257 SWIGINTERN PyObject *_wrap_PlatformInformation_GetToolkitMinorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10258 PyObject *resultobj = 0;
10259 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10260 int result;
10261 void *argp1 = 0 ;
10262 int res1 = 0 ;
10263 PyObject *swig_obj[1] ;
10264
10265 if (!args) SWIG_fail;
10266 swig_obj[0] = args;
10267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10268 if (!SWIG_IsOK(res1)) {
10269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetToolkitMinorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10270 }
10271 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10272 {
10273 PyThreadState* __tstate = wxPyBeginAllowThreads();
10274 result = (int)((wxPlatformInfo const *)arg1)->GetToolkitMinorVersion();
10275 wxPyEndAllowThreads(__tstate);
10276 if (PyErr_Occurred()) SWIG_fail;
10277 }
10278 resultobj = SWIG_From_int(static_cast< int >(result));
10279 return resultobj;
10280 fail:
10281 return NULL;
10282 }
10283
10284
10285 SWIGINTERN PyObject *_wrap_PlatformInformation_IsUsingUniversalWidgets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10286 PyObject *resultobj = 0;
10287 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10288 bool result;
10289 void *argp1 = 0 ;
10290 int res1 = 0 ;
10291 PyObject *swig_obj[1] ;
10292
10293 if (!args) SWIG_fail;
10294 swig_obj[0] = args;
10295 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10296 if (!SWIG_IsOK(res1)) {
10297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_IsUsingUniversalWidgets" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10298 }
10299 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10300 {
10301 PyThreadState* __tstate = wxPyBeginAllowThreads();
10302 result = (bool)((wxPlatformInfo const *)arg1)->IsUsingUniversalWidgets();
10303 wxPyEndAllowThreads(__tstate);
10304 if (PyErr_Occurred()) SWIG_fail;
10305 }
10306 {
10307 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10308 }
10309 return resultobj;
10310 fail:
10311 return NULL;
10312 }
10313
10314
10315 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10316 PyObject *resultobj = 0;
10317 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10318 wxOperatingSystemId result;
10319 void *argp1 = 0 ;
10320 int res1 = 0 ;
10321 PyObject *swig_obj[1] ;
10322
10323 if (!args) SWIG_fail;
10324 swig_obj[0] = args;
10325 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10326 if (!SWIG_IsOK(res1)) {
10327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOperatingSystemId" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10328 }
10329 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10330 {
10331 PyThreadState* __tstate = wxPyBeginAllowThreads();
10332 result = (wxOperatingSystemId)((wxPlatformInfo const *)arg1)->GetOperatingSystemId();
10333 wxPyEndAllowThreads(__tstate);
10334 if (PyErr_Occurred()) SWIG_fail;
10335 }
10336 resultobj = SWIG_From_int(static_cast< int >(result));
10337 return resultobj;
10338 fail:
10339 return NULL;
10340 }
10341
10342
10343 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10344 PyObject *resultobj = 0;
10345 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10346 wxPortId result;
10347 void *argp1 = 0 ;
10348 int res1 = 0 ;
10349 PyObject *swig_obj[1] ;
10350
10351 if (!args) SWIG_fail;
10352 swig_obj[0] = args;
10353 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10354 if (!SWIG_IsOK(res1)) {
10355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortId" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10356 }
10357 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10358 {
10359 PyThreadState* __tstate = wxPyBeginAllowThreads();
10360 result = (wxPortId)((wxPlatformInfo const *)arg1)->GetPortId();
10361 wxPyEndAllowThreads(__tstate);
10362 if (PyErr_Occurred()) SWIG_fail;
10363 }
10364 resultobj = SWIG_From_int(static_cast< int >(result));
10365 return resultobj;
10366 fail:
10367 return NULL;
10368 }
10369
10370
10371 SWIGINTERN PyObject *_wrap_PlatformInformation_GetArchitecture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10372 PyObject *resultobj = 0;
10373 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10374 wxArchitecture result;
10375 void *argp1 = 0 ;
10376 int res1 = 0 ;
10377 PyObject *swig_obj[1] ;
10378
10379 if (!args) SWIG_fail;
10380 swig_obj[0] = args;
10381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10382 if (!SWIG_IsOK(res1)) {
10383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetArchitecture" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10384 }
10385 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10386 {
10387 PyThreadState* __tstate = wxPyBeginAllowThreads();
10388 result = (wxArchitecture)((wxPlatformInfo const *)arg1)->GetArchitecture();
10389 wxPyEndAllowThreads(__tstate);
10390 if (PyErr_Occurred()) SWIG_fail;
10391 }
10392 resultobj = SWIG_From_int(static_cast< int >(result));
10393 return resultobj;
10394 fail:
10395 return NULL;
10396 }
10397
10398
10399 SWIGINTERN PyObject *_wrap_PlatformInformation_GetEndianness(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10400 PyObject *resultobj = 0;
10401 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10402 wxEndianness result;
10403 void *argp1 = 0 ;
10404 int res1 = 0 ;
10405 PyObject *swig_obj[1] ;
10406
10407 if (!args) SWIG_fail;
10408 swig_obj[0] = args;
10409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10410 if (!SWIG_IsOK(res1)) {
10411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetEndianness" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10412 }
10413 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10414 {
10415 PyThreadState* __tstate = wxPyBeginAllowThreads();
10416 result = (wxEndianness)((wxPlatformInfo const *)arg1)->GetEndianness();
10417 wxPyEndAllowThreads(__tstate);
10418 if (PyErr_Occurred()) SWIG_fail;
10419 }
10420 resultobj = SWIG_From_int(static_cast< int >(result));
10421 return resultobj;
10422 fail:
10423 return NULL;
10424 }
10425
10426
10427 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemFamilyName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10428 PyObject *resultobj = 0;
10429 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10430 wxString result;
10431 void *argp1 = 0 ;
10432 int res1 = 0 ;
10433 PyObject *swig_obj[1] ;
10434
10435 if (!args) SWIG_fail;
10436 swig_obj[0] = args;
10437 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10438 if (!SWIG_IsOK(res1)) {
10439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOperatingSystemFamilyName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10440 }
10441 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10442 {
10443 PyThreadState* __tstate = wxPyBeginAllowThreads();
10444 result = ((wxPlatformInfo const *)arg1)->GetOperatingSystemFamilyName();
10445 wxPyEndAllowThreads(__tstate);
10446 if (PyErr_Occurred()) SWIG_fail;
10447 }
10448 {
10449 #if wxUSE_UNICODE
10450 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10451 #else
10452 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10453 #endif
10454 }
10455 return resultobj;
10456 fail:
10457 return NULL;
10458 }
10459
10460
10461 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemIdName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10462 PyObject *resultobj = 0;
10463 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10464 wxString result;
10465 void *argp1 = 0 ;
10466 int res1 = 0 ;
10467 PyObject *swig_obj[1] ;
10468
10469 if (!args) SWIG_fail;
10470 swig_obj[0] = args;
10471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10472 if (!SWIG_IsOK(res1)) {
10473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOperatingSystemIdName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10474 }
10475 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10476 {
10477 PyThreadState* __tstate = wxPyBeginAllowThreads();
10478 result = ((wxPlatformInfo const *)arg1)->GetOperatingSystemIdName();
10479 wxPyEndAllowThreads(__tstate);
10480 if (PyErr_Occurred()) SWIG_fail;
10481 }
10482 {
10483 #if wxUSE_UNICODE
10484 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10485 #else
10486 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10487 #endif
10488 }
10489 return resultobj;
10490 fail:
10491 return NULL;
10492 }
10493
10494
10495 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortIdName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10496 PyObject *resultobj = 0;
10497 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10498 wxString result;
10499 void *argp1 = 0 ;
10500 int res1 = 0 ;
10501 PyObject *swig_obj[1] ;
10502
10503 if (!args) SWIG_fail;
10504 swig_obj[0] = args;
10505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10506 if (!SWIG_IsOK(res1)) {
10507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortIdName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10508 }
10509 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10510 {
10511 PyThreadState* __tstate = wxPyBeginAllowThreads();
10512 result = ((wxPlatformInfo const *)arg1)->GetPortIdName();
10513 wxPyEndAllowThreads(__tstate);
10514 if (PyErr_Occurred()) SWIG_fail;
10515 }
10516 {
10517 #if wxUSE_UNICODE
10518 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10519 #else
10520 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10521 #endif
10522 }
10523 return resultobj;
10524 fail:
10525 return NULL;
10526 }
10527
10528
10529 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortIdShortName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10530 PyObject *resultobj = 0;
10531 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10532 wxString result;
10533 void *argp1 = 0 ;
10534 int res1 = 0 ;
10535 PyObject *swig_obj[1] ;
10536
10537 if (!args) SWIG_fail;
10538 swig_obj[0] = args;
10539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10540 if (!SWIG_IsOK(res1)) {
10541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortIdShortName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10542 }
10543 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10544 {
10545 PyThreadState* __tstate = wxPyBeginAllowThreads();
10546 result = ((wxPlatformInfo const *)arg1)->GetPortIdShortName();
10547 wxPyEndAllowThreads(__tstate);
10548 if (PyErr_Occurred()) SWIG_fail;
10549 }
10550 {
10551 #if wxUSE_UNICODE
10552 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10553 #else
10554 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10555 #endif
10556 }
10557 return resultobj;
10558 fail:
10559 return NULL;
10560 }
10561
10562
10563 SWIGINTERN PyObject *_wrap_PlatformInformation_GetArchName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10564 PyObject *resultobj = 0;
10565 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10566 wxString result;
10567 void *argp1 = 0 ;
10568 int res1 = 0 ;
10569 PyObject *swig_obj[1] ;
10570
10571 if (!args) SWIG_fail;
10572 swig_obj[0] = args;
10573 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10574 if (!SWIG_IsOK(res1)) {
10575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetArchName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10576 }
10577 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10578 {
10579 PyThreadState* __tstate = wxPyBeginAllowThreads();
10580 result = ((wxPlatformInfo const *)arg1)->GetArchName();
10581 wxPyEndAllowThreads(__tstate);
10582 if (PyErr_Occurred()) SWIG_fail;
10583 }
10584 {
10585 #if wxUSE_UNICODE
10586 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10587 #else
10588 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10589 #endif
10590 }
10591 return resultobj;
10592 fail:
10593 return NULL;
10594 }
10595
10596
10597 SWIGINTERN PyObject *_wrap_PlatformInformation_GetEndiannessName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10598 PyObject *resultobj = 0;
10599 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10600 wxString result;
10601 void *argp1 = 0 ;
10602 int res1 = 0 ;
10603 PyObject *swig_obj[1] ;
10604
10605 if (!args) SWIG_fail;
10606 swig_obj[0] = args;
10607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10608 if (!SWIG_IsOK(res1)) {
10609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetEndiannessName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10610 }
10611 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10612 {
10613 PyThreadState* __tstate = wxPyBeginAllowThreads();
10614 result = ((wxPlatformInfo const *)arg1)->GetEndiannessName();
10615 wxPyEndAllowThreads(__tstate);
10616 if (PyErr_Occurred()) SWIG_fail;
10617 }
10618 {
10619 #if wxUSE_UNICODE
10620 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10621 #else
10622 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10623 #endif
10624 }
10625 return resultobj;
10626 fail:
10627 return NULL;
10628 }
10629
10630
10631 SWIGINTERN PyObject *_wrap_PlatformInformation_SetOSVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10632 PyObject *resultobj = 0;
10633 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10634 int arg2 ;
10635 int arg3 ;
10636 void *argp1 = 0 ;
10637 int res1 = 0 ;
10638 int val2 ;
10639 int ecode2 = 0 ;
10640 int val3 ;
10641 int ecode3 = 0 ;
10642 PyObject * obj0 = 0 ;
10643 PyObject * obj1 = 0 ;
10644 PyObject * obj2 = 0 ;
10645 char * kwnames[] = {
10646 (char *) "self",(char *) "major",(char *) "minor", NULL
10647 };
10648
10649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_SetOSVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10651 if (!SWIG_IsOK(res1)) {
10652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10653 }
10654 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10655 ecode2 = SWIG_AsVal_int(obj1, &val2);
10656 if (!SWIG_IsOK(ecode2)) {
10657 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "2"" of type '" "int""'");
10658 }
10659 arg2 = static_cast< int >(val2);
10660 ecode3 = SWIG_AsVal_int(obj2, &val3);
10661 if (!SWIG_IsOK(ecode3)) {
10662 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "3"" of type '" "int""'");
10663 }
10664 arg3 = static_cast< int >(val3);
10665 {
10666 PyThreadState* __tstate = wxPyBeginAllowThreads();
10667 (arg1)->SetOSVersion(arg2,arg3);
10668 wxPyEndAllowThreads(__tstate);
10669 if (PyErr_Occurred()) SWIG_fail;
10670 }
10671 resultobj = SWIG_Py_Void();
10672 return resultobj;
10673 fail:
10674 return NULL;
10675 }
10676
10677
10678 SWIGINTERN PyObject *_wrap_PlatformInformation_SetToolkitVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10679 PyObject *resultobj = 0;
10680 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10681 int arg2 ;
10682 int arg3 ;
10683 void *argp1 = 0 ;
10684 int res1 = 0 ;
10685 int val2 ;
10686 int ecode2 = 0 ;
10687 int val3 ;
10688 int ecode3 = 0 ;
10689 PyObject * obj0 = 0 ;
10690 PyObject * obj1 = 0 ;
10691 PyObject * obj2 = 0 ;
10692 char * kwnames[] = {
10693 (char *) "self",(char *) "major",(char *) "minor", NULL
10694 };
10695
10696 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_SetToolkitVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10697 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10698 if (!SWIG_IsOK(res1)) {
10699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetToolkitVersion" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10700 }
10701 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10702 ecode2 = SWIG_AsVal_int(obj1, &val2);
10703 if (!SWIG_IsOK(ecode2)) {
10704 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetToolkitVersion" "', expected argument " "2"" of type '" "int""'");
10705 }
10706 arg2 = static_cast< int >(val2);
10707 ecode3 = SWIG_AsVal_int(obj2, &val3);
10708 if (!SWIG_IsOK(ecode3)) {
10709 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_SetToolkitVersion" "', expected argument " "3"" of type '" "int""'");
10710 }
10711 arg3 = static_cast< int >(val3);
10712 {
10713 PyThreadState* __tstate = wxPyBeginAllowThreads();
10714 (arg1)->SetToolkitVersion(arg2,arg3);
10715 wxPyEndAllowThreads(__tstate);
10716 if (PyErr_Occurred()) SWIG_fail;
10717 }
10718 resultobj = SWIG_Py_Void();
10719 return resultobj;
10720 fail:
10721 return NULL;
10722 }
10723
10724
10725 SWIGINTERN PyObject *_wrap_PlatformInformation_SetOperatingSystemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10726 PyObject *resultobj = 0;
10727 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10728 wxOperatingSystemId arg2 ;
10729 void *argp1 = 0 ;
10730 int res1 = 0 ;
10731 int val2 ;
10732 int ecode2 = 0 ;
10733 PyObject * obj0 = 0 ;
10734 PyObject * obj1 = 0 ;
10735 char * kwnames[] = {
10736 (char *) "self",(char *) "n", NULL
10737 };
10738
10739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetOperatingSystemId",kwnames,&obj0,&obj1)) SWIG_fail;
10740 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10741 if (!SWIG_IsOK(res1)) {
10742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetOperatingSystemId" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10743 }
10744 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10745 ecode2 = SWIG_AsVal_int(obj1, &val2);
10746 if (!SWIG_IsOK(ecode2)) {
10747 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetOperatingSystemId" "', expected argument " "2"" of type '" "wxOperatingSystemId""'");
10748 }
10749 arg2 = static_cast< wxOperatingSystemId >(val2);
10750 {
10751 PyThreadState* __tstate = wxPyBeginAllowThreads();
10752 (arg1)->SetOperatingSystemId(arg2);
10753 wxPyEndAllowThreads(__tstate);
10754 if (PyErr_Occurred()) SWIG_fail;
10755 }
10756 resultobj = SWIG_Py_Void();
10757 return resultobj;
10758 fail:
10759 return NULL;
10760 }
10761
10762
10763 SWIGINTERN PyObject *_wrap_PlatformInformation_SetPortId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10764 PyObject *resultobj = 0;
10765 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10766 wxPortId arg2 ;
10767 void *argp1 = 0 ;
10768 int res1 = 0 ;
10769 int val2 ;
10770 int ecode2 = 0 ;
10771 PyObject * obj0 = 0 ;
10772 PyObject * obj1 = 0 ;
10773 char * kwnames[] = {
10774 (char *) "self",(char *) "n", NULL
10775 };
10776
10777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetPortId",kwnames,&obj0,&obj1)) SWIG_fail;
10778 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10779 if (!SWIG_IsOK(res1)) {
10780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetPortId" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10781 }
10782 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10783 ecode2 = SWIG_AsVal_int(obj1, &val2);
10784 if (!SWIG_IsOK(ecode2)) {
10785 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetPortId" "', expected argument " "2"" of type '" "wxPortId""'");
10786 }
10787 arg2 = static_cast< wxPortId >(val2);
10788 {
10789 PyThreadState* __tstate = wxPyBeginAllowThreads();
10790 (arg1)->SetPortId(arg2);
10791 wxPyEndAllowThreads(__tstate);
10792 if (PyErr_Occurred()) SWIG_fail;
10793 }
10794 resultobj = SWIG_Py_Void();
10795 return resultobj;
10796 fail:
10797 return NULL;
10798 }
10799
10800
10801 SWIGINTERN PyObject *_wrap_PlatformInformation_SetArchitecture(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10802 PyObject *resultobj = 0;
10803 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10804 wxArchitecture arg2 ;
10805 void *argp1 = 0 ;
10806 int res1 = 0 ;
10807 int val2 ;
10808 int ecode2 = 0 ;
10809 PyObject * obj0 = 0 ;
10810 PyObject * obj1 = 0 ;
10811 char * kwnames[] = {
10812 (char *) "self",(char *) "n", NULL
10813 };
10814
10815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetArchitecture",kwnames,&obj0,&obj1)) SWIG_fail;
10816 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10817 if (!SWIG_IsOK(res1)) {
10818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetArchitecture" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10819 }
10820 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10821 ecode2 = SWIG_AsVal_int(obj1, &val2);
10822 if (!SWIG_IsOK(ecode2)) {
10823 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetArchitecture" "', expected argument " "2"" of type '" "wxArchitecture""'");
10824 }
10825 arg2 = static_cast< wxArchitecture >(val2);
10826 {
10827 PyThreadState* __tstate = wxPyBeginAllowThreads();
10828 (arg1)->SetArchitecture(arg2);
10829 wxPyEndAllowThreads(__tstate);
10830 if (PyErr_Occurred()) SWIG_fail;
10831 }
10832 resultobj = SWIG_Py_Void();
10833 return resultobj;
10834 fail:
10835 return NULL;
10836 }
10837
10838
10839 SWIGINTERN PyObject *_wrap_PlatformInformation_SetEndianness(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10840 PyObject *resultobj = 0;
10841 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10842 wxEndianness arg2 ;
10843 void *argp1 = 0 ;
10844 int res1 = 0 ;
10845 int val2 ;
10846 int ecode2 = 0 ;
10847 PyObject * obj0 = 0 ;
10848 PyObject * obj1 = 0 ;
10849 char * kwnames[] = {
10850 (char *) "self",(char *) "n", NULL
10851 };
10852
10853 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetEndianness",kwnames,&obj0,&obj1)) SWIG_fail;
10854 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10855 if (!SWIG_IsOK(res1)) {
10856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetEndianness" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10857 }
10858 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10859 ecode2 = SWIG_AsVal_int(obj1, &val2);
10860 if (!SWIG_IsOK(ecode2)) {
10861 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetEndianness" "', expected argument " "2"" of type '" "wxEndianness""'");
10862 }
10863 arg2 = static_cast< wxEndianness >(val2);
10864 {
10865 PyThreadState* __tstate = wxPyBeginAllowThreads();
10866 (arg1)->SetEndianness(arg2);
10867 wxPyEndAllowThreads(__tstate);
10868 if (PyErr_Occurred()) SWIG_fail;
10869 }
10870 resultobj = SWIG_Py_Void();
10871 return resultobj;
10872 fail:
10873 return NULL;
10874 }
10875
10876
10877 SWIGINTERN PyObject *_wrap_PlatformInformation_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10878 PyObject *resultobj = 0;
10879 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10880 bool result;
10881 void *argp1 = 0 ;
10882 int res1 = 0 ;
10883 PyObject *swig_obj[1] ;
10884
10885 if (!args) SWIG_fail;
10886 swig_obj[0] = args;
10887 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10888 if (!SWIG_IsOK(res1)) {
10889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_IsOk" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10890 }
10891 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10892 {
10893 PyThreadState* __tstate = wxPyBeginAllowThreads();
10894 result = (bool)((wxPlatformInfo const *)arg1)->IsOk();
10895 wxPyEndAllowThreads(__tstate);
10896 if (PyErr_Occurred()) SWIG_fail;
10897 }
10898 {
10899 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10900 }
10901 return resultobj;
10902 fail:
10903 return NULL;
10904 }
10905
10906
10907 SWIGINTERN PyObject *PlatformInformation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10908 PyObject *obj;
10909 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10910 SWIG_TypeNewClientData(SWIGTYPE_p_wxPlatformInfo, SWIG_NewClientData(obj));
10911 return SWIG_Py_Void();
10912 }
10913
10914 SWIGINTERN PyObject *PlatformInformation_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10915 return SWIG_Python_InitShadowInstance(args);
10916 }
10917
10918 SWIGINTERN PyObject *_wrap_DrawWindowOnDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10919 PyObject *resultobj = 0;
10920 wxWindow *arg1 = (wxWindow *) 0 ;
10921 wxDC *arg2 = 0 ;
10922 bool result;
10923 void *argp1 = 0 ;
10924 int res1 = 0 ;
10925 void *argp2 = 0 ;
10926 int res2 = 0 ;
10927 PyObject * obj0 = 0 ;
10928 PyObject * obj1 = 0 ;
10929 char * kwnames[] = {
10930 (char *) "window",(char *) "dc", NULL
10931 };
10932
10933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DrawWindowOnDC",kwnames,&obj0,&obj1)) SWIG_fail;
10934 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
10935 if (!SWIG_IsOK(res1)) {
10936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DrawWindowOnDC" "', expected argument " "1"" of type '" "wxWindow *""'");
10937 }
10938 arg1 = reinterpret_cast< wxWindow * >(argp1);
10939 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
10940 if (!SWIG_IsOK(res2)) {
10941 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
10942 }
10943 if (!argp2) {
10944 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
10945 }
10946 arg2 = reinterpret_cast< wxDC * >(argp2);
10947 {
10948 PyThreadState* __tstate = wxPyBeginAllowThreads();
10949 result = (bool)wxDrawWindowOnDC(arg1,(wxDC const &)*arg2);
10950 wxPyEndAllowThreads(__tstate);
10951 if (PyErr_Occurred()) SWIG_fail;
10952 }
10953 {
10954 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10955 }
10956 return resultobj;
10957 fail:
10958 return NULL;
10959 }
10960
10961
10962 SWIGINTERN PyObject *_wrap_delete_TipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10963 PyObject *resultobj = 0;
10964 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
10965 void *argp1 = 0 ;
10966 int res1 = 0 ;
10967 PyObject *swig_obj[1] ;
10968
10969 if (!args) SWIG_fail;
10970 swig_obj[0] = args;
10971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, SWIG_POINTER_DISOWN | 0 );
10972 if (!SWIG_IsOK(res1)) {
10973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TipProvider" "', expected argument " "1"" of type '" "wxTipProvider *""'");
10974 }
10975 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
10976 {
10977 PyThreadState* __tstate = wxPyBeginAllowThreads();
10978 delete arg1;
10979
10980 wxPyEndAllowThreads(__tstate);
10981 if (PyErr_Occurred()) SWIG_fail;
10982 }
10983 resultobj = SWIG_Py_Void();
10984 return resultobj;
10985 fail:
10986 return NULL;
10987 }
10988
10989
10990 SWIGINTERN PyObject *_wrap_TipProvider_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10991 PyObject *resultobj = 0;
10992 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
10993 wxString result;
10994 void *argp1 = 0 ;
10995 int res1 = 0 ;
10996 PyObject *swig_obj[1] ;
10997
10998 if (!args) SWIG_fail;
10999 swig_obj[0] = args;
11000 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11001 if (!SWIG_IsOK(res1)) {
11002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11003 }
11004 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11005 {
11006 PyThreadState* __tstate = wxPyBeginAllowThreads();
11007 result = (arg1)->GetTip();
11008 wxPyEndAllowThreads(__tstate);
11009 if (PyErr_Occurred()) SWIG_fail;
11010 }
11011 {
11012 #if wxUSE_UNICODE
11013 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11014 #else
11015 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11016 #endif
11017 }
11018 return resultobj;
11019 fail:
11020 return NULL;
11021 }
11022
11023
11024 SWIGINTERN PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11025 PyObject *resultobj = 0;
11026 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11027 size_t result;
11028 void *argp1 = 0 ;
11029 int res1 = 0 ;
11030 PyObject *swig_obj[1] ;
11031
11032 if (!args) SWIG_fail;
11033 swig_obj[0] = args;
11034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11035 if (!SWIG_IsOK(res1)) {
11036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetCurrentTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11037 }
11038 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11039 {
11040 PyThreadState* __tstate = wxPyBeginAllowThreads();
11041 result = (size_t)(arg1)->GetCurrentTip();
11042 wxPyEndAllowThreads(__tstate);
11043 if (PyErr_Occurred()) SWIG_fail;
11044 }
11045 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
11046 return resultobj;
11047 fail:
11048 return NULL;
11049 }
11050
11051
11052 SWIGINTERN PyObject *_wrap_TipProvider_PreprocessTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11053 PyObject *resultobj = 0;
11054 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11055 wxString *arg2 = 0 ;
11056 wxString result;
11057 void *argp1 = 0 ;
11058 int res1 = 0 ;
11059 bool temp2 = false ;
11060 PyObject * obj0 = 0 ;
11061 PyObject * obj1 = 0 ;
11062 char * kwnames[] = {
11063 (char *) "self",(char *) "tip", NULL
11064 };
11065
11066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) SWIG_fail;
11067 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11068 if (!SWIG_IsOK(res1)) {
11069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_PreprocessTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11070 }
11071 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11072 {
11073 arg2 = wxString_in_helper(obj1);
11074 if (arg2 == NULL) SWIG_fail;
11075 temp2 = true;
11076 }
11077 {
11078 PyThreadState* __tstate = wxPyBeginAllowThreads();
11079 result = (arg1)->PreprocessTip((wxString const &)*arg2);
11080 wxPyEndAllowThreads(__tstate);
11081 if (PyErr_Occurred()) SWIG_fail;
11082 }
11083 {
11084 #if wxUSE_UNICODE
11085 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11086 #else
11087 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11088 #endif
11089 }
11090 {
11091 if (temp2)
11092 delete arg2;
11093 }
11094 return resultobj;
11095 fail:
11096 {
11097 if (temp2)
11098 delete arg2;
11099 }
11100 return NULL;
11101 }
11102
11103
11104 SWIGINTERN PyObject *TipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11105 PyObject *obj;
11106 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11107 SWIG_TypeNewClientData(SWIGTYPE_p_wxTipProvider, SWIG_NewClientData(obj));
11108 return SWIG_Py_Void();
11109 }
11110
11111 SWIGINTERN PyObject *_wrap_new_PyTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11112 PyObject *resultobj = 0;
11113 size_t arg1 ;
11114 wxPyTipProvider *result = 0 ;
11115 size_t val1 ;
11116 int ecode1 = 0 ;
11117 PyObject * obj0 = 0 ;
11118 char * kwnames[] = {
11119 (char *) "currentTip", NULL
11120 };
11121
11122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) SWIG_fail;
11123 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
11124 if (!SWIG_IsOK(ecode1)) {
11125 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyTipProvider" "', expected argument " "1"" of type '" "size_t""'");
11126 }
11127 arg1 = static_cast< size_t >(val1);
11128 {
11129 PyThreadState* __tstate = wxPyBeginAllowThreads();
11130 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
11131 wxPyEndAllowThreads(__tstate);
11132 if (PyErr_Occurred()) SWIG_fail;
11133 }
11134 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_NEW | 0 );
11135 return resultobj;
11136 fail:
11137 return NULL;
11138 }
11139
11140
11141 SWIGINTERN PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11142 PyObject *resultobj = 0;
11143 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
11144 PyObject *arg2 = (PyObject *) 0 ;
11145 PyObject *arg3 = (PyObject *) 0 ;
11146 void *argp1 = 0 ;
11147 int res1 = 0 ;
11148 PyObject * obj0 = 0 ;
11149 PyObject * obj1 = 0 ;
11150 PyObject * obj2 = 0 ;
11151 char * kwnames[] = {
11152 (char *) "self",(char *) "self",(char *) "_class", NULL
11153 };
11154
11155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTipProvider, 0 | 0 );
11157 if (!SWIG_IsOK(res1)) {
11158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTipProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTipProvider *""'");
11159 }
11160 arg1 = reinterpret_cast< wxPyTipProvider * >(argp1);
11161 arg2 = obj1;
11162 arg3 = obj2;
11163 {
11164 PyThreadState* __tstate = wxPyBeginAllowThreads();
11165 (arg1)->_setCallbackInfo(arg2,arg3);
11166 wxPyEndAllowThreads(__tstate);
11167 if (PyErr_Occurred()) SWIG_fail;
11168 }
11169 resultobj = SWIG_Py_Void();
11170 return resultobj;
11171 fail:
11172 return NULL;
11173 }
11174
11175
11176 SWIGINTERN PyObject *PyTipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11177 PyObject *obj;
11178 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11179 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTipProvider, SWIG_NewClientData(obj));
11180 return SWIG_Py_Void();
11181 }
11182
11183 SWIGINTERN PyObject *PyTipProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11184 return SWIG_Python_InitShadowInstance(args);
11185 }
11186
11187 SWIGINTERN PyObject *_wrap_ShowTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11188 PyObject *resultobj = 0;
11189 wxWindow *arg1 = (wxWindow *) 0 ;
11190 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
11191 bool arg3 = (bool) true ;
11192 bool result;
11193 void *argp1 = 0 ;
11194 int res1 = 0 ;
11195 void *argp2 = 0 ;
11196 int res2 = 0 ;
11197 bool val3 ;
11198 int ecode3 = 0 ;
11199 PyObject * obj0 = 0 ;
11200 PyObject * obj1 = 0 ;
11201 PyObject * obj2 = 0 ;
11202 char * kwnames[] = {
11203 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
11204 };
11205
11206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11207 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
11208 if (!SWIG_IsOK(res1)) {
11209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowTip" "', expected argument " "1"" of type '" "wxWindow *""'");
11210 }
11211 arg1 = reinterpret_cast< wxWindow * >(argp1);
11212 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11213 if (!SWIG_IsOK(res2)) {
11214 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShowTip" "', expected argument " "2"" of type '" "wxTipProvider *""'");
11215 }
11216 arg2 = reinterpret_cast< wxTipProvider * >(argp2);
11217 if (obj2) {
11218 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11219 if (!SWIG_IsOK(ecode3)) {
11220 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ShowTip" "', expected argument " "3"" of type '" "bool""'");
11221 }
11222 arg3 = static_cast< bool >(val3);
11223 }
11224 {
11225 if (!wxPyCheckForApp()) SWIG_fail;
11226 PyThreadState* __tstate = wxPyBeginAllowThreads();
11227 result = (bool)wxShowTip(arg1,arg2,arg3);
11228 wxPyEndAllowThreads(__tstate);
11229 if (PyErr_Occurred()) SWIG_fail;
11230 }
11231 {
11232 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11233 }
11234 return resultobj;
11235 fail:
11236 return NULL;
11237 }
11238
11239
11240 SWIGINTERN PyObject *_wrap_CreateFileTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11241 PyObject *resultobj = 0;
11242 wxString *arg1 = 0 ;
11243 size_t arg2 ;
11244 wxTipProvider *result = 0 ;
11245 bool temp1 = false ;
11246 size_t val2 ;
11247 int ecode2 = 0 ;
11248 PyObject * obj0 = 0 ;
11249 PyObject * obj1 = 0 ;
11250 char * kwnames[] = {
11251 (char *) "filename",(char *) "currentTip", NULL
11252 };
11253
11254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) SWIG_fail;
11255 {
11256 arg1 = wxString_in_helper(obj0);
11257 if (arg1 == NULL) SWIG_fail;
11258 temp1 = true;
11259 }
11260 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
11261 if (!SWIG_IsOK(ecode2)) {
11262 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CreateFileTipProvider" "', expected argument " "2"" of type '" "size_t""'");
11263 }
11264 arg2 = static_cast< size_t >(val2);
11265 {
11266 if (!wxPyCheckForApp()) SWIG_fail;
11267 PyThreadState* __tstate = wxPyBeginAllowThreads();
11268 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
11269 wxPyEndAllowThreads(__tstate);
11270 if (PyErr_Occurred()) SWIG_fail;
11271 }
11272 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTipProvider, SWIG_POINTER_OWN | 0 );
11273 {
11274 if (temp1)
11275 delete arg1;
11276 }
11277 return resultobj;
11278 fail:
11279 {
11280 if (temp1)
11281 delete arg1;
11282 }
11283 return NULL;
11284 }
11285
11286
11287 SWIGINTERN PyObject *_wrap_new_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11288 PyObject *resultobj = 0;
11289 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
11290 int arg2 = (int) wxID_ANY ;
11291 wxPyTimer *result = 0 ;
11292 void *argp1 = 0 ;
11293 int res1 = 0 ;
11294 int val2 ;
11295 int ecode2 = 0 ;
11296 PyObject * obj0 = 0 ;
11297 PyObject * obj1 = 0 ;
11298 char * kwnames[] = {
11299 (char *) "owner",(char *) "id", NULL
11300 };
11301
11302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) SWIG_fail;
11303 if (obj0) {
11304 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
11305 if (!SWIG_IsOK(res1)) {
11306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Timer" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
11307 }
11308 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
11309 }
11310 if (obj1) {
11311 ecode2 = SWIG_AsVal_int(obj1, &val2);
11312 if (!SWIG_IsOK(ecode2)) {
11313 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Timer" "', expected argument " "2"" of type '" "int""'");
11314 }
11315 arg2 = static_cast< int >(val2);
11316 }
11317 {
11318 if (!wxPyCheckForApp()) SWIG_fail;
11319 PyThreadState* __tstate = wxPyBeginAllowThreads();
11320 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
11321 wxPyEndAllowThreads(__tstate);
11322 if (PyErr_Occurred()) SWIG_fail;
11323 }
11324 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTimer, SWIG_POINTER_NEW | 0 );
11325 return resultobj;
11326 fail:
11327 return NULL;
11328 }
11329
11330
11331 SWIGINTERN PyObject *_wrap_delete_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11332 PyObject *resultobj = 0;
11333 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11334 void *argp1 = 0 ;
11335 int res1 = 0 ;
11336 PyObject *swig_obj[1] ;
11337
11338 if (!args) SWIG_fail;
11339 swig_obj[0] = args;
11340 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, SWIG_POINTER_DISOWN | 0 );
11341 if (!SWIG_IsOK(res1)) {
11342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Timer" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11343 }
11344 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11345 {
11346 PyThreadState* __tstate = wxPyBeginAllowThreads();
11347 delete arg1;
11348
11349 wxPyEndAllowThreads(__tstate);
11350 if (PyErr_Occurred()) SWIG_fail;
11351 }
11352 resultobj = SWIG_Py_Void();
11353 return resultobj;
11354 fail:
11355 return NULL;
11356 }
11357
11358
11359 SWIGINTERN PyObject *_wrap_Timer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11360 PyObject *resultobj = 0;
11361 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11362 PyObject *arg2 = (PyObject *) 0 ;
11363 PyObject *arg3 = (PyObject *) 0 ;
11364 int arg4 = (int) 1 ;
11365 void *argp1 = 0 ;
11366 int res1 = 0 ;
11367 int val4 ;
11368 int ecode4 = 0 ;
11369 PyObject * obj0 = 0 ;
11370 PyObject * obj1 = 0 ;
11371 PyObject * obj2 = 0 ;
11372 PyObject * obj3 = 0 ;
11373 char * kwnames[] = {
11374 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
11375 };
11376
11377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11378 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11379 if (!SWIG_IsOK(res1)) {
11380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11381 }
11382 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11383 arg2 = obj1;
11384 arg3 = obj2;
11385 if (obj3) {
11386 ecode4 = SWIG_AsVal_int(obj3, &val4);
11387 if (!SWIG_IsOK(ecode4)) {
11388 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Timer__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
11389 }
11390 arg4 = static_cast< int >(val4);
11391 }
11392 {
11393 PyThreadState* __tstate = wxPyBeginAllowThreads();
11394 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
11395 wxPyEndAllowThreads(__tstate);
11396 if (PyErr_Occurred()) SWIG_fail;
11397 }
11398 resultobj = SWIG_Py_Void();
11399 return resultobj;
11400 fail:
11401 return NULL;
11402 }
11403
11404
11405 SWIGINTERN PyObject *_wrap_Timer_SetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11406 PyObject *resultobj = 0;
11407 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11408 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
11409 int arg3 = (int) wxID_ANY ;
11410 void *argp1 = 0 ;
11411 int res1 = 0 ;
11412 void *argp2 = 0 ;
11413 int res2 = 0 ;
11414 int val3 ;
11415 int ecode3 = 0 ;
11416 PyObject * obj0 = 0 ;
11417 PyObject * obj1 = 0 ;
11418 PyObject * obj2 = 0 ;
11419 char * kwnames[] = {
11420 (char *) "self",(char *) "owner",(char *) "id", NULL
11421 };
11422
11423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11424 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11425 if (!SWIG_IsOK(res1)) {
11426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_SetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11427 }
11428 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11429 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
11430 if (!SWIG_IsOK(res2)) {
11431 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Timer_SetOwner" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
11432 }
11433 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
11434 if (obj2) {
11435 ecode3 = SWIG_AsVal_int(obj2, &val3);
11436 if (!SWIG_IsOK(ecode3)) {
11437 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_SetOwner" "', expected argument " "3"" of type '" "int""'");
11438 }
11439 arg3 = static_cast< int >(val3);
11440 }
11441 {
11442 PyThreadState* __tstate = wxPyBeginAllowThreads();
11443 (arg1)->SetOwner(arg2,arg3);
11444 wxPyEndAllowThreads(__tstate);
11445 if (PyErr_Occurred()) SWIG_fail;
11446 }
11447 resultobj = SWIG_Py_Void();
11448 return resultobj;
11449 fail:
11450 return NULL;
11451 }
11452
11453
11454 SWIGINTERN PyObject *_wrap_Timer_GetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11455 PyObject *resultobj = 0;
11456 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11457 wxEvtHandler *result = 0 ;
11458 void *argp1 = 0 ;
11459 int res1 = 0 ;
11460 PyObject *swig_obj[1] ;
11461
11462 if (!args) SWIG_fail;
11463 swig_obj[0] = args;
11464 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11465 if (!SWIG_IsOK(res1)) {
11466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11467 }
11468 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11469 {
11470 PyThreadState* __tstate = wxPyBeginAllowThreads();
11471 result = (wxEvtHandler *)(arg1)->GetOwner();
11472 wxPyEndAllowThreads(__tstate);
11473 if (PyErr_Occurred()) SWIG_fail;
11474 }
11475 {
11476 resultobj = wxPyMake_wxObject(result, 0);
11477 }
11478 return resultobj;
11479 fail:
11480 return NULL;
11481 }
11482
11483
11484 SWIGINTERN PyObject *_wrap_Timer_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11485 PyObject *resultobj = 0;
11486 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11487 int arg2 = (int) -1 ;
11488 bool arg3 = (bool) false ;
11489 bool result;
11490 void *argp1 = 0 ;
11491 int res1 = 0 ;
11492 int val2 ;
11493 int ecode2 = 0 ;
11494 bool val3 ;
11495 int ecode3 = 0 ;
11496 PyObject * obj0 = 0 ;
11497 PyObject * obj1 = 0 ;
11498 PyObject * obj2 = 0 ;
11499 char * kwnames[] = {
11500 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
11501 };
11502
11503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11505 if (!SWIG_IsOK(res1)) {
11506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Start" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11507 }
11508 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11509 if (obj1) {
11510 ecode2 = SWIG_AsVal_int(obj1, &val2);
11511 if (!SWIG_IsOK(ecode2)) {
11512 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Timer_Start" "', expected argument " "2"" of type '" "int""'");
11513 }
11514 arg2 = static_cast< int >(val2);
11515 }
11516 if (obj2) {
11517 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11518 if (!SWIG_IsOK(ecode3)) {
11519 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_Start" "', expected argument " "3"" of type '" "bool""'");
11520 }
11521 arg3 = static_cast< bool >(val3);
11522 }
11523 {
11524 PyThreadState* __tstate = wxPyBeginAllowThreads();
11525 result = (bool)(arg1)->Start(arg2,arg3);
11526 wxPyEndAllowThreads(__tstate);
11527 if (PyErr_Occurred()) SWIG_fail;
11528 }
11529 {
11530 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11531 }
11532 return resultobj;
11533 fail:
11534 return NULL;
11535 }
11536
11537
11538 SWIGINTERN PyObject *_wrap_Timer_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11539 PyObject *resultobj = 0;
11540 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11541 void *argp1 = 0 ;
11542 int res1 = 0 ;
11543 PyObject *swig_obj[1] ;
11544
11545 if (!args) SWIG_fail;
11546 swig_obj[0] = args;
11547 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11548 if (!SWIG_IsOK(res1)) {
11549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Stop" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11550 }
11551 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11552 {
11553 PyThreadState* __tstate = wxPyBeginAllowThreads();
11554 (arg1)->Stop();
11555 wxPyEndAllowThreads(__tstate);
11556 if (PyErr_Occurred()) SWIG_fail;
11557 }
11558 resultobj = SWIG_Py_Void();
11559 return resultobj;
11560 fail:
11561 return NULL;
11562 }
11563
11564
11565 SWIGINTERN PyObject *_wrap_Timer_Notify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11566 PyObject *resultobj = 0;
11567 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11568 void *argp1 = 0 ;
11569 int res1 = 0 ;
11570 PyObject *swig_obj[1] ;
11571
11572 if (!args) SWIG_fail;
11573 swig_obj[0] = args;
11574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11575 if (!SWIG_IsOK(res1)) {
11576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Notify" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11577 }
11578 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11579 {
11580 PyThreadState* __tstate = wxPyBeginAllowThreads();
11581 (arg1)->Notify();
11582 wxPyEndAllowThreads(__tstate);
11583 if (PyErr_Occurred()) SWIG_fail;
11584 }
11585 resultobj = SWIG_Py_Void();
11586 return resultobj;
11587 fail:
11588 return NULL;
11589 }
11590
11591
11592 SWIGINTERN PyObject *_wrap_Timer_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11593 PyObject *resultobj = 0;
11594 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11595 bool result;
11596 void *argp1 = 0 ;
11597 int res1 = 0 ;
11598 PyObject *swig_obj[1] ;
11599
11600 if (!args) SWIG_fail;
11601 swig_obj[0] = args;
11602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11603 if (!SWIG_IsOK(res1)) {
11604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsRunning" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11605 }
11606 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11607 {
11608 PyThreadState* __tstate = wxPyBeginAllowThreads();
11609 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
11610 wxPyEndAllowThreads(__tstate);
11611 if (PyErr_Occurred()) SWIG_fail;
11612 }
11613 {
11614 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11615 }
11616 return resultobj;
11617 fail:
11618 return NULL;
11619 }
11620
11621
11622 SWIGINTERN PyObject *_wrap_Timer_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11623 PyObject *resultobj = 0;
11624 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11625 int result;
11626 void *argp1 = 0 ;
11627 int res1 = 0 ;
11628 PyObject *swig_obj[1] ;
11629
11630 if (!args) SWIG_fail;
11631 swig_obj[0] = args;
11632 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11633 if (!SWIG_IsOK(res1)) {
11634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetInterval" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11635 }
11636 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11637 {
11638 PyThreadState* __tstate = wxPyBeginAllowThreads();
11639 result = (int)((wxPyTimer const *)arg1)->GetInterval();
11640 wxPyEndAllowThreads(__tstate);
11641 if (PyErr_Occurred()) SWIG_fail;
11642 }
11643 resultobj = SWIG_From_int(static_cast< int >(result));
11644 return resultobj;
11645 fail:
11646 return NULL;
11647 }
11648
11649
11650 SWIGINTERN PyObject *_wrap_Timer_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11651 PyObject *resultobj = 0;
11652 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11653 int result;
11654 void *argp1 = 0 ;
11655 int res1 = 0 ;
11656 PyObject *swig_obj[1] ;
11657
11658 if (!args) SWIG_fail;
11659 swig_obj[0] = args;
11660 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11661 if (!SWIG_IsOK(res1)) {
11662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetId" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11663 }
11664 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11665 {
11666 PyThreadState* __tstate = wxPyBeginAllowThreads();
11667 result = (int)((wxPyTimer const *)arg1)->GetId();
11668 wxPyEndAllowThreads(__tstate);
11669 if (PyErr_Occurred()) SWIG_fail;
11670 }
11671 resultobj = SWIG_From_int(static_cast< int >(result));
11672 return resultobj;
11673 fail:
11674 return NULL;
11675 }
11676
11677
11678 SWIGINTERN PyObject *_wrap_Timer_IsOneShot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11679 PyObject *resultobj = 0;
11680 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11681 bool result;
11682 void *argp1 = 0 ;
11683 int res1 = 0 ;
11684 PyObject *swig_obj[1] ;
11685
11686 if (!args) SWIG_fail;
11687 swig_obj[0] = args;
11688 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11689 if (!SWIG_IsOK(res1)) {
11690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsOneShot" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11691 }
11692 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11693 {
11694 PyThreadState* __tstate = wxPyBeginAllowThreads();
11695 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
11696 wxPyEndAllowThreads(__tstate);
11697 if (PyErr_Occurred()) SWIG_fail;
11698 }
11699 {
11700 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11701 }
11702 return resultobj;
11703 fail:
11704 return NULL;
11705 }
11706
11707
11708 SWIGINTERN PyObject *Timer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11709 PyObject *obj;
11710 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11711 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTimer, SWIG_NewClientData(obj));
11712 return SWIG_Py_Void();
11713 }
11714
11715 SWIGINTERN PyObject *Timer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11716 return SWIG_Python_InitShadowInstance(args);
11717 }
11718
11719 SWIGINTERN PyObject *_wrap_new_TimerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11720 PyObject *resultobj = 0;
11721 int arg1 = (int) 0 ;
11722 int arg2 = (int) 0 ;
11723 wxTimerEvent *result = 0 ;
11724 int val1 ;
11725 int ecode1 = 0 ;
11726 int val2 ;
11727 int ecode2 = 0 ;
11728 PyObject * obj0 = 0 ;
11729 PyObject * obj1 = 0 ;
11730 char * kwnames[] = {
11731 (char *) "timerid",(char *) "interval", NULL
11732 };
11733
11734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) SWIG_fail;
11735 if (obj0) {
11736 ecode1 = SWIG_AsVal_int(obj0, &val1);
11737 if (!SWIG_IsOK(ecode1)) {
11738 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimerEvent" "', expected argument " "1"" of type '" "int""'");
11739 }
11740 arg1 = static_cast< int >(val1);
11741 }
11742 if (obj1) {
11743 ecode2 = SWIG_AsVal_int(obj1, &val2);
11744 if (!SWIG_IsOK(ecode2)) {
11745 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerEvent" "', expected argument " "2"" of type '" "int""'");
11746 }
11747 arg2 = static_cast< int >(val2);
11748 }
11749 {
11750 PyThreadState* __tstate = wxPyBeginAllowThreads();
11751 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
11752 wxPyEndAllowThreads(__tstate);
11753 if (PyErr_Occurred()) SWIG_fail;
11754 }
11755 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_NEW | 0 );
11756 return resultobj;
11757 fail:
11758 return NULL;
11759 }
11760
11761
11762 SWIGINTERN PyObject *_wrap_TimerEvent_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11763 PyObject *resultobj = 0;
11764 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
11765 int result;
11766 void *argp1 = 0 ;
11767 int res1 = 0 ;
11768 PyObject *swig_obj[1] ;
11769
11770 if (!args) SWIG_fail;
11771 swig_obj[0] = args;
11772 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerEvent, 0 | 0 );
11773 if (!SWIG_IsOK(res1)) {
11774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerEvent_GetInterval" "', expected argument " "1"" of type '" "wxTimerEvent const *""'");
11775 }
11776 arg1 = reinterpret_cast< wxTimerEvent * >(argp1);
11777 {
11778 PyThreadState* __tstate = wxPyBeginAllowThreads();
11779 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
11780 wxPyEndAllowThreads(__tstate);
11781 if (PyErr_Occurred()) SWIG_fail;
11782 }
11783 resultobj = SWIG_From_int(static_cast< int >(result));
11784 return resultobj;
11785 fail:
11786 return NULL;
11787 }
11788
11789
11790 SWIGINTERN PyObject *TimerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11791 PyObject *obj;
11792 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11793 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerEvent, SWIG_NewClientData(obj));
11794 return SWIG_Py_Void();
11795 }
11796
11797 SWIGINTERN PyObject *TimerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11798 return SWIG_Python_InitShadowInstance(args);
11799 }
11800
11801 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
11802 PyObject *resultobj = 0;
11803 wxTimer *arg1 = 0 ;
11804 wxTimerRunner *result = 0 ;
11805 void *argp1 = 0 ;
11806 int res1 = 0 ;
11807
11808 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
11809 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
11810 if (!SWIG_IsOK(res1)) {
11811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
11812 }
11813 if (!argp1) {
11814 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
11815 }
11816 arg1 = reinterpret_cast< wxTimer * >(argp1);
11817 {
11818 if (!wxPyCheckForApp()) SWIG_fail;
11819 PyThreadState* __tstate = wxPyBeginAllowThreads();
11820 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
11821 wxPyEndAllowThreads(__tstate);
11822 if (PyErr_Occurred()) SWIG_fail;
11823 }
11824 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
11825 return resultobj;
11826 fail:
11827 return NULL;
11828 }
11829
11830
11831 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
11832 PyObject *resultobj = 0;
11833 wxTimer *arg1 = 0 ;
11834 int arg2 ;
11835 bool arg3 = (bool) false ;
11836 wxTimerRunner *result = 0 ;
11837 void *argp1 = 0 ;
11838 int res1 = 0 ;
11839 int val2 ;
11840 int ecode2 = 0 ;
11841 bool val3 ;
11842 int ecode3 = 0 ;
11843
11844 if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
11845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
11846 if (!SWIG_IsOK(res1)) {
11847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
11848 }
11849 if (!argp1) {
11850 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
11851 }
11852 arg1 = reinterpret_cast< wxTimer * >(argp1);
11853 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
11854 if (!SWIG_IsOK(ecode2)) {
11855 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerRunner" "', expected argument " "2"" of type '" "int""'");
11856 }
11857 arg2 = static_cast< int >(val2);
11858 if (swig_obj[2]) {
11859 ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
11860 if (!SWIG_IsOK(ecode3)) {
11861 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimerRunner" "', expected argument " "3"" of type '" "bool""'");
11862 }
11863 arg3 = static_cast< bool >(val3);
11864 }
11865 {
11866 if (!wxPyCheckForApp()) SWIG_fail;
11867 PyThreadState* __tstate = wxPyBeginAllowThreads();
11868 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
11869 wxPyEndAllowThreads(__tstate);
11870 if (PyErr_Occurred()) SWIG_fail;
11871 }
11872 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
11873 return resultobj;
11874 fail:
11875 return NULL;
11876 }
11877
11878
11879 SWIGINTERN PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
11880 int argc;
11881 PyObject *argv[4];
11882
11883 if (!(argc = SWIG_Python_UnpackTuple(args,"new_TimerRunner",0,3,argv))) SWIG_fail;
11884 --argc;
11885 if (argc == 1) {
11886 return _wrap_new_TimerRunner__SWIG_0(self, argc, argv);
11887 }
11888 if ((argc >= 2) && (argc <= 3)) {
11889 return _wrap_new_TimerRunner__SWIG_1(self, argc, argv);
11890 }
11891
11892 fail:
11893 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
11894 return NULL;
11895 }
11896
11897
11898 SWIGINTERN PyObject *_wrap_delete_TimerRunner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11899 PyObject *resultobj = 0;
11900 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
11901 void *argp1 = 0 ;
11902 int res1 = 0 ;
11903 PyObject *swig_obj[1] ;
11904
11905 if (!args) SWIG_fail;
11906 swig_obj[0] = args;
11907 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_DISOWN | 0 );
11908 if (!SWIG_IsOK(res1)) {
11909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimerRunner" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
11910 }
11911 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
11912 {
11913 PyThreadState* __tstate = wxPyBeginAllowThreads();
11914 delete arg1;
11915
11916 wxPyEndAllowThreads(__tstate);
11917 if (PyErr_Occurred()) SWIG_fail;
11918 }
11919 resultobj = SWIG_Py_Void();
11920 return resultobj;
11921 fail:
11922 return NULL;
11923 }
11924
11925
11926 SWIGINTERN PyObject *_wrap_TimerRunner_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11927 PyObject *resultobj = 0;
11928 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
11929 int arg2 ;
11930 bool arg3 = (bool) false ;
11931 void *argp1 = 0 ;
11932 int res1 = 0 ;
11933 int val2 ;
11934 int ecode2 = 0 ;
11935 bool val3 ;
11936 int ecode3 = 0 ;
11937 PyObject * obj0 = 0 ;
11938 PyObject * obj1 = 0 ;
11939 PyObject * obj2 = 0 ;
11940 char * kwnames[] = {
11941 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
11942 };
11943
11944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11945 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimerRunner, 0 | 0 );
11946 if (!SWIG_IsOK(res1)) {
11947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerRunner_Start" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
11948 }
11949 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
11950 ecode2 = SWIG_AsVal_int(obj1, &val2);
11951 if (!SWIG_IsOK(ecode2)) {
11952 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimerRunner_Start" "', expected argument " "2"" of type '" "int""'");
11953 }
11954 arg2 = static_cast< int >(val2);
11955 if (obj2) {
11956 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11957 if (!SWIG_IsOK(ecode3)) {
11958 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TimerRunner_Start" "', expected argument " "3"" of type '" "bool""'");
11959 }
11960 arg3 = static_cast< bool >(val3);
11961 }
11962 {
11963 PyThreadState* __tstate = wxPyBeginAllowThreads();
11964 (arg1)->Start(arg2,arg3);
11965 wxPyEndAllowThreads(__tstate);
11966 if (PyErr_Occurred()) SWIG_fail;
11967 }
11968 resultobj = SWIG_Py_Void();
11969 return resultobj;
11970 fail:
11971 return NULL;
11972 }
11973
11974
11975 SWIGINTERN PyObject *TimerRunner_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11976 PyObject *obj;
11977 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11978 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerRunner, SWIG_NewClientData(obj));
11979 return SWIG_Py_Void();
11980 }
11981
11982 SWIGINTERN PyObject *TimerRunner_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11983 return SWIG_Python_InitShadowInstance(args);
11984 }
11985
11986 SWIGINTERN PyObject *_wrap_new_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11987 PyObject *resultobj = 0;
11988 wxLog *result = 0 ;
11989
11990 if (!SWIG_Python_UnpackTuple(args,"new_Log",0,0,0)) SWIG_fail;
11991 {
11992 PyThreadState* __tstate = wxPyBeginAllowThreads();
11993 result = (wxLog *)new wxLog();
11994 wxPyEndAllowThreads(__tstate);
11995 if (PyErr_Occurred()) SWIG_fail;
11996 }
11997 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_NEW | 0 );
11998 return resultobj;
11999 fail:
12000 return NULL;
12001 }
12002
12003
12004 SWIGINTERN PyObject *_wrap_delete_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12005 PyObject *resultobj = 0;
12006 wxLog *arg1 = (wxLog *) 0 ;
12007 void *argp1 = 0 ;
12008 int res1 = 0 ;
12009 PyObject *swig_obj[1] ;
12010
12011 if (!args) SWIG_fail;
12012 swig_obj[0] = args;
12013 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
12014 if (!SWIG_IsOK(res1)) {
12015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Log" "', expected argument " "1"" of type '" "wxLog *""'");
12016 }
12017 arg1 = reinterpret_cast< wxLog * >(argp1);
12018 {
12019 PyThreadState* __tstate = wxPyBeginAllowThreads();
12020 delete arg1;
12021
12022 wxPyEndAllowThreads(__tstate);
12023 if (PyErr_Occurred()) SWIG_fail;
12024 }
12025 resultobj = SWIG_Py_Void();
12026 return resultobj;
12027 fail:
12028 return NULL;
12029 }
12030
12031
12032 SWIGINTERN PyObject *_wrap_Log_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12033 PyObject *resultobj = 0;
12034 bool result;
12035
12036 if (!SWIG_Python_UnpackTuple(args,"Log_IsEnabled",0,0,0)) SWIG_fail;
12037 {
12038 PyThreadState* __tstate = wxPyBeginAllowThreads();
12039 result = (bool)wxLog::IsEnabled();
12040 wxPyEndAllowThreads(__tstate);
12041 if (PyErr_Occurred()) SWIG_fail;
12042 }
12043 {
12044 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12045 }
12046 return resultobj;
12047 fail:
12048 return NULL;
12049 }
12050
12051
12052 SWIGINTERN PyObject *_wrap_Log_EnableLogging(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12053 PyObject *resultobj = 0;
12054 bool arg1 = (bool) true ;
12055 bool result;
12056 bool val1 ;
12057 int ecode1 = 0 ;
12058 PyObject * obj0 = 0 ;
12059 char * kwnames[] = {
12060 (char *) "doIt", NULL
12061 };
12062
12063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) SWIG_fail;
12064 if (obj0) {
12065 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12066 if (!SWIG_IsOK(ecode1)) {
12067 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_EnableLogging" "', expected argument " "1"" of type '" "bool""'");
12068 }
12069 arg1 = static_cast< bool >(val1);
12070 }
12071 {
12072 PyThreadState* __tstate = wxPyBeginAllowThreads();
12073 result = (bool)wxLog::EnableLogging(arg1);
12074 wxPyEndAllowThreads(__tstate);
12075 if (PyErr_Occurred()) SWIG_fail;
12076 }
12077 {
12078 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12079 }
12080 return resultobj;
12081 fail:
12082 return NULL;
12083 }
12084
12085
12086 SWIGINTERN PyObject *_wrap_Log_OnLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12087 PyObject *resultobj = 0;
12088 wxLogLevel arg1 ;
12089 wxChar *arg2 = (wxChar *) 0 ;
12090 time_t arg3 ;
12091 unsigned long val1 ;
12092 int ecode1 = 0 ;
12093 void *argp2 = 0 ;
12094 int res2 = 0 ;
12095 unsigned int val3 ;
12096 int ecode3 = 0 ;
12097 PyObject * obj0 = 0 ;
12098 PyObject * obj1 = 0 ;
12099 PyObject * obj2 = 0 ;
12100 char * kwnames[] = {
12101 (char *) "level",(char *) "szString",(char *) "t", NULL
12102 };
12103
12104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12105 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12106 if (!SWIG_IsOK(ecode1)) {
12107 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_OnLog" "', expected argument " "1"" of type '" "wxLogLevel""'");
12108 }
12109 arg1 = static_cast< wxLogLevel >(val1);
12110 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxChar, 0 | 0 );
12111 if (!SWIG_IsOK(res2)) {
12112 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Log_OnLog" "', expected argument " "2"" of type '" "wxChar const *""'");
12113 }
12114 arg2 = reinterpret_cast< wxChar * >(argp2);
12115 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
12116 if (!SWIG_IsOK(ecode3)) {
12117 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Log_OnLog" "', expected argument " "3"" of type '" "time_t""'");
12118 }
12119 arg3 = static_cast< time_t >(val3);
12120 {
12121 PyThreadState* __tstate = wxPyBeginAllowThreads();
12122 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
12123 wxPyEndAllowThreads(__tstate);
12124 if (PyErr_Occurred()) SWIG_fail;
12125 }
12126 resultobj = SWIG_Py_Void();
12127 return resultobj;
12128 fail:
12129 return NULL;
12130 }
12131
12132
12133 SWIGINTERN PyObject *_wrap_Log_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12134 PyObject *resultobj = 0;
12135 wxLog *arg1 = (wxLog *) 0 ;
12136 void *argp1 = 0 ;
12137 int res1 = 0 ;
12138 PyObject *swig_obj[1] ;
12139
12140 if (!args) SWIG_fail;
12141 swig_obj[0] = args;
12142 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
12143 if (!SWIG_IsOK(res1)) {
12144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Flush" "', expected argument " "1"" of type '" "wxLog *""'");
12145 }
12146 arg1 = reinterpret_cast< wxLog * >(argp1);
12147 {
12148 PyThreadState* __tstate = wxPyBeginAllowThreads();
12149 (arg1)->Flush();
12150 wxPyEndAllowThreads(__tstate);
12151 if (PyErr_Occurred()) SWIG_fail;
12152 }
12153 resultobj = SWIG_Py_Void();
12154 return resultobj;
12155 fail:
12156 return NULL;
12157 }
12158
12159
12160 SWIGINTERN PyObject *_wrap_Log_FlushActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12161 PyObject *resultobj = 0;
12162
12163 if (!SWIG_Python_UnpackTuple(args,"Log_FlushActive",0,0,0)) SWIG_fail;
12164 {
12165 PyThreadState* __tstate = wxPyBeginAllowThreads();
12166 wxLog::FlushActive();
12167 wxPyEndAllowThreads(__tstate);
12168 if (PyErr_Occurred()) SWIG_fail;
12169 }
12170 resultobj = SWIG_Py_Void();
12171 return resultobj;
12172 fail:
12173 return NULL;
12174 }
12175
12176
12177 SWIGINTERN PyObject *_wrap_Log_GetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12178 PyObject *resultobj = 0;
12179 wxLog *result = 0 ;
12180
12181 if (!SWIG_Python_UnpackTuple(args,"Log_GetActiveTarget",0,0,0)) SWIG_fail;
12182 {
12183 PyThreadState* __tstate = wxPyBeginAllowThreads();
12184 result = (wxLog *)wxLog::GetActiveTarget();
12185 wxPyEndAllowThreads(__tstate);
12186 if (PyErr_Occurred()) SWIG_fail;
12187 }
12188 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
12189 return resultobj;
12190 fail:
12191 return NULL;
12192 }
12193
12194
12195 SWIGINTERN PyObject *_wrap_Log_SetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12196 PyObject *resultobj = 0;
12197 wxLog *arg1 = (wxLog *) 0 ;
12198 wxLog *result = 0 ;
12199 int res1 = 0 ;
12200 PyObject * obj0 = 0 ;
12201 char * kwnames[] = {
12202 (char *) "pLogger", NULL
12203 };
12204
12205 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) SWIG_fail;
12206 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
12207 if (!SWIG_IsOK(res1)) {
12208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetActiveTarget" "', expected argument " "1"" of type '" "wxLog *""'");
12209 }
12210 {
12211 PyThreadState* __tstate = wxPyBeginAllowThreads();
12212 result = (wxLog *)wxLog::SetActiveTarget(arg1);
12213 wxPyEndAllowThreads(__tstate);
12214 if (PyErr_Occurred()) SWIG_fail;
12215 }
12216 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_OWN | 0 );
12217 return resultobj;
12218 fail:
12219 return NULL;
12220 }
12221
12222
12223 SWIGINTERN PyObject *_wrap_Log_Suspend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12224 PyObject *resultobj = 0;
12225
12226 if (!SWIG_Python_UnpackTuple(args,"Log_Suspend",0,0,0)) SWIG_fail;
12227 {
12228 PyThreadState* __tstate = wxPyBeginAllowThreads();
12229 wxLog::Suspend();
12230 wxPyEndAllowThreads(__tstate);
12231 if (PyErr_Occurred()) SWIG_fail;
12232 }
12233 resultobj = SWIG_Py_Void();
12234 return resultobj;
12235 fail:
12236 return NULL;
12237 }
12238
12239
12240 SWIGINTERN PyObject *_wrap_Log_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12241 PyObject *resultobj = 0;
12242
12243 if (!SWIG_Python_UnpackTuple(args,"Log_Resume",0,0,0)) SWIG_fail;
12244 {
12245 PyThreadState* __tstate = wxPyBeginAllowThreads();
12246 wxLog::Resume();
12247 wxPyEndAllowThreads(__tstate);
12248 if (PyErr_Occurred()) SWIG_fail;
12249 }
12250 resultobj = SWIG_Py_Void();
12251 return resultobj;
12252 fail:
12253 return NULL;
12254 }
12255
12256
12257 SWIGINTERN PyObject *_wrap_Log_SetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12258 PyObject *resultobj = 0;
12259 bool arg1 = (bool) true ;
12260 bool val1 ;
12261 int ecode1 = 0 ;
12262 PyObject * obj0 = 0 ;
12263 char * kwnames[] = {
12264 (char *) "bVerbose", NULL
12265 };
12266
12267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) SWIG_fail;
12268 if (obj0) {
12269 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12270 if (!SWIG_IsOK(ecode1)) {
12271 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetVerbose" "', expected argument " "1"" of type '" "bool""'");
12272 }
12273 arg1 = static_cast< bool >(val1);
12274 }
12275 {
12276 PyThreadState* __tstate = wxPyBeginAllowThreads();
12277 wxLog::SetVerbose(arg1);
12278 wxPyEndAllowThreads(__tstate);
12279 if (PyErr_Occurred()) SWIG_fail;
12280 }
12281 resultobj = SWIG_Py_Void();
12282 return resultobj;
12283 fail:
12284 return NULL;
12285 }
12286
12287
12288 SWIGINTERN PyObject *_wrap_Log_SetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12289 PyObject *resultobj = 0;
12290 wxLogLevel arg1 ;
12291 unsigned long val1 ;
12292 int ecode1 = 0 ;
12293 PyObject * obj0 = 0 ;
12294 char * kwnames[] = {
12295 (char *) "logLevel", NULL
12296 };
12297
12298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) SWIG_fail;
12299 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12300 if (!SWIG_IsOK(ecode1)) {
12301 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetLogLevel" "', expected argument " "1"" of type '" "wxLogLevel""'");
12302 }
12303 arg1 = static_cast< wxLogLevel >(val1);
12304 {
12305 PyThreadState* __tstate = wxPyBeginAllowThreads();
12306 wxLog::SetLogLevel(arg1);
12307 wxPyEndAllowThreads(__tstate);
12308 if (PyErr_Occurred()) SWIG_fail;
12309 }
12310 resultobj = SWIG_Py_Void();
12311 return resultobj;
12312 fail:
12313 return NULL;
12314 }
12315
12316
12317 SWIGINTERN PyObject *_wrap_Log_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12318 PyObject *resultobj = 0;
12319
12320 if (!SWIG_Python_UnpackTuple(args,"Log_DontCreateOnDemand",0,0,0)) SWIG_fail;
12321 {
12322 PyThreadState* __tstate = wxPyBeginAllowThreads();
12323 wxLog::DontCreateOnDemand();
12324 wxPyEndAllowThreads(__tstate);
12325 if (PyErr_Occurred()) SWIG_fail;
12326 }
12327 resultobj = SWIG_Py_Void();
12328 return resultobj;
12329 fail:
12330 return NULL;
12331 }
12332
12333
12334 SWIGINTERN PyObject *_wrap_Log_SetRepetitionCounting(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12335 PyObject *resultobj = 0;
12336 bool arg1 = (bool) true ;
12337 bool val1 ;
12338 int ecode1 = 0 ;
12339 PyObject * obj0 = 0 ;
12340 char * kwnames[] = {
12341 (char *) "bRepetCounting", NULL
12342 };
12343
12344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetRepetitionCounting",kwnames,&obj0)) SWIG_fail;
12345 if (obj0) {
12346 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12347 if (!SWIG_IsOK(ecode1)) {
12348 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetRepetitionCounting" "', expected argument " "1"" of type '" "bool""'");
12349 }
12350 arg1 = static_cast< bool >(val1);
12351 }
12352 {
12353 PyThreadState* __tstate = wxPyBeginAllowThreads();
12354 wxLog::SetRepetitionCounting(arg1);
12355 wxPyEndAllowThreads(__tstate);
12356 if (PyErr_Occurred()) SWIG_fail;
12357 }
12358 resultobj = SWIG_Py_Void();
12359 return resultobj;
12360 fail:
12361 return NULL;
12362 }
12363
12364
12365 SWIGINTERN PyObject *_wrap_Log_GetRepetitionCounting(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12366 PyObject *resultobj = 0;
12367 bool result;
12368
12369 if (!SWIG_Python_UnpackTuple(args,"Log_GetRepetitionCounting",0,0,0)) SWIG_fail;
12370 {
12371 PyThreadState* __tstate = wxPyBeginAllowThreads();
12372 result = (bool)wxLog::GetRepetitionCounting();
12373 wxPyEndAllowThreads(__tstate);
12374 if (PyErr_Occurred()) SWIG_fail;
12375 }
12376 {
12377 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12378 }
12379 return resultobj;
12380 fail:
12381 return NULL;
12382 }
12383
12384
12385 SWIGINTERN PyObject *_wrap_Log_SetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12386 PyObject *resultobj = 0;
12387 wxTraceMask arg1 ;
12388 unsigned long val1 ;
12389 int ecode1 = 0 ;
12390 PyObject * obj0 = 0 ;
12391 char * kwnames[] = {
12392 (char *) "ulMask", NULL
12393 };
12394
12395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) SWIG_fail;
12396 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12397 if (!SWIG_IsOK(ecode1)) {
12398 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetTraceMask" "', expected argument " "1"" of type '" "wxTraceMask""'");
12399 }
12400 arg1 = static_cast< wxTraceMask >(val1);
12401 {
12402 PyThreadState* __tstate = wxPyBeginAllowThreads();
12403 wxLog::SetTraceMask(arg1);
12404 wxPyEndAllowThreads(__tstate);
12405 if (PyErr_Occurred()) SWIG_fail;
12406 }
12407 resultobj = SWIG_Py_Void();
12408 return resultobj;
12409 fail:
12410 return NULL;
12411 }
12412
12413
12414 SWIGINTERN PyObject *_wrap_Log_AddTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12415 PyObject *resultobj = 0;
12416 wxString *arg1 = 0 ;
12417 bool temp1 = false ;
12418 PyObject * obj0 = 0 ;
12419 char * kwnames[] = {
12420 (char *) "str", NULL
12421 };
12422
12423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) SWIG_fail;
12424 {
12425 arg1 = wxString_in_helper(obj0);
12426 if (arg1 == NULL) SWIG_fail;
12427 temp1 = true;
12428 }
12429 {
12430 PyThreadState* __tstate = wxPyBeginAllowThreads();
12431 wxLog::AddTraceMask((wxString const &)*arg1);
12432 wxPyEndAllowThreads(__tstate);
12433 if (PyErr_Occurred()) SWIG_fail;
12434 }
12435 resultobj = SWIG_Py_Void();
12436 {
12437 if (temp1)
12438 delete arg1;
12439 }
12440 return resultobj;
12441 fail:
12442 {
12443 if (temp1)
12444 delete arg1;
12445 }
12446 return NULL;
12447 }
12448
12449
12450 SWIGINTERN PyObject *_wrap_Log_RemoveTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12451 PyObject *resultobj = 0;
12452 wxString *arg1 = 0 ;
12453 bool temp1 = false ;
12454 PyObject * obj0 = 0 ;
12455 char * kwnames[] = {
12456 (char *) "str", NULL
12457 };
12458
12459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) SWIG_fail;
12460 {
12461 arg1 = wxString_in_helper(obj0);
12462 if (arg1 == NULL) SWIG_fail;
12463 temp1 = true;
12464 }
12465 {
12466 PyThreadState* __tstate = wxPyBeginAllowThreads();
12467 wxLog::RemoveTraceMask((wxString const &)*arg1);
12468 wxPyEndAllowThreads(__tstate);
12469 if (PyErr_Occurred()) SWIG_fail;
12470 }
12471 resultobj = SWIG_Py_Void();
12472 {
12473 if (temp1)
12474 delete arg1;
12475 }
12476 return resultobj;
12477 fail:
12478 {
12479 if (temp1)
12480 delete arg1;
12481 }
12482 return NULL;
12483 }
12484
12485
12486 SWIGINTERN PyObject *_wrap_Log_ClearTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12487 PyObject *resultobj = 0;
12488
12489 if (!SWIG_Python_UnpackTuple(args,"Log_ClearTraceMasks",0,0,0)) SWIG_fail;
12490 {
12491 PyThreadState* __tstate = wxPyBeginAllowThreads();
12492 wxLog::ClearTraceMasks();
12493 wxPyEndAllowThreads(__tstate);
12494 if (PyErr_Occurred()) SWIG_fail;
12495 }
12496 resultobj = SWIG_Py_Void();
12497 return resultobj;
12498 fail:
12499 return NULL;
12500 }
12501
12502
12503 SWIGINTERN PyObject *_wrap_Log_GetTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12504 PyObject *resultobj = 0;
12505 wxArrayString *result = 0 ;
12506
12507 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMasks",0,0,0)) SWIG_fail;
12508 {
12509 PyThreadState* __tstate = wxPyBeginAllowThreads();
12510 {
12511 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
12512 result = (wxArrayString *) &_result_ref;
12513 }
12514 wxPyEndAllowThreads(__tstate);
12515 if (PyErr_Occurred()) SWIG_fail;
12516 }
12517 {
12518 resultobj = wxArrayString2PyList_helper(*result);
12519 }
12520 return resultobj;
12521 fail:
12522 return NULL;
12523 }
12524
12525
12526 SWIGINTERN PyObject *_wrap_Log_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12527 PyObject *resultobj = 0;
12528 wxChar *arg1 = (wxChar *) 0 ;
12529 void *argp1 = 0 ;
12530 int res1 = 0 ;
12531 PyObject * obj0 = 0 ;
12532 char * kwnames[] = {
12533 (char *) "ts", NULL
12534 };
12535
12536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) SWIG_fail;
12537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
12538 if (!SWIG_IsOK(res1)) {
12539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetTimestamp" "', expected argument " "1"" of type '" "wxChar const *""'");
12540 }
12541 arg1 = reinterpret_cast< wxChar * >(argp1);
12542 {
12543 PyThreadState* __tstate = wxPyBeginAllowThreads();
12544 wxLog::SetTimestamp((wxChar const *)arg1);
12545 wxPyEndAllowThreads(__tstate);
12546 if (PyErr_Occurred()) SWIG_fail;
12547 }
12548 resultobj = SWIG_Py_Void();
12549 return resultobj;
12550 fail:
12551 return NULL;
12552 }
12553
12554
12555 SWIGINTERN PyObject *_wrap_Log_GetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12556 PyObject *resultobj = 0;
12557 bool result;
12558
12559 if (!SWIG_Python_UnpackTuple(args,"Log_GetVerbose",0,0,0)) SWIG_fail;
12560 {
12561 PyThreadState* __tstate = wxPyBeginAllowThreads();
12562 result = (bool)wxLog::GetVerbose();
12563 wxPyEndAllowThreads(__tstate);
12564 if (PyErr_Occurred()) SWIG_fail;
12565 }
12566 {
12567 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12568 }
12569 return resultobj;
12570 fail:
12571 return NULL;
12572 }
12573
12574
12575 SWIGINTERN PyObject *_wrap_Log_GetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12576 PyObject *resultobj = 0;
12577 wxTraceMask result;
12578
12579 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMask",0,0,0)) SWIG_fail;
12580 {
12581 PyThreadState* __tstate = wxPyBeginAllowThreads();
12582 result = (wxTraceMask)wxLog::GetTraceMask();
12583 wxPyEndAllowThreads(__tstate);
12584 if (PyErr_Occurred()) SWIG_fail;
12585 }
12586 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12587 return resultobj;
12588 fail:
12589 return NULL;
12590 }
12591
12592
12593 SWIGINTERN PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12594 PyObject *resultobj = 0;
12595 wxChar *arg1 = (wxChar *) 0 ;
12596 bool result;
12597 void *argp1 = 0 ;
12598 int res1 = 0 ;
12599 PyObject * obj0 = 0 ;
12600 char * kwnames[] = {
12601 (char *) "mask", NULL
12602 };
12603
12604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) SWIG_fail;
12605 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
12606 if (!SWIG_IsOK(res1)) {
12607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_IsAllowedTraceMask" "', expected argument " "1"" of type '" "wxChar const *""'");
12608 }
12609 arg1 = reinterpret_cast< wxChar * >(argp1);
12610 {
12611 PyThreadState* __tstate = wxPyBeginAllowThreads();
12612 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
12613 wxPyEndAllowThreads(__tstate);
12614 if (PyErr_Occurred()) SWIG_fail;
12615 }
12616 {
12617 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12618 }
12619 return resultobj;
12620 fail:
12621 return NULL;
12622 }
12623
12624
12625 SWIGINTERN PyObject *_wrap_Log_GetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12626 PyObject *resultobj = 0;
12627 wxLogLevel result;
12628
12629 if (!SWIG_Python_UnpackTuple(args,"Log_GetLogLevel",0,0,0)) SWIG_fail;
12630 {
12631 PyThreadState* __tstate = wxPyBeginAllowThreads();
12632 result = (wxLogLevel)wxLog::GetLogLevel();
12633 wxPyEndAllowThreads(__tstate);
12634 if (PyErr_Occurred()) SWIG_fail;
12635 }
12636 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12637 return resultobj;
12638 fail:
12639 return NULL;
12640 }
12641
12642
12643 SWIGINTERN PyObject *_wrap_Log_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12644 PyObject *resultobj = 0;
12645 wxChar *result = 0 ;
12646
12647 if (!SWIG_Python_UnpackTuple(args,"Log_GetTimestamp",0,0,0)) SWIG_fail;
12648 {
12649 PyThreadState* __tstate = wxPyBeginAllowThreads();
12650 result = (wxChar *)wxLog::GetTimestamp();
12651 wxPyEndAllowThreads(__tstate);
12652 if (PyErr_Occurred()) SWIG_fail;
12653 }
12654 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChar, 0 | 0 );
12655 return resultobj;
12656 fail:
12657 return NULL;
12658 }
12659
12660
12661 SWIGINTERN PyObject *_wrap_Log_TimeStamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12662 PyObject *resultobj = 0;
12663 wxString result;
12664
12665 if (!SWIG_Python_UnpackTuple(args,"Log_TimeStamp",0,0,0)) SWIG_fail;
12666 {
12667 PyThreadState* __tstate = wxPyBeginAllowThreads();
12668 result = wxLog_TimeStamp();
12669 wxPyEndAllowThreads(__tstate);
12670 if (PyErr_Occurred()) SWIG_fail;
12671 }
12672 {
12673 #if wxUSE_UNICODE
12674 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12675 #else
12676 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12677 #endif
12678 }
12679 return resultobj;
12680 fail:
12681 return NULL;
12682 }
12683
12684
12685 SWIGINTERN PyObject *_wrap_Log_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12686 PyObject *resultobj = 0;
12687 wxLog *arg1 = (wxLog *) 0 ;
12688 void *argp1 = 0 ;
12689 int res1 = 0 ;
12690 PyObject *swig_obj[1] ;
12691
12692 if (!args) SWIG_fail;
12693 swig_obj[0] = args;
12694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
12695 if (!SWIG_IsOK(res1)) {
12696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Destroy" "', expected argument " "1"" of type '" "wxLog *""'");
12697 }
12698 arg1 = reinterpret_cast< wxLog * >(argp1);
12699 {
12700 PyThreadState* __tstate = wxPyBeginAllowThreads();
12701 wxLog_Destroy(arg1);
12702 wxPyEndAllowThreads(__tstate);
12703 if (PyErr_Occurred()) SWIG_fail;
12704 }
12705 resultobj = SWIG_Py_Void();
12706 return resultobj;
12707 fail:
12708 return NULL;
12709 }
12710
12711
12712 SWIGINTERN PyObject *Log_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12713 PyObject *obj;
12714 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12715 SWIG_TypeNewClientData(SWIGTYPE_p_wxLog, SWIG_NewClientData(obj));
12716 return SWIG_Py_Void();
12717 }
12718
12719 SWIGINTERN PyObject *Log_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12720 return SWIG_Python_InitShadowInstance(args);
12721 }
12722
12723 SWIGINTERN PyObject *_wrap_new_LogStderr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12724 PyObject *resultobj = 0;
12725 wxLogStderr *result = 0 ;
12726
12727 if (!SWIG_Python_UnpackTuple(args,"new_LogStderr",0,0,0)) SWIG_fail;
12728 {
12729 PyThreadState* __tstate = wxPyBeginAllowThreads();
12730 result = (wxLogStderr *)new wxLogStderr();
12731 wxPyEndAllowThreads(__tstate);
12732 if (PyErr_Occurred()) SWIG_fail;
12733 }
12734 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogStderr, SWIG_POINTER_NEW | 0 );
12735 return resultobj;
12736 fail:
12737 return NULL;
12738 }
12739
12740
12741 SWIGINTERN PyObject *LogStderr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12742 PyObject *obj;
12743 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12744 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogStderr, SWIG_NewClientData(obj));
12745 return SWIG_Py_Void();
12746 }
12747
12748 SWIGINTERN PyObject *LogStderr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12749 return SWIG_Python_InitShadowInstance(args);
12750 }
12751
12752 SWIGINTERN PyObject *_wrap_new_LogTextCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12753 PyObject *resultobj = 0;
12754 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
12755 wxLogTextCtrl *result = 0 ;
12756 void *argp1 = 0 ;
12757 int res1 = 0 ;
12758 PyObject * obj0 = 0 ;
12759 char * kwnames[] = {
12760 (char *) "pTextCtrl", NULL
12761 };
12762
12763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) SWIG_fail;
12764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextCtrl, 0 | 0 );
12765 if (!SWIG_IsOK(res1)) {
12766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogTextCtrl" "', expected argument " "1"" of type '" "wxTextCtrl *""'");
12767 }
12768 arg1 = reinterpret_cast< wxTextCtrl * >(argp1);
12769 {
12770 PyThreadState* __tstate = wxPyBeginAllowThreads();
12771 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
12772 wxPyEndAllowThreads(__tstate);
12773 if (PyErr_Occurred()) SWIG_fail;
12774 }
12775 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogTextCtrl, SWIG_POINTER_NEW | 0 );
12776 return resultobj;
12777 fail:
12778 return NULL;
12779 }
12780
12781
12782 SWIGINTERN PyObject *LogTextCtrl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12783 PyObject *obj;
12784 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12785 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogTextCtrl, SWIG_NewClientData(obj));
12786 return SWIG_Py_Void();
12787 }
12788
12789 SWIGINTERN PyObject *LogTextCtrl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12790 return SWIG_Python_InitShadowInstance(args);
12791 }
12792
12793 SWIGINTERN PyObject *_wrap_new_LogGui(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12794 PyObject *resultobj = 0;
12795 wxLogGui *result = 0 ;
12796
12797 if (!SWIG_Python_UnpackTuple(args,"new_LogGui",0,0,0)) SWIG_fail;
12798 {
12799 PyThreadState* __tstate = wxPyBeginAllowThreads();
12800 result = (wxLogGui *)new wxLogGui();
12801 wxPyEndAllowThreads(__tstate);
12802 if (PyErr_Occurred()) SWIG_fail;
12803 }
12804 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogGui, SWIG_POINTER_NEW | 0 );
12805 return resultobj;
12806 fail:
12807 return NULL;
12808 }
12809
12810
12811 SWIGINTERN PyObject *LogGui_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12812 PyObject *obj;
12813 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12814 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogGui, SWIG_NewClientData(obj));
12815 return SWIG_Py_Void();
12816 }
12817
12818 SWIGINTERN PyObject *LogGui_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12819 return SWIG_Python_InitShadowInstance(args);
12820 }
12821
12822 SWIGINTERN PyObject *_wrap_new_LogWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12823 PyObject *resultobj = 0;
12824 wxFrame *arg1 = (wxFrame *) 0 ;
12825 wxString *arg2 = 0 ;
12826 bool arg3 = (bool) true ;
12827 bool arg4 = (bool) true ;
12828 wxLogWindow *result = 0 ;
12829 void *argp1 = 0 ;
12830 int res1 = 0 ;
12831 bool temp2 = false ;
12832 bool val3 ;
12833 int ecode3 = 0 ;
12834 bool val4 ;
12835 int ecode4 = 0 ;
12836 PyObject * obj0 = 0 ;
12837 PyObject * obj1 = 0 ;
12838 PyObject * obj2 = 0 ;
12839 PyObject * obj3 = 0 ;
12840 char * kwnames[] = {
12841 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
12842 };
12843
12844 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12845 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
12846 if (!SWIG_IsOK(res1)) {
12847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogWindow" "', expected argument " "1"" of type '" "wxFrame *""'");
12848 }
12849 arg1 = reinterpret_cast< wxFrame * >(argp1);
12850 {
12851 arg2 = wxString_in_helper(obj1);
12852 if (arg2 == NULL) SWIG_fail;
12853 temp2 = true;
12854 }
12855 if (obj2) {
12856 ecode3 = SWIG_AsVal_bool(obj2, &val3);
12857 if (!SWIG_IsOK(ecode3)) {
12858 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_LogWindow" "', expected argument " "3"" of type '" "bool""'");
12859 }
12860 arg3 = static_cast< bool >(val3);
12861 }
12862 if (obj3) {
12863 ecode4 = SWIG_AsVal_bool(obj3, &val4);
12864 if (!SWIG_IsOK(ecode4)) {
12865 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LogWindow" "', expected argument " "4"" of type '" "bool""'");
12866 }
12867 arg4 = static_cast< bool >(val4);
12868 }
12869 {
12870 PyThreadState* __tstate = wxPyBeginAllowThreads();
12871 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
12872 wxPyEndAllowThreads(__tstate);
12873 if (PyErr_Occurred()) SWIG_fail;
12874 }
12875 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogWindow, SWIG_POINTER_NEW | 0 );
12876 {
12877 if (temp2)
12878 delete arg2;
12879 }
12880 return resultobj;
12881 fail:
12882 {
12883 if (temp2)
12884 delete arg2;
12885 }
12886 return NULL;
12887 }
12888
12889
12890 SWIGINTERN PyObject *_wrap_LogWindow_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12891 PyObject *resultobj = 0;
12892 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
12893 bool arg2 = (bool) true ;
12894 void *argp1 = 0 ;
12895 int res1 = 0 ;
12896 bool val2 ;
12897 int ecode2 = 0 ;
12898 PyObject * obj0 = 0 ;
12899 PyObject * obj1 = 0 ;
12900 char * kwnames[] = {
12901 (char *) "self",(char *) "bShow", NULL
12902 };
12903
12904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) SWIG_fail;
12905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
12906 if (!SWIG_IsOK(res1)) {
12907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_Show" "', expected argument " "1"" of type '" "wxLogWindow *""'");
12908 }
12909 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
12910 if (obj1) {
12911 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12912 if (!SWIG_IsOK(ecode2)) {
12913 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_Show" "', expected argument " "2"" of type '" "bool""'");
12914 }
12915 arg2 = static_cast< bool >(val2);
12916 }
12917 {
12918 PyThreadState* __tstate = wxPyBeginAllowThreads();
12919 (arg1)->Show(arg2);
12920 wxPyEndAllowThreads(__tstate);
12921 if (PyErr_Occurred()) SWIG_fail;
12922 }
12923 resultobj = SWIG_Py_Void();
12924 return resultobj;
12925 fail:
12926 return NULL;
12927 }
12928
12929
12930 SWIGINTERN PyObject *_wrap_LogWindow_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12931 PyObject *resultobj = 0;
12932 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
12933 wxFrame *result = 0 ;
12934 void *argp1 = 0 ;
12935 int res1 = 0 ;
12936 PyObject *swig_obj[1] ;
12937
12938 if (!args) SWIG_fail;
12939 swig_obj[0] = args;
12940 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
12941 if (!SWIG_IsOK(res1)) {
12942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetFrame" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
12943 }
12944 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
12945 {
12946 PyThreadState* __tstate = wxPyBeginAllowThreads();
12947 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
12948 wxPyEndAllowThreads(__tstate);
12949 if (PyErr_Occurred()) SWIG_fail;
12950 }
12951 {
12952 resultobj = wxPyMake_wxObject(result, (bool)0);
12953 }
12954 return resultobj;
12955 fail:
12956 return NULL;
12957 }
12958
12959
12960 SWIGINTERN PyObject *_wrap_LogWindow_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12961 PyObject *resultobj = 0;
12962 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
12963 wxLog *result = 0 ;
12964 void *argp1 = 0 ;
12965 int res1 = 0 ;
12966 PyObject *swig_obj[1] ;
12967
12968 if (!args) SWIG_fail;
12969 swig_obj[0] = args;
12970 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
12971 if (!SWIG_IsOK(res1)) {
12972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetOldLog" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
12973 }
12974 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
12975 {
12976 PyThreadState* __tstate = wxPyBeginAllowThreads();
12977 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
12978 wxPyEndAllowThreads(__tstate);
12979 if (PyErr_Occurred()) SWIG_fail;
12980 }
12981 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
12982 return resultobj;
12983 fail:
12984 return NULL;
12985 }
12986
12987
12988 SWIGINTERN PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12989 PyObject *resultobj = 0;
12990 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
12991 bool result;
12992 void *argp1 = 0 ;
12993 int res1 = 0 ;
12994 PyObject *swig_obj[1] ;
12995
12996 if (!args) SWIG_fail;
12997 swig_obj[0] = args;
12998 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
12999 if (!SWIG_IsOK(res1)) {
13000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
13001 }
13002 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13003 {
13004 PyThreadState* __tstate = wxPyBeginAllowThreads();
13005 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
13006 wxPyEndAllowThreads(__tstate);
13007 if (PyErr_Occurred()) SWIG_fail;
13008 }
13009 {
13010 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13011 }
13012 return resultobj;
13013 fail:
13014 return NULL;
13015 }
13016
13017
13018 SWIGINTERN PyObject *_wrap_LogWindow_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13019 PyObject *resultobj = 0;
13020 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13021 bool arg2 ;
13022 void *argp1 = 0 ;
13023 int res1 = 0 ;
13024 bool val2 ;
13025 int ecode2 = 0 ;
13026 PyObject * obj0 = 0 ;
13027 PyObject * obj1 = 0 ;
13028 char * kwnames[] = {
13029 (char *) "self",(char *) "bDoPass", NULL
13030 };
13031
13032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
13033 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13034 if (!SWIG_IsOK(res1)) {
13035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_PassMessages" "', expected argument " "1"" of type '" "wxLogWindow *""'");
13036 }
13037 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13038 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13039 if (!SWIG_IsOK(ecode2)) {
13040 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_PassMessages" "', expected argument " "2"" of type '" "bool""'");
13041 }
13042 arg2 = static_cast< bool >(val2);
13043 {
13044 PyThreadState* __tstate = wxPyBeginAllowThreads();
13045 (arg1)->PassMessages(arg2);
13046 wxPyEndAllowThreads(__tstate);
13047 if (PyErr_Occurred()) SWIG_fail;
13048 }
13049 resultobj = SWIG_Py_Void();
13050 return resultobj;
13051 fail:
13052 return NULL;
13053 }
13054
13055
13056 SWIGINTERN PyObject *LogWindow_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13057 PyObject *obj;
13058 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13059 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogWindow, SWIG_NewClientData(obj));
13060 return SWIG_Py_Void();
13061 }
13062
13063 SWIGINTERN PyObject *LogWindow_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13064 return SWIG_Python_InitShadowInstance(args);
13065 }
13066
13067 SWIGINTERN PyObject *_wrap_new_LogChain(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13068 PyObject *resultobj = 0;
13069 wxLog *arg1 = (wxLog *) 0 ;
13070 wxLogChain *result = 0 ;
13071 void *argp1 = 0 ;
13072 int res1 = 0 ;
13073 PyObject * obj0 = 0 ;
13074 char * kwnames[] = {
13075 (char *) "logger", NULL
13076 };
13077
13078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) SWIG_fail;
13079 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
13080 if (!SWIG_IsOK(res1)) {
13081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogChain" "', expected argument " "1"" of type '" "wxLog *""'");
13082 }
13083 arg1 = reinterpret_cast< wxLog * >(argp1);
13084 {
13085 PyThreadState* __tstate = wxPyBeginAllowThreads();
13086 result = (wxLogChain *)new wxLogChain(arg1);
13087 wxPyEndAllowThreads(__tstate);
13088 if (PyErr_Occurred()) SWIG_fail;
13089 }
13090 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogChain, SWIG_POINTER_NEW | 0 );
13091 return resultobj;
13092 fail:
13093 return NULL;
13094 }
13095
13096
13097 SWIGINTERN PyObject *_wrap_LogChain_SetLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13098 PyObject *resultobj = 0;
13099 wxLogChain *arg1 = (wxLogChain *) 0 ;
13100 wxLog *arg2 = (wxLog *) 0 ;
13101 void *argp1 = 0 ;
13102 int res1 = 0 ;
13103 void *argp2 = 0 ;
13104 int res2 = 0 ;
13105 PyObject * obj0 = 0 ;
13106 PyObject * obj1 = 0 ;
13107 char * kwnames[] = {
13108 (char *) "self",(char *) "logger", NULL
13109 };
13110
13111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) SWIG_fail;
13112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13113 if (!SWIG_IsOK(res1)) {
13114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_SetLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
13115 }
13116 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13117 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLog, 0 | 0 );
13118 if (!SWIG_IsOK(res2)) {
13119 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LogChain_SetLog" "', expected argument " "2"" of type '" "wxLog *""'");
13120 }
13121 arg2 = reinterpret_cast< wxLog * >(argp2);
13122 {
13123 PyThreadState* __tstate = wxPyBeginAllowThreads();
13124 (arg1)->SetLog(arg2);
13125 wxPyEndAllowThreads(__tstate);
13126 if (PyErr_Occurred()) SWIG_fail;
13127 }
13128 resultobj = SWIG_Py_Void();
13129 return resultobj;
13130 fail:
13131 return NULL;
13132 }
13133
13134
13135 SWIGINTERN PyObject *_wrap_LogChain_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13136 PyObject *resultobj = 0;
13137 wxLogChain *arg1 = (wxLogChain *) 0 ;
13138 bool arg2 ;
13139 void *argp1 = 0 ;
13140 int res1 = 0 ;
13141 bool val2 ;
13142 int ecode2 = 0 ;
13143 PyObject * obj0 = 0 ;
13144 PyObject * obj1 = 0 ;
13145 char * kwnames[] = {
13146 (char *) "self",(char *) "bDoPass", NULL
13147 };
13148
13149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
13150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13151 if (!SWIG_IsOK(res1)) {
13152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_PassMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
13153 }
13154 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13155 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13156 if (!SWIG_IsOK(ecode2)) {
13157 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogChain_PassMessages" "', expected argument " "2"" of type '" "bool""'");
13158 }
13159 arg2 = static_cast< bool >(val2);
13160 {
13161 PyThreadState* __tstate = wxPyBeginAllowThreads();
13162 (arg1)->PassMessages(arg2);
13163 wxPyEndAllowThreads(__tstate);
13164 if (PyErr_Occurred()) SWIG_fail;
13165 }
13166 resultobj = SWIG_Py_Void();
13167 return resultobj;
13168 fail:
13169 return NULL;
13170 }
13171
13172
13173 SWIGINTERN PyObject *_wrap_LogChain_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13174 PyObject *resultobj = 0;
13175 wxLogChain *arg1 = (wxLogChain *) 0 ;
13176 bool result;
13177 void *argp1 = 0 ;
13178 int res1 = 0 ;
13179 PyObject *swig_obj[1] ;
13180
13181 if (!args) SWIG_fail;
13182 swig_obj[0] = args;
13183 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13184 if (!SWIG_IsOK(res1)) {
13185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
13186 }
13187 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13188 {
13189 PyThreadState* __tstate = wxPyBeginAllowThreads();
13190 result = (bool)(arg1)->IsPassingMessages();
13191 wxPyEndAllowThreads(__tstate);
13192 if (PyErr_Occurred()) SWIG_fail;
13193 }
13194 {
13195 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13196 }
13197 return resultobj;
13198 fail:
13199 return NULL;
13200 }
13201
13202
13203 SWIGINTERN PyObject *_wrap_LogChain_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13204 PyObject *resultobj = 0;
13205 wxLogChain *arg1 = (wxLogChain *) 0 ;
13206 wxLog *result = 0 ;
13207 void *argp1 = 0 ;
13208 int res1 = 0 ;
13209 PyObject *swig_obj[1] ;
13210
13211 if (!args) SWIG_fail;
13212 swig_obj[0] = args;
13213 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13214 if (!SWIG_IsOK(res1)) {
13215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_GetOldLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
13216 }
13217 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13218 {
13219 PyThreadState* __tstate = wxPyBeginAllowThreads();
13220 result = (wxLog *)(arg1)->GetOldLog();
13221 wxPyEndAllowThreads(__tstate);
13222 if (PyErr_Occurred()) SWIG_fail;
13223 }
13224 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
13225 return resultobj;
13226 fail:
13227 return NULL;
13228 }
13229
13230
13231 SWIGINTERN PyObject *LogChain_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13232 PyObject *obj;
13233 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13234 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogChain, SWIG_NewClientData(obj));
13235 return SWIG_Py_Void();
13236 }
13237
13238 SWIGINTERN PyObject *LogChain_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13239 return SWIG_Python_InitShadowInstance(args);
13240 }
13241
13242 SWIGINTERN PyObject *_wrap_new_LogBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13243 PyObject *resultobj = 0;
13244 wxLogBuffer *result = 0 ;
13245
13246 if (!SWIG_Python_UnpackTuple(args,"new_LogBuffer",0,0,0)) SWIG_fail;
13247 {
13248 PyThreadState* __tstate = wxPyBeginAllowThreads();
13249 result = (wxLogBuffer *)new wxLogBuffer();
13250 wxPyEndAllowThreads(__tstate);
13251 if (PyErr_Occurred()) SWIG_fail;
13252 }
13253 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogBuffer, SWIG_POINTER_NEW | 0 );
13254 return resultobj;
13255 fail:
13256 return NULL;
13257 }
13258
13259
13260 SWIGINTERN PyObject *_wrap_LogBuffer_GetBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13261 PyObject *resultobj = 0;
13262 wxLogBuffer *arg1 = (wxLogBuffer *) 0 ;
13263 wxString *result = 0 ;
13264 void *argp1 = 0 ;
13265 int res1 = 0 ;
13266 PyObject *swig_obj[1] ;
13267
13268 if (!args) SWIG_fail;
13269 swig_obj[0] = args;
13270 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogBuffer, 0 | 0 );
13271 if (!SWIG_IsOK(res1)) {
13272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogBuffer_GetBuffer" "', expected argument " "1"" of type '" "wxLogBuffer const *""'");
13273 }
13274 arg1 = reinterpret_cast< wxLogBuffer * >(argp1);
13275 {
13276 PyThreadState* __tstate = wxPyBeginAllowThreads();
13277 {
13278 wxString const &_result_ref = ((wxLogBuffer const *)arg1)->GetBuffer();
13279 result = (wxString *) &_result_ref;
13280 }
13281 wxPyEndAllowThreads(__tstate);
13282 if (PyErr_Occurred()) SWIG_fail;
13283 }
13284 {
13285 #if wxUSE_UNICODE
13286 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13287 #else
13288 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13289 #endif
13290 }
13291 return resultobj;
13292 fail:
13293 return NULL;
13294 }
13295
13296
13297 SWIGINTERN PyObject *LogBuffer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13298 PyObject *obj;
13299 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13300 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogBuffer, SWIG_NewClientData(obj));
13301 return SWIG_Py_Void();
13302 }
13303
13304 SWIGINTERN PyObject *LogBuffer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13305 return SWIG_Python_InitShadowInstance(args);
13306 }
13307
13308 SWIGINTERN PyObject *_wrap_SysErrorCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13309 PyObject *resultobj = 0;
13310 unsigned long result;
13311
13312 if (!SWIG_Python_UnpackTuple(args,"SysErrorCode",0,0,0)) SWIG_fail;
13313 {
13314 PyThreadState* __tstate = wxPyBeginAllowThreads();
13315 result = (unsigned long)wxSysErrorCode();
13316 wxPyEndAllowThreads(__tstate);
13317 if (PyErr_Occurred()) SWIG_fail;
13318 }
13319 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
13320 return resultobj;
13321 fail:
13322 return NULL;
13323 }
13324
13325
13326 SWIGINTERN PyObject *_wrap_SysErrorMsg(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13327 PyObject *resultobj = 0;
13328 unsigned long arg1 = (unsigned long) 0 ;
13329 wxString result;
13330 unsigned long val1 ;
13331 int ecode1 = 0 ;
13332 PyObject * obj0 = 0 ;
13333 char * kwnames[] = {
13334 (char *) "nErrCode", NULL
13335 };
13336
13337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) SWIG_fail;
13338 if (obj0) {
13339 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
13340 if (!SWIG_IsOK(ecode1)) {
13341 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SysErrorMsg" "', expected argument " "1"" of type '" "unsigned long""'");
13342 }
13343 arg1 = static_cast< unsigned long >(val1);
13344 }
13345 {
13346 PyThreadState* __tstate = wxPyBeginAllowThreads();
13347 result = wxSysErrorMsg(arg1);
13348 wxPyEndAllowThreads(__tstate);
13349 if (PyErr_Occurred()) SWIG_fail;
13350 }
13351 {
13352 #if wxUSE_UNICODE
13353 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13354 #else
13355 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13356 #endif
13357 }
13358 return resultobj;
13359 fail:
13360 return NULL;
13361 }
13362
13363
13364 SWIGINTERN PyObject *_wrap_LogFatalError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13365 PyObject *resultobj = 0;
13366 wxString *arg1 = 0 ;
13367 bool temp1 = false ;
13368 PyObject * obj0 = 0 ;
13369 char * kwnames[] = {
13370 (char *) "msg", NULL
13371 };
13372
13373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) SWIG_fail;
13374 {
13375 arg1 = wxString_in_helper(obj0);
13376 if (arg1 == NULL) SWIG_fail;
13377 temp1 = true;
13378 }
13379 {
13380 PyThreadState* __tstate = wxPyBeginAllowThreads();
13381 wxPyLogFatalError((wxString const &)*arg1);
13382 wxPyEndAllowThreads(__tstate);
13383 if (PyErr_Occurred()) SWIG_fail;
13384 }
13385 resultobj = SWIG_Py_Void();
13386 {
13387 if (temp1)
13388 delete arg1;
13389 }
13390 return resultobj;
13391 fail:
13392 {
13393 if (temp1)
13394 delete arg1;
13395 }
13396 return NULL;
13397 }
13398
13399
13400 SWIGINTERN PyObject *_wrap_LogError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13401 PyObject *resultobj = 0;
13402 wxString *arg1 = 0 ;
13403 bool temp1 = false ;
13404 PyObject * obj0 = 0 ;
13405 char * kwnames[] = {
13406 (char *) "msg", NULL
13407 };
13408
13409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) SWIG_fail;
13410 {
13411 arg1 = wxString_in_helper(obj0);
13412 if (arg1 == NULL) SWIG_fail;
13413 temp1 = true;
13414 }
13415 {
13416 PyThreadState* __tstate = wxPyBeginAllowThreads();
13417 wxPyLogError((wxString const &)*arg1);
13418 wxPyEndAllowThreads(__tstate);
13419 if (PyErr_Occurred()) SWIG_fail;
13420 }
13421 resultobj = SWIG_Py_Void();
13422 {
13423 if (temp1)
13424 delete arg1;
13425 }
13426 return resultobj;
13427 fail:
13428 {
13429 if (temp1)
13430 delete arg1;
13431 }
13432 return NULL;
13433 }
13434
13435
13436 SWIGINTERN PyObject *_wrap_LogWarning(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13437 PyObject *resultobj = 0;
13438 wxString *arg1 = 0 ;
13439 bool temp1 = false ;
13440 PyObject * obj0 = 0 ;
13441 char * kwnames[] = {
13442 (char *) "msg", NULL
13443 };
13444
13445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) SWIG_fail;
13446 {
13447 arg1 = wxString_in_helper(obj0);
13448 if (arg1 == NULL) SWIG_fail;
13449 temp1 = true;
13450 }
13451 {
13452 PyThreadState* __tstate = wxPyBeginAllowThreads();
13453 wxPyLogWarning((wxString const &)*arg1);
13454 wxPyEndAllowThreads(__tstate);
13455 if (PyErr_Occurred()) SWIG_fail;
13456 }
13457 resultobj = SWIG_Py_Void();
13458 {
13459 if (temp1)
13460 delete arg1;
13461 }
13462 return resultobj;
13463 fail:
13464 {
13465 if (temp1)
13466 delete arg1;
13467 }
13468 return NULL;
13469 }
13470
13471
13472 SWIGINTERN PyObject *_wrap_LogMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13473 PyObject *resultobj = 0;
13474 wxString *arg1 = 0 ;
13475 bool temp1 = false ;
13476 PyObject * obj0 = 0 ;
13477 char * kwnames[] = {
13478 (char *) "msg", NULL
13479 };
13480
13481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) SWIG_fail;
13482 {
13483 arg1 = wxString_in_helper(obj0);
13484 if (arg1 == NULL) SWIG_fail;
13485 temp1 = true;
13486 }
13487 {
13488 PyThreadState* __tstate = wxPyBeginAllowThreads();
13489 wxPyLogMessage((wxString const &)*arg1);
13490 wxPyEndAllowThreads(__tstate);
13491 if (PyErr_Occurred()) SWIG_fail;
13492 }
13493 resultobj = SWIG_Py_Void();
13494 {
13495 if (temp1)
13496 delete arg1;
13497 }
13498 return resultobj;
13499 fail:
13500 {
13501 if (temp1)
13502 delete arg1;
13503 }
13504 return NULL;
13505 }
13506
13507
13508 SWIGINTERN PyObject *_wrap_LogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13509 PyObject *resultobj = 0;
13510 wxString *arg1 = 0 ;
13511 bool temp1 = false ;
13512 PyObject * obj0 = 0 ;
13513 char * kwnames[] = {
13514 (char *) "msg", NULL
13515 };
13516
13517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) SWIG_fail;
13518 {
13519 arg1 = wxString_in_helper(obj0);
13520 if (arg1 == NULL) SWIG_fail;
13521 temp1 = true;
13522 }
13523 {
13524 PyThreadState* __tstate = wxPyBeginAllowThreads();
13525 wxPyLogInfo((wxString const &)*arg1);
13526 wxPyEndAllowThreads(__tstate);
13527 if (PyErr_Occurred()) SWIG_fail;
13528 }
13529 resultobj = SWIG_Py_Void();
13530 {
13531 if (temp1)
13532 delete arg1;
13533 }
13534 return resultobj;
13535 fail:
13536 {
13537 if (temp1)
13538 delete arg1;
13539 }
13540 return NULL;
13541 }
13542
13543
13544 SWIGINTERN PyObject *_wrap_LogDebug(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13545 PyObject *resultobj = 0;
13546 wxString *arg1 = 0 ;
13547 bool temp1 = false ;
13548 PyObject * obj0 = 0 ;
13549 char * kwnames[] = {
13550 (char *) "msg", NULL
13551 };
13552
13553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) SWIG_fail;
13554 {
13555 arg1 = wxString_in_helper(obj0);
13556 if (arg1 == NULL) SWIG_fail;
13557 temp1 = true;
13558 }
13559 {
13560 PyThreadState* __tstate = wxPyBeginAllowThreads();
13561 wxPyLogDebug((wxString const &)*arg1);
13562 wxPyEndAllowThreads(__tstate);
13563 if (PyErr_Occurred()) SWIG_fail;
13564 }
13565 resultobj = SWIG_Py_Void();
13566 {
13567 if (temp1)
13568 delete arg1;
13569 }
13570 return resultobj;
13571 fail:
13572 {
13573 if (temp1)
13574 delete arg1;
13575 }
13576 return NULL;
13577 }
13578
13579
13580 SWIGINTERN PyObject *_wrap_LogVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13581 PyObject *resultobj = 0;
13582 wxString *arg1 = 0 ;
13583 bool temp1 = false ;
13584 PyObject * obj0 = 0 ;
13585 char * kwnames[] = {
13586 (char *) "msg", NULL
13587 };
13588
13589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) SWIG_fail;
13590 {
13591 arg1 = wxString_in_helper(obj0);
13592 if (arg1 == NULL) SWIG_fail;
13593 temp1 = true;
13594 }
13595 {
13596 PyThreadState* __tstate = wxPyBeginAllowThreads();
13597 wxPyLogVerbose((wxString const &)*arg1);
13598 wxPyEndAllowThreads(__tstate);
13599 if (PyErr_Occurred()) SWIG_fail;
13600 }
13601 resultobj = SWIG_Py_Void();
13602 {
13603 if (temp1)
13604 delete arg1;
13605 }
13606 return resultobj;
13607 fail:
13608 {
13609 if (temp1)
13610 delete arg1;
13611 }
13612 return NULL;
13613 }
13614
13615
13616 SWIGINTERN PyObject *_wrap_LogStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13617 PyObject *resultobj = 0;
13618 wxString *arg1 = 0 ;
13619 bool temp1 = false ;
13620 PyObject * obj0 = 0 ;
13621 char * kwnames[] = {
13622 (char *) "msg", NULL
13623 };
13624
13625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) SWIG_fail;
13626 {
13627 arg1 = wxString_in_helper(obj0);
13628 if (arg1 == NULL) SWIG_fail;
13629 temp1 = true;
13630 }
13631 {
13632 PyThreadState* __tstate = wxPyBeginAllowThreads();
13633 wxPyLogStatus((wxString const &)*arg1);
13634 wxPyEndAllowThreads(__tstate);
13635 if (PyErr_Occurred()) SWIG_fail;
13636 }
13637 resultobj = SWIG_Py_Void();
13638 {
13639 if (temp1)
13640 delete arg1;
13641 }
13642 return resultobj;
13643 fail:
13644 {
13645 if (temp1)
13646 delete arg1;
13647 }
13648 return NULL;
13649 }
13650
13651
13652 SWIGINTERN PyObject *_wrap_LogStatusFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13653 PyObject *resultobj = 0;
13654 wxFrame *arg1 = (wxFrame *) 0 ;
13655 wxString *arg2 = 0 ;
13656 void *argp1 = 0 ;
13657 int res1 = 0 ;
13658 bool temp2 = false ;
13659 PyObject * obj0 = 0 ;
13660 PyObject * obj1 = 0 ;
13661 char * kwnames[] = {
13662 (char *) "pFrame",(char *) "msg", NULL
13663 };
13664
13665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) SWIG_fail;
13666 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
13667 if (!SWIG_IsOK(res1)) {
13668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogStatusFrame" "', expected argument " "1"" of type '" "wxFrame *""'");
13669 }
13670 arg1 = reinterpret_cast< wxFrame * >(argp1);
13671 {
13672 arg2 = wxString_in_helper(obj1);
13673 if (arg2 == NULL) SWIG_fail;
13674 temp2 = true;
13675 }
13676 {
13677 PyThreadState* __tstate = wxPyBeginAllowThreads();
13678 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
13679 wxPyEndAllowThreads(__tstate);
13680 if (PyErr_Occurred()) SWIG_fail;
13681 }
13682 resultobj = SWIG_Py_Void();
13683 {
13684 if (temp2)
13685 delete arg2;
13686 }
13687 return resultobj;
13688 fail:
13689 {
13690 if (temp2)
13691 delete arg2;
13692 }
13693 return NULL;
13694 }
13695
13696
13697 SWIGINTERN PyObject *_wrap_LogSysError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13698 PyObject *resultobj = 0;
13699 wxString *arg1 = 0 ;
13700 bool temp1 = false ;
13701 PyObject * obj0 = 0 ;
13702 char * kwnames[] = {
13703 (char *) "msg", NULL
13704 };
13705
13706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) SWIG_fail;
13707 {
13708 arg1 = wxString_in_helper(obj0);
13709 if (arg1 == NULL) SWIG_fail;
13710 temp1 = true;
13711 }
13712 {
13713 PyThreadState* __tstate = wxPyBeginAllowThreads();
13714 wxPyLogSysError((wxString const &)*arg1);
13715 wxPyEndAllowThreads(__tstate);
13716 if (PyErr_Occurred()) SWIG_fail;
13717 }
13718 resultobj = SWIG_Py_Void();
13719 {
13720 if (temp1)
13721 delete arg1;
13722 }
13723 return resultobj;
13724 fail:
13725 {
13726 if (temp1)
13727 delete arg1;
13728 }
13729 return NULL;
13730 }
13731
13732
13733 SWIGINTERN PyObject *_wrap_LogGeneric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13734 PyObject *resultobj = 0;
13735 unsigned long arg1 ;
13736 wxString *arg2 = 0 ;
13737 unsigned long val1 ;
13738 int ecode1 = 0 ;
13739 bool temp2 = false ;
13740 PyObject * obj0 = 0 ;
13741 PyObject * obj1 = 0 ;
13742 char * kwnames[] = {
13743 (char *) "level",(char *) "msg", NULL
13744 };
13745
13746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) SWIG_fail;
13747 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
13748 if (!SWIG_IsOK(ecode1)) {
13749 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogGeneric" "', expected argument " "1"" of type '" "unsigned long""'");
13750 }
13751 arg1 = static_cast< unsigned long >(val1);
13752 {
13753 arg2 = wxString_in_helper(obj1);
13754 if (arg2 == NULL) SWIG_fail;
13755 temp2 = true;
13756 }
13757 {
13758 PyThreadState* __tstate = wxPyBeginAllowThreads();
13759 wxPyLogGeneric(arg1,(wxString const &)*arg2);
13760 wxPyEndAllowThreads(__tstate);
13761 if (PyErr_Occurred()) SWIG_fail;
13762 }
13763 resultobj = SWIG_Py_Void();
13764 {
13765 if (temp2)
13766 delete arg2;
13767 }
13768 return resultobj;
13769 fail:
13770 {
13771 if (temp2)
13772 delete arg2;
13773 }
13774 return NULL;
13775 }
13776
13777
13778 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
13779 PyObject *resultobj = 0;
13780 unsigned long arg1 ;
13781 wxString *arg2 = 0 ;
13782 unsigned long val1 ;
13783 int ecode1 = 0 ;
13784 bool temp2 = false ;
13785
13786 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
13787 ecode1 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val1);
13788 if (!SWIG_IsOK(ecode1)) {
13789 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogTrace" "', expected argument " "1"" of type '" "unsigned long""'");
13790 }
13791 arg1 = static_cast< unsigned long >(val1);
13792 {
13793 arg2 = wxString_in_helper(swig_obj[1]);
13794 if (arg2 == NULL) SWIG_fail;
13795 temp2 = true;
13796 }
13797 {
13798 PyThreadState* __tstate = wxPyBeginAllowThreads();
13799 wxPyLogTrace(arg1,(wxString const &)*arg2);
13800 wxPyEndAllowThreads(__tstate);
13801 if (PyErr_Occurred()) SWIG_fail;
13802 }
13803 resultobj = SWIG_Py_Void();
13804 {
13805 if (temp2)
13806 delete arg2;
13807 }
13808 return resultobj;
13809 fail:
13810 {
13811 if (temp2)
13812 delete arg2;
13813 }
13814 return NULL;
13815 }
13816
13817
13818 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
13819 PyObject *resultobj = 0;
13820 wxString *arg1 = 0 ;
13821 wxString *arg2 = 0 ;
13822 bool temp1 = false ;
13823 bool temp2 = false ;
13824
13825 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
13826 {
13827 arg1 = wxString_in_helper(swig_obj[0]);
13828 if (arg1 == NULL) SWIG_fail;
13829 temp1 = true;
13830 }
13831 {
13832 arg2 = wxString_in_helper(swig_obj[1]);
13833 if (arg2 == NULL) SWIG_fail;
13834 temp2 = true;
13835 }
13836 {
13837 PyThreadState* __tstate = wxPyBeginAllowThreads();
13838 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
13839 wxPyEndAllowThreads(__tstate);
13840 if (PyErr_Occurred()) SWIG_fail;
13841 }
13842 resultobj = SWIG_Py_Void();
13843 {
13844 if (temp1)
13845 delete arg1;
13846 }
13847 {
13848 if (temp2)
13849 delete arg2;
13850 }
13851 return resultobj;
13852 fail:
13853 {
13854 if (temp1)
13855 delete arg1;
13856 }
13857 {
13858 if (temp2)
13859 delete arg2;
13860 }
13861 return NULL;
13862 }
13863
13864
13865 SWIGINTERN PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
13866 int argc;
13867 PyObject *argv[3];
13868
13869 if (!(argc = SWIG_Python_UnpackTuple(args,"LogTrace",0,2,argv))) SWIG_fail;
13870 --argc;
13871 if (argc == 2) {
13872 int _v = 0;
13873 {
13874 {
13875 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
13876 }
13877 }
13878 if (!_v) goto check_1;
13879 return _wrap_LogTrace__SWIG_1(self, argc, argv);
13880 }
13881 check_1:
13882
13883 if (argc == 2) {
13884 return _wrap_LogTrace__SWIG_0(self, argc, argv);
13885 }
13886
13887 fail:
13888 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
13889 return NULL;
13890 }
13891
13892
13893 SWIGINTERN PyObject *_wrap_SafeShowMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13894 PyObject *resultobj = 0;
13895 wxString *arg1 = 0 ;
13896 wxString *arg2 = 0 ;
13897 bool temp1 = false ;
13898 bool temp2 = false ;
13899 PyObject * obj0 = 0 ;
13900 PyObject * obj1 = 0 ;
13901 char * kwnames[] = {
13902 (char *) "title",(char *) "text", NULL
13903 };
13904
13905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) SWIG_fail;
13906 {
13907 arg1 = wxString_in_helper(obj0);
13908 if (arg1 == NULL) SWIG_fail;
13909 temp1 = true;
13910 }
13911 {
13912 arg2 = wxString_in_helper(obj1);
13913 if (arg2 == NULL) SWIG_fail;
13914 temp2 = true;
13915 }
13916 {
13917 PyThreadState* __tstate = wxPyBeginAllowThreads();
13918 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
13919 wxPyEndAllowThreads(__tstate);
13920 if (PyErr_Occurred()) SWIG_fail;
13921 }
13922 resultobj = SWIG_Py_Void();
13923 {
13924 if (temp1)
13925 delete arg1;
13926 }
13927 {
13928 if (temp2)
13929 delete arg2;
13930 }
13931 return resultobj;
13932 fail:
13933 {
13934 if (temp1)
13935 delete arg1;
13936 }
13937 {
13938 if (temp2)
13939 delete arg2;
13940 }
13941 return NULL;
13942 }
13943
13944
13945 SWIGINTERN PyObject *_wrap_new_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13946 PyObject *resultobj = 0;
13947 wxLogNull *result = 0 ;
13948
13949 if (!SWIG_Python_UnpackTuple(args,"new_LogNull",0,0,0)) SWIG_fail;
13950 {
13951 PyThreadState* __tstate = wxPyBeginAllowThreads();
13952 result = (wxLogNull *)new wxLogNull();
13953 wxPyEndAllowThreads(__tstate);
13954 if (PyErr_Occurred()) SWIG_fail;
13955 }
13956 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogNull, SWIG_POINTER_NEW | 0 );
13957 return resultobj;
13958 fail:
13959 return NULL;
13960 }
13961
13962
13963 SWIGINTERN PyObject *_wrap_delete_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13964 PyObject *resultobj = 0;
13965 wxLogNull *arg1 = (wxLogNull *) 0 ;
13966 void *argp1 = 0 ;
13967 int res1 = 0 ;
13968 PyObject *swig_obj[1] ;
13969
13970 if (!args) SWIG_fail;
13971 swig_obj[0] = args;
13972 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogNull, SWIG_POINTER_DISOWN | 0 );
13973 if (!SWIG_IsOK(res1)) {
13974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LogNull" "', expected argument " "1"" of type '" "wxLogNull *""'");
13975 }
13976 arg1 = reinterpret_cast< wxLogNull * >(argp1);
13977 {
13978 PyThreadState* __tstate = wxPyBeginAllowThreads();
13979 delete arg1;
13980
13981 wxPyEndAllowThreads(__tstate);
13982 if (PyErr_Occurred()) SWIG_fail;
13983 }
13984 resultobj = SWIG_Py_Void();
13985 return resultobj;
13986 fail:
13987 return NULL;
13988 }
13989
13990
13991 SWIGINTERN PyObject *LogNull_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13992 PyObject *obj;
13993 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13994 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogNull, SWIG_NewClientData(obj));
13995 return SWIG_Py_Void();
13996 }
13997
13998 SWIGINTERN PyObject *LogNull_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13999 return SWIG_Python_InitShadowInstance(args);
14000 }
14001
14002 SWIGINTERN PyObject *_wrap_new_PyLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14003 PyObject *resultobj = 0;
14004 wxPyLog *result = 0 ;
14005
14006 if (!SWIG_Python_UnpackTuple(args,"new_PyLog",0,0,0)) SWIG_fail;
14007 {
14008 PyThreadState* __tstate = wxPyBeginAllowThreads();
14009 result = (wxPyLog *)new wxPyLog();
14010 wxPyEndAllowThreads(__tstate);
14011 if (PyErr_Occurred()) SWIG_fail;
14012 }
14013 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyLog, SWIG_POINTER_NEW | 0 );
14014 return resultobj;
14015 fail:
14016 return NULL;
14017 }
14018
14019
14020 SWIGINTERN PyObject *_wrap_PyLog__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14021 PyObject *resultobj = 0;
14022 wxPyLog *arg1 = (wxPyLog *) 0 ;
14023 PyObject *arg2 = (PyObject *) 0 ;
14024 PyObject *arg3 = (PyObject *) 0 ;
14025 void *argp1 = 0 ;
14026 int res1 = 0 ;
14027 PyObject * obj0 = 0 ;
14028 PyObject * obj1 = 0 ;
14029 PyObject * obj2 = 0 ;
14030 char * kwnames[] = {
14031 (char *) "self",(char *) "self",(char *) "_class", NULL
14032 };
14033
14034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14035 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyLog, 0 | 0 );
14036 if (!SWIG_IsOK(res1)) {
14037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyLog__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyLog *""'");
14038 }
14039 arg1 = reinterpret_cast< wxPyLog * >(argp1);
14040 arg2 = obj1;
14041 arg3 = obj2;
14042 {
14043 PyThreadState* __tstate = wxPyBeginAllowThreads();
14044 (arg1)->_setCallbackInfo(arg2,arg3);
14045 wxPyEndAllowThreads(__tstate);
14046 if (PyErr_Occurred()) SWIG_fail;
14047 }
14048 resultobj = SWIG_Py_Void();
14049 return resultobj;
14050 fail:
14051 return NULL;
14052 }
14053
14054
14055 SWIGINTERN PyObject *PyLog_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14056 PyObject *obj;
14057 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14058 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyLog, SWIG_NewClientData(obj));
14059 return SWIG_Py_Void();
14060 }
14061
14062 SWIGINTERN PyObject *PyLog_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14063 return SWIG_Python_InitShadowInstance(args);
14064 }
14065
14066 SWIGINTERN PyObject *_wrap_Process_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14067 PyObject *resultobj = 0;
14068 int arg1 ;
14069 wxSignal arg2 = (wxSignal) wxSIGTERM ;
14070 int arg3 = (int) wxKILL_NOCHILDREN ;
14071 wxKillError result;
14072 int val1 ;
14073 int ecode1 = 0 ;
14074 int val2 ;
14075 int ecode2 = 0 ;
14076 int val3 ;
14077 int ecode3 = 0 ;
14078 PyObject * obj0 = 0 ;
14079 PyObject * obj1 = 0 ;
14080 PyObject * obj2 = 0 ;
14081 char * kwnames[] = {
14082 (char *) "pid",(char *) "sig",(char *) "flags", NULL
14083 };
14084
14085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14086 ecode1 = SWIG_AsVal_int(obj0, &val1);
14087 if (!SWIG_IsOK(ecode1)) {
14088 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Kill" "', expected argument " "1"" of type '" "int""'");
14089 }
14090 arg1 = static_cast< int >(val1);
14091 if (obj1) {
14092 ecode2 = SWIG_AsVal_int(obj1, &val2);
14093 if (!SWIG_IsOK(ecode2)) {
14094 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Kill" "', expected argument " "2"" of type '" "wxSignal""'");
14095 }
14096 arg2 = static_cast< wxSignal >(val2);
14097 }
14098 if (obj2) {
14099 ecode3 = SWIG_AsVal_int(obj2, &val3);
14100 if (!SWIG_IsOK(ecode3)) {
14101 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_Kill" "', expected argument " "3"" of type '" "int""'");
14102 }
14103 arg3 = static_cast< int >(val3);
14104 }
14105 {
14106 PyThreadState* __tstate = wxPyBeginAllowThreads();
14107 result = (wxKillError)wxPyProcess::Kill(arg1,arg2,arg3);
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_Process_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14119 PyObject *resultobj = 0;
14120 int arg1 ;
14121 bool result;
14122 int val1 ;
14123 int ecode1 = 0 ;
14124 PyObject * obj0 = 0 ;
14125 char * kwnames[] = {
14126 (char *) "pid", NULL
14127 };
14128
14129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) SWIG_fail;
14130 ecode1 = SWIG_AsVal_int(obj0, &val1);
14131 if (!SWIG_IsOK(ecode1)) {
14132 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Exists" "', expected argument " "1"" of type '" "int""'");
14133 }
14134 arg1 = static_cast< int >(val1);
14135 {
14136 PyThreadState* __tstate = wxPyBeginAllowThreads();
14137 result = (bool)wxPyProcess::Exists(arg1);
14138 wxPyEndAllowThreads(__tstate);
14139 if (PyErr_Occurred()) SWIG_fail;
14140 }
14141 {
14142 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14143 }
14144 return resultobj;
14145 fail:
14146 return NULL;
14147 }
14148
14149
14150 SWIGINTERN PyObject *_wrap_Process_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14151 PyObject *resultobj = 0;
14152 wxString *arg1 = 0 ;
14153 int arg2 = (int) wxEXEC_ASYNC ;
14154 wxPyProcess *result = 0 ;
14155 bool temp1 = false ;
14156 int val2 ;
14157 int ecode2 = 0 ;
14158 PyObject * obj0 = 0 ;
14159 PyObject * obj1 = 0 ;
14160 char * kwnames[] = {
14161 (char *) "cmd",(char *) "flags", NULL
14162 };
14163
14164 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) SWIG_fail;
14165 {
14166 arg1 = wxString_in_helper(obj0);
14167 if (arg1 == NULL) SWIG_fail;
14168 temp1 = true;
14169 }
14170 if (obj1) {
14171 ecode2 = SWIG_AsVal_int(obj1, &val2);
14172 if (!SWIG_IsOK(ecode2)) {
14173 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Open" "', expected argument " "2"" of type '" "int""'");
14174 }
14175 arg2 = static_cast< int >(val2);
14176 }
14177 {
14178 PyThreadState* __tstate = wxPyBeginAllowThreads();
14179 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
14180 wxPyEndAllowThreads(__tstate);
14181 if (PyErr_Occurred()) SWIG_fail;
14182 }
14183 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, 0 | 0 );
14184 {
14185 if (temp1)
14186 delete arg1;
14187 }
14188 return resultobj;
14189 fail:
14190 {
14191 if (temp1)
14192 delete arg1;
14193 }
14194 return NULL;
14195 }
14196
14197
14198 SWIGINTERN PyObject *_wrap_new_Process(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14199 PyObject *resultobj = 0;
14200 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
14201 int arg2 = (int) -1 ;
14202 wxPyProcess *result = 0 ;
14203 void *argp1 = 0 ;
14204 int res1 = 0 ;
14205 int val2 ;
14206 int ecode2 = 0 ;
14207 PyObject * obj0 = 0 ;
14208 PyObject * obj1 = 0 ;
14209 char * kwnames[] = {
14210 (char *) "parent",(char *) "id", NULL
14211 };
14212
14213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) SWIG_fail;
14214 if (obj0) {
14215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
14216 if (!SWIG_IsOK(res1)) {
14217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Process" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
14218 }
14219 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
14220 }
14221 if (obj1) {
14222 ecode2 = SWIG_AsVal_int(obj1, &val2);
14223 if (!SWIG_IsOK(ecode2)) {
14224 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Process" "', expected argument " "2"" of type '" "int""'");
14225 }
14226 arg2 = static_cast< int >(val2);
14227 }
14228 {
14229 PyThreadState* __tstate = wxPyBeginAllowThreads();
14230 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
14231 wxPyEndAllowThreads(__tstate);
14232 if (PyErr_Occurred()) SWIG_fail;
14233 }
14234 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, SWIG_POINTER_NEW | 0 );
14235 return resultobj;
14236 fail:
14237 return NULL;
14238 }
14239
14240
14241 SWIGINTERN PyObject *_wrap_Process__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14242 PyObject *resultobj = 0;
14243 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14244 PyObject *arg2 = (PyObject *) 0 ;
14245 PyObject *arg3 = (PyObject *) 0 ;
14246 void *argp1 = 0 ;
14247 int res1 = 0 ;
14248 PyObject * obj0 = 0 ;
14249 PyObject * obj1 = 0 ;
14250 PyObject * obj2 = 0 ;
14251 char * kwnames[] = {
14252 (char *) "self",(char *) "self",(char *) "_class", NULL
14253 };
14254
14255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14257 if (!SWIG_IsOK(res1)) {
14258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14259 }
14260 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14261 arg2 = obj1;
14262 arg3 = obj2;
14263 {
14264 PyThreadState* __tstate = wxPyBeginAllowThreads();
14265 (arg1)->_setCallbackInfo(arg2,arg3);
14266 wxPyEndAllowThreads(__tstate);
14267 if (PyErr_Occurred()) SWIG_fail;
14268 }
14269 resultobj = SWIG_Py_Void();
14270 return resultobj;
14271 fail:
14272 return NULL;
14273 }
14274
14275
14276 SWIGINTERN PyObject *_wrap_Process_OnTerminate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14277 PyObject *resultobj = 0;
14278 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14279 int arg2 ;
14280 int arg3 ;
14281 void *argp1 = 0 ;
14282 int res1 = 0 ;
14283 int val2 ;
14284 int ecode2 = 0 ;
14285 int val3 ;
14286 int ecode3 = 0 ;
14287 PyObject * obj0 = 0 ;
14288 PyObject * obj1 = 0 ;
14289 PyObject * obj2 = 0 ;
14290 char * kwnames[] = {
14291 (char *) "self",(char *) "pid",(char *) "status", NULL
14292 };
14293
14294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_OnTerminate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14295 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14296 if (!SWIG_IsOK(res1)) {
14297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_OnTerminate" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14298 }
14299 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14300 ecode2 = SWIG_AsVal_int(obj1, &val2);
14301 if (!SWIG_IsOK(ecode2)) {
14302 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_OnTerminate" "', expected argument " "2"" of type '" "int""'");
14303 }
14304 arg2 = static_cast< int >(val2);
14305 ecode3 = SWIG_AsVal_int(obj2, &val3);
14306 if (!SWIG_IsOK(ecode3)) {
14307 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_OnTerminate" "', expected argument " "3"" of type '" "int""'");
14308 }
14309 arg3 = static_cast< int >(val3);
14310 {
14311 PyThreadState* __tstate = wxPyBeginAllowThreads();
14312 (arg1)->OnTerminate(arg2,arg3);
14313 wxPyEndAllowThreads(__tstate);
14314 if (PyErr_Occurred()) SWIG_fail;
14315 }
14316 resultobj = SWIG_Py_Void();
14317 return resultobj;
14318 fail:
14319 return NULL;
14320 }
14321
14322
14323 SWIGINTERN PyObject *_wrap_Process_Redirect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14324 PyObject *resultobj = 0;
14325 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14326 void *argp1 = 0 ;
14327 int res1 = 0 ;
14328 PyObject *swig_obj[1] ;
14329
14330 if (!args) SWIG_fail;
14331 swig_obj[0] = args;
14332 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14333 if (!SWIG_IsOK(res1)) {
14334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Redirect" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14335 }
14336 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14337 {
14338 PyThreadState* __tstate = wxPyBeginAllowThreads();
14339 (arg1)->Redirect();
14340 wxPyEndAllowThreads(__tstate);
14341 if (PyErr_Occurred()) SWIG_fail;
14342 }
14343 resultobj = SWIG_Py_Void();
14344 return resultobj;
14345 fail:
14346 return NULL;
14347 }
14348
14349
14350 SWIGINTERN PyObject *_wrap_Process_IsRedirected(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14351 PyObject *resultobj = 0;
14352 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14353 bool result;
14354 void *argp1 = 0 ;
14355 int res1 = 0 ;
14356 PyObject *swig_obj[1] ;
14357
14358 if (!args) SWIG_fail;
14359 swig_obj[0] = args;
14360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14361 if (!SWIG_IsOK(res1)) {
14362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsRedirected" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14363 }
14364 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14365 {
14366 PyThreadState* __tstate = wxPyBeginAllowThreads();
14367 result = (bool)(arg1)->IsRedirected();
14368 wxPyEndAllowThreads(__tstate);
14369 if (PyErr_Occurred()) SWIG_fail;
14370 }
14371 {
14372 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14373 }
14374 return resultobj;
14375 fail:
14376 return NULL;
14377 }
14378
14379
14380 SWIGINTERN PyObject *_wrap_Process_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14381 PyObject *resultobj = 0;
14382 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14383 void *argp1 = 0 ;
14384 int res1 = 0 ;
14385 PyObject *swig_obj[1] ;
14386
14387 if (!args) SWIG_fail;
14388 swig_obj[0] = args;
14389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14390 if (!SWIG_IsOK(res1)) {
14391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Detach" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14392 }
14393 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14394 {
14395 PyThreadState* __tstate = wxPyBeginAllowThreads();
14396 (arg1)->Detach();
14397 wxPyEndAllowThreads(__tstate);
14398 if (PyErr_Occurred()) SWIG_fail;
14399 }
14400 resultobj = SWIG_Py_Void();
14401 return resultobj;
14402 fail:
14403 return NULL;
14404 }
14405
14406
14407 SWIGINTERN PyObject *_wrap_Process_GetInputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14408 PyObject *resultobj = 0;
14409 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14410 wxInputStream *result = 0 ;
14411 void *argp1 = 0 ;
14412 int res1 = 0 ;
14413 PyObject *swig_obj[1] ;
14414
14415 if (!args) SWIG_fail;
14416 swig_obj[0] = args;
14417 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14418 if (!SWIG_IsOK(res1)) {
14419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetInputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14420 }
14421 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14422 {
14423 PyThreadState* __tstate = wxPyBeginAllowThreads();
14424 result = (wxInputStream *)(arg1)->GetInputStream();
14425 wxPyEndAllowThreads(__tstate);
14426 if (PyErr_Occurred()) SWIG_fail;
14427 }
14428 {
14429 wxPyInputStream * _ptr = NULL;
14430
14431 if (result) {
14432 _ptr = new wxPyInputStream(result);
14433 }
14434 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
14435 }
14436 return resultobj;
14437 fail:
14438 return NULL;
14439 }
14440
14441
14442 SWIGINTERN PyObject *_wrap_Process_GetErrorStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14443 PyObject *resultobj = 0;
14444 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14445 wxInputStream *result = 0 ;
14446 void *argp1 = 0 ;
14447 int res1 = 0 ;
14448 PyObject *swig_obj[1] ;
14449
14450 if (!args) SWIG_fail;
14451 swig_obj[0] = args;
14452 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14453 if (!SWIG_IsOK(res1)) {
14454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetErrorStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14455 }
14456 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14457 {
14458 PyThreadState* __tstate = wxPyBeginAllowThreads();
14459 result = (wxInputStream *)(arg1)->GetErrorStream();
14460 wxPyEndAllowThreads(__tstate);
14461 if (PyErr_Occurred()) SWIG_fail;
14462 }
14463 {
14464 wxPyInputStream * _ptr = NULL;
14465
14466 if (result) {
14467 _ptr = new wxPyInputStream(result);
14468 }
14469 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
14470 }
14471 return resultobj;
14472 fail:
14473 return NULL;
14474 }
14475
14476
14477 SWIGINTERN PyObject *_wrap_Process_GetOutputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14478 PyObject *resultobj = 0;
14479 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14480 wxOutputStream *result = 0 ;
14481 void *argp1 = 0 ;
14482 int res1 = 0 ;
14483 PyObject *swig_obj[1] ;
14484
14485 if (!args) SWIG_fail;
14486 swig_obj[0] = args;
14487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14488 if (!SWIG_IsOK(res1)) {
14489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetOutputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14490 }
14491 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14492 {
14493 PyThreadState* __tstate = wxPyBeginAllowThreads();
14494 result = (wxOutputStream *)(arg1)->GetOutputStream();
14495 wxPyEndAllowThreads(__tstate);
14496 if (PyErr_Occurred()) SWIG_fail;
14497 }
14498 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxOutputStream, 0 | 0 );
14499 return resultobj;
14500 fail:
14501 return NULL;
14502 }
14503
14504
14505 SWIGINTERN PyObject *_wrap_Process_CloseOutput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14506 PyObject *resultobj = 0;
14507 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14508 void *argp1 = 0 ;
14509 int res1 = 0 ;
14510 PyObject *swig_obj[1] ;
14511
14512 if (!args) SWIG_fail;
14513 swig_obj[0] = args;
14514 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14515 if (!SWIG_IsOK(res1)) {
14516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_CloseOutput" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14517 }
14518 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14519 {
14520 PyThreadState* __tstate = wxPyBeginAllowThreads();
14521 (arg1)->CloseOutput();
14522 wxPyEndAllowThreads(__tstate);
14523 if (PyErr_Occurred()) SWIG_fail;
14524 }
14525 resultobj = SWIG_Py_Void();
14526 return resultobj;
14527 fail:
14528 return NULL;
14529 }
14530
14531
14532 SWIGINTERN PyObject *_wrap_Process_IsInputOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14533 PyObject *resultobj = 0;
14534 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14535 bool result;
14536 void *argp1 = 0 ;
14537 int res1 = 0 ;
14538 PyObject *swig_obj[1] ;
14539
14540 if (!args) SWIG_fail;
14541 swig_obj[0] = args;
14542 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14543 if (!SWIG_IsOK(res1)) {
14544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputOpened" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14545 }
14546 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14547 {
14548 PyThreadState* __tstate = wxPyBeginAllowThreads();
14549 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
14550 wxPyEndAllowThreads(__tstate);
14551 if (PyErr_Occurred()) SWIG_fail;
14552 }
14553 {
14554 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14555 }
14556 return resultobj;
14557 fail:
14558 return NULL;
14559 }
14560
14561
14562 SWIGINTERN PyObject *_wrap_Process_IsInputAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14563 PyObject *resultobj = 0;
14564 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14565 bool result;
14566 void *argp1 = 0 ;
14567 int res1 = 0 ;
14568 PyObject *swig_obj[1] ;
14569
14570 if (!args) SWIG_fail;
14571 swig_obj[0] = args;
14572 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14573 if (!SWIG_IsOK(res1)) {
14574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14575 }
14576 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14577 {
14578 PyThreadState* __tstate = wxPyBeginAllowThreads();
14579 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
14580 wxPyEndAllowThreads(__tstate);
14581 if (PyErr_Occurred()) SWIG_fail;
14582 }
14583 {
14584 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14585 }
14586 return resultobj;
14587 fail:
14588 return NULL;
14589 }
14590
14591
14592 SWIGINTERN PyObject *_wrap_Process_IsErrorAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14593 PyObject *resultobj = 0;
14594 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14595 bool result;
14596 void *argp1 = 0 ;
14597 int res1 = 0 ;
14598 PyObject *swig_obj[1] ;
14599
14600 if (!args) SWIG_fail;
14601 swig_obj[0] = args;
14602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14603 if (!SWIG_IsOK(res1)) {
14604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsErrorAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14605 }
14606 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14607 {
14608 PyThreadState* __tstate = wxPyBeginAllowThreads();
14609 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
14610 wxPyEndAllowThreads(__tstate);
14611 if (PyErr_Occurred()) SWIG_fail;
14612 }
14613 {
14614 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14615 }
14616 return resultobj;
14617 fail:
14618 return NULL;
14619 }
14620
14621
14622 SWIGINTERN PyObject *Process_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14623 PyObject *obj;
14624 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14625 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyProcess, SWIG_NewClientData(obj));
14626 return SWIG_Py_Void();
14627 }
14628
14629 SWIGINTERN PyObject *Process_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14630 return SWIG_Python_InitShadowInstance(args);
14631 }
14632
14633 SWIGINTERN PyObject *_wrap_new_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14634 PyObject *resultobj = 0;
14635 int arg1 = (int) 0 ;
14636 int arg2 = (int) 0 ;
14637 int arg3 = (int) 0 ;
14638 wxProcessEvent *result = 0 ;
14639 int val1 ;
14640 int ecode1 = 0 ;
14641 int val2 ;
14642 int ecode2 = 0 ;
14643 int val3 ;
14644 int ecode3 = 0 ;
14645 PyObject * obj0 = 0 ;
14646 PyObject * obj1 = 0 ;
14647 PyObject * obj2 = 0 ;
14648 char * kwnames[] = {
14649 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
14650 };
14651
14652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14653 if (obj0) {
14654 ecode1 = SWIG_AsVal_int(obj0, &val1);
14655 if (!SWIG_IsOK(ecode1)) {
14656 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ProcessEvent" "', expected argument " "1"" of type '" "int""'");
14657 }
14658 arg1 = static_cast< int >(val1);
14659 }
14660 if (obj1) {
14661 ecode2 = SWIG_AsVal_int(obj1, &val2);
14662 if (!SWIG_IsOK(ecode2)) {
14663 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ProcessEvent" "', expected argument " "2"" of type '" "int""'");
14664 }
14665 arg2 = static_cast< int >(val2);
14666 }
14667 if (obj2) {
14668 ecode3 = SWIG_AsVal_int(obj2, &val3);
14669 if (!SWIG_IsOK(ecode3)) {
14670 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ProcessEvent" "', expected argument " "3"" of type '" "int""'");
14671 }
14672 arg3 = static_cast< int >(val3);
14673 }
14674 {
14675 PyThreadState* __tstate = wxPyBeginAllowThreads();
14676 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
14677 wxPyEndAllowThreads(__tstate);
14678 if (PyErr_Occurred()) SWIG_fail;
14679 }
14680 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_NEW | 0 );
14681 return resultobj;
14682 fail:
14683 return NULL;
14684 }
14685
14686
14687 SWIGINTERN PyObject *_wrap_ProcessEvent_GetPid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14688 PyObject *resultobj = 0;
14689 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14690 int result;
14691 void *argp1 = 0 ;
14692 int res1 = 0 ;
14693 PyObject *swig_obj[1] ;
14694
14695 if (!args) SWIG_fail;
14696 swig_obj[0] = args;
14697 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14698 if (!SWIG_IsOK(res1)) {
14699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetPid" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14700 }
14701 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14702 {
14703 PyThreadState* __tstate = wxPyBeginAllowThreads();
14704 result = (int)(arg1)->GetPid();
14705 wxPyEndAllowThreads(__tstate);
14706 if (PyErr_Occurred()) SWIG_fail;
14707 }
14708 resultobj = SWIG_From_int(static_cast< int >(result));
14709 return resultobj;
14710 fail:
14711 return NULL;
14712 }
14713
14714
14715 SWIGINTERN PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14716 PyObject *resultobj = 0;
14717 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14718 int result;
14719 void *argp1 = 0 ;
14720 int res1 = 0 ;
14721 PyObject *swig_obj[1] ;
14722
14723 if (!args) SWIG_fail;
14724 swig_obj[0] = args;
14725 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14726 if (!SWIG_IsOK(res1)) {
14727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetExitCode" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14728 }
14729 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14730 {
14731 PyThreadState* __tstate = wxPyBeginAllowThreads();
14732 result = (int)(arg1)->GetExitCode();
14733 wxPyEndAllowThreads(__tstate);
14734 if (PyErr_Occurred()) SWIG_fail;
14735 }
14736 resultobj = SWIG_From_int(static_cast< int >(result));
14737 return resultobj;
14738 fail:
14739 return NULL;
14740 }
14741
14742
14743 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14744 PyObject *resultobj = 0;
14745 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14746 int arg2 ;
14747 void *argp1 = 0 ;
14748 int res1 = 0 ;
14749 int val2 ;
14750 int ecode2 = 0 ;
14751 PyObject *swig_obj[2] ;
14752
14753 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_pid_set",2,2,swig_obj)) SWIG_fail;
14754 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14755 if (!SWIG_IsOK(res1)) {
14756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14757 }
14758 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14759 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
14760 if (!SWIG_IsOK(ecode2)) {
14761 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "2"" of type '" "int""'");
14762 }
14763 arg2 = static_cast< int >(val2);
14764 if (arg1) (arg1)->m_pid = arg2;
14765
14766 resultobj = SWIG_Py_Void();
14767 return resultobj;
14768 fail:
14769 return NULL;
14770 }
14771
14772
14773 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14774 PyObject *resultobj = 0;
14775 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14776 int result;
14777 void *argp1 = 0 ;
14778 int res1 = 0 ;
14779 PyObject *swig_obj[1] ;
14780
14781 if (!args) SWIG_fail;
14782 swig_obj[0] = args;
14783 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14784 if (!SWIG_IsOK(res1)) {
14785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14786 }
14787 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14788 result = (int) ((arg1)->m_pid);
14789 resultobj = SWIG_From_int(static_cast< int >(result));
14790 return resultobj;
14791 fail:
14792 return NULL;
14793 }
14794
14795
14796 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14797 PyObject *resultobj = 0;
14798 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14799 int arg2 ;
14800 void *argp1 = 0 ;
14801 int res1 = 0 ;
14802 int val2 ;
14803 int ecode2 = 0 ;
14804 PyObject *swig_obj[2] ;
14805
14806 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_exitcode_set",2,2,swig_obj)) SWIG_fail;
14807 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14808 if (!SWIG_IsOK(res1)) {
14809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14810 }
14811 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14812 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
14813 if (!SWIG_IsOK(ecode2)) {
14814 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "2"" of type '" "int""'");
14815 }
14816 arg2 = static_cast< int >(val2);
14817 if (arg1) (arg1)->m_exitcode = arg2;
14818
14819 resultobj = SWIG_Py_Void();
14820 return resultobj;
14821 fail:
14822 return NULL;
14823 }
14824
14825
14826 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14827 PyObject *resultobj = 0;
14828 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14829 int result;
14830 void *argp1 = 0 ;
14831 int res1 = 0 ;
14832 PyObject *swig_obj[1] ;
14833
14834 if (!args) SWIG_fail;
14835 swig_obj[0] = args;
14836 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14837 if (!SWIG_IsOK(res1)) {
14838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14839 }
14840 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14841 result = (int) ((arg1)->m_exitcode);
14842 resultobj = SWIG_From_int(static_cast< int >(result));
14843 return resultobj;
14844 fail:
14845 return NULL;
14846 }
14847
14848
14849 SWIGINTERN PyObject *ProcessEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14850 PyObject *obj;
14851 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14852 SWIG_TypeNewClientData(SWIGTYPE_p_wxProcessEvent, SWIG_NewClientData(obj));
14853 return SWIG_Py_Void();
14854 }
14855
14856 SWIGINTERN PyObject *ProcessEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14857 return SWIG_Python_InitShadowInstance(args);
14858 }
14859
14860 SWIGINTERN PyObject *_wrap_Execute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14861 PyObject *resultobj = 0;
14862 wxString *arg1 = 0 ;
14863 int arg2 = (int) wxEXEC_ASYNC ;
14864 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
14865 long result;
14866 bool temp1 = false ;
14867 int val2 ;
14868 int ecode2 = 0 ;
14869 void *argp3 = 0 ;
14870 int res3 = 0 ;
14871 PyObject * obj0 = 0 ;
14872 PyObject * obj1 = 0 ;
14873 PyObject * obj2 = 0 ;
14874 char * kwnames[] = {
14875 (char *) "command",(char *) "flags",(char *) "process", NULL
14876 };
14877
14878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14879 {
14880 arg1 = wxString_in_helper(obj0);
14881 if (arg1 == NULL) SWIG_fail;
14882 temp1 = true;
14883 }
14884 if (obj1) {
14885 ecode2 = SWIG_AsVal_int(obj1, &val2);
14886 if (!SWIG_IsOK(ecode2)) {
14887 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Execute" "', expected argument " "2"" of type '" "int""'");
14888 }
14889 arg2 = static_cast< int >(val2);
14890 }
14891 if (obj2) {
14892 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14893 if (!SWIG_IsOK(res3)) {
14894 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Execute" "', expected argument " "3"" of type '" "wxPyProcess *""'");
14895 }
14896 arg3 = reinterpret_cast< wxPyProcess * >(argp3);
14897 }
14898 {
14899 if (!wxPyCheckForApp()) SWIG_fail;
14900 PyThreadState* __tstate = wxPyBeginAllowThreads();
14901 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
14902 wxPyEndAllowThreads(__tstate);
14903 if (PyErr_Occurred()) SWIG_fail;
14904 }
14905 resultobj = SWIG_From_long(static_cast< long >(result));
14906 {
14907 if (temp1)
14908 delete arg1;
14909 }
14910 return resultobj;
14911 fail:
14912 {
14913 if (temp1)
14914 delete arg1;
14915 }
14916 return NULL;
14917 }
14918
14919
14920 SWIGINTERN PyObject *_wrap_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14921 PyObject *resultobj = 0;
14922 long arg1 ;
14923 wxSignal arg2 = (wxSignal) wxSIGTERM ;
14924 wxKillError *arg3 = (wxKillError *) 0 ;
14925 int arg4 = (int) wxKILL_NOCHILDREN ;
14926 int result;
14927 long val1 ;
14928 int ecode1 = 0 ;
14929 int val2 ;
14930 int ecode2 = 0 ;
14931 wxKillError temp3 ;
14932 int val4 ;
14933 int ecode4 = 0 ;
14934 PyObject * obj0 = 0 ;
14935 PyObject * obj1 = 0 ;
14936 PyObject * obj2 = 0 ;
14937 char * kwnames[] = {
14938 (char *) "pid",(char *) "sig",(char *) "flags", NULL
14939 };
14940
14941 {
14942 arg3 = &temp3;
14943 }
14944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14945 ecode1 = SWIG_AsVal_long(obj0, &val1);
14946 if (!SWIG_IsOK(ecode1)) {
14947 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Kill" "', expected argument " "1"" of type '" "long""'");
14948 }
14949 arg1 = static_cast< long >(val1);
14950 if (obj1) {
14951 ecode2 = SWIG_AsVal_int(obj1, &val2);
14952 if (!SWIG_IsOK(ecode2)) {
14953 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Kill" "', expected argument " "2"" of type '" "wxSignal""'");
14954 }
14955 arg2 = static_cast< wxSignal >(val2);
14956 }
14957 if (obj2) {
14958 ecode4 = SWIG_AsVal_int(obj2, &val4);
14959 if (!SWIG_IsOK(ecode4)) {
14960 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Kill" "', expected argument " "4"" of type '" "int""'");
14961 }
14962 arg4 = static_cast< int >(val4);
14963 }
14964 {
14965 PyThreadState* __tstate = wxPyBeginAllowThreads();
14966 result = (int)wxKill(arg1,arg2,arg3,arg4);
14967 wxPyEndAllowThreads(__tstate);
14968 if (PyErr_Occurred()) SWIG_fail;
14969 }
14970 resultobj = SWIG_From_int(static_cast< int >(result));
14971 {
14972 PyObject* o;
14973 o = PyInt_FromLong((long) (*arg3));
14974
14975
14976
14977 resultobj = SWIG_Python_AppendOutput(resultobj, o);
14978
14979 }
14980 return resultobj;
14981 fail:
14982 return NULL;
14983 }
14984
14985
14986 SWIGINTERN PyObject *_wrap_new_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14987 PyObject *resultobj = 0;
14988 int arg1 = (int) wxJOYSTICK1 ;
14989 wxJoystick *result = 0 ;
14990 int val1 ;
14991 int ecode1 = 0 ;
14992 PyObject * obj0 = 0 ;
14993 char * kwnames[] = {
14994 (char *) "joystick", NULL
14995 };
14996
14997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) SWIG_fail;
14998 if (obj0) {
14999 ecode1 = SWIG_AsVal_int(obj0, &val1);
15000 if (!SWIG_IsOK(ecode1)) {
15001 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Joystick" "', expected argument " "1"" of type '" "int""'");
15002 }
15003 arg1 = static_cast< int >(val1);
15004 }
15005 {
15006 if (!wxPyCheckForApp()) SWIG_fail;
15007 PyThreadState* __tstate = wxPyBeginAllowThreads();
15008 result = (wxJoystick *)new wxJoystick(arg1);
15009 wxPyEndAllowThreads(__tstate);
15010 if (PyErr_Occurred()) SWIG_fail;
15011 }
15012 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystick, SWIG_POINTER_NEW | 0 );
15013 return resultobj;
15014 fail:
15015 return NULL;
15016 }
15017
15018
15019 SWIGINTERN PyObject *_wrap_delete_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15020 PyObject *resultobj = 0;
15021 wxJoystick *arg1 = (wxJoystick *) 0 ;
15022 void *argp1 = 0 ;
15023 int res1 = 0 ;
15024 PyObject *swig_obj[1] ;
15025
15026 if (!args) SWIG_fail;
15027 swig_obj[0] = args;
15028 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, SWIG_POINTER_DISOWN | 0 );
15029 if (!SWIG_IsOK(res1)) {
15030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Joystick" "', expected argument " "1"" of type '" "wxJoystick *""'");
15031 }
15032 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15033 {
15034 PyThreadState* __tstate = wxPyBeginAllowThreads();
15035 delete arg1;
15036
15037 wxPyEndAllowThreads(__tstate);
15038 if (PyErr_Occurred()) SWIG_fail;
15039 }
15040 resultobj = SWIG_Py_Void();
15041 return resultobj;
15042 fail:
15043 return NULL;
15044 }
15045
15046
15047 SWIGINTERN PyObject *_wrap_Joystick_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15048 PyObject *resultobj = 0;
15049 wxJoystick *arg1 = (wxJoystick *) 0 ;
15050 wxPoint result;
15051 void *argp1 = 0 ;
15052 int res1 = 0 ;
15053 PyObject *swig_obj[1] ;
15054
15055 if (!args) SWIG_fail;
15056 swig_obj[0] = args;
15057 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15058 if (!SWIG_IsOK(res1)) {
15059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15060 }
15061 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15062 {
15063 PyThreadState* __tstate = wxPyBeginAllowThreads();
15064 result = (arg1)->GetPosition();
15065 wxPyEndAllowThreads(__tstate);
15066 if (PyErr_Occurred()) SWIG_fail;
15067 }
15068 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
15069 return resultobj;
15070 fail:
15071 return NULL;
15072 }
15073
15074
15075 SWIGINTERN PyObject *_wrap_Joystick_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15076 PyObject *resultobj = 0;
15077 wxJoystick *arg1 = (wxJoystick *) 0 ;
15078 int result;
15079 void *argp1 = 0 ;
15080 int res1 = 0 ;
15081 PyObject *swig_obj[1] ;
15082
15083 if (!args) SWIG_fail;
15084 swig_obj[0] = args;
15085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15086 if (!SWIG_IsOK(res1)) {
15087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15088 }
15089 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15090 {
15091 PyThreadState* __tstate = wxPyBeginAllowThreads();
15092 result = (int)(arg1)->GetZPosition();
15093 wxPyEndAllowThreads(__tstate);
15094 if (PyErr_Occurred()) SWIG_fail;
15095 }
15096 resultobj = SWIG_From_int(static_cast< int >(result));
15097 return resultobj;
15098 fail:
15099 return NULL;
15100 }
15101
15102
15103 SWIGINTERN PyObject *_wrap_Joystick_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15104 PyObject *resultobj = 0;
15105 wxJoystick *arg1 = (wxJoystick *) 0 ;
15106 int result;
15107 void *argp1 = 0 ;
15108 int res1 = 0 ;
15109 PyObject *swig_obj[1] ;
15110
15111 if (!args) SWIG_fail;
15112 swig_obj[0] = args;
15113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15114 if (!SWIG_IsOK(res1)) {
15115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetButtonState" "', expected argument " "1"" of type '" "wxJoystick *""'");
15116 }
15117 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15118 {
15119 PyThreadState* __tstate = wxPyBeginAllowThreads();
15120 result = (int)(arg1)->GetButtonState();
15121 wxPyEndAllowThreads(__tstate);
15122 if (PyErr_Occurred()) SWIG_fail;
15123 }
15124 resultobj = SWIG_From_int(static_cast< int >(result));
15125 return resultobj;
15126 fail:
15127 return NULL;
15128 }
15129
15130
15131 SWIGINTERN PyObject *_wrap_Joystick_GetPOVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15132 PyObject *resultobj = 0;
15133 wxJoystick *arg1 = (wxJoystick *) 0 ;
15134 int result;
15135 void *argp1 = 0 ;
15136 int res1 = 0 ;
15137 PyObject *swig_obj[1] ;
15138
15139 if (!args) SWIG_fail;
15140 swig_obj[0] = args;
15141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15142 if (!SWIG_IsOK(res1)) {
15143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15144 }
15145 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15146 {
15147 PyThreadState* __tstate = wxPyBeginAllowThreads();
15148 result = (int)(arg1)->GetPOVPosition();
15149 wxPyEndAllowThreads(__tstate);
15150 if (PyErr_Occurred()) SWIG_fail;
15151 }
15152 resultobj = SWIG_From_int(static_cast< int >(result));
15153 return resultobj;
15154 fail:
15155 return NULL;
15156 }
15157
15158
15159 SWIGINTERN PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15160 PyObject *resultobj = 0;
15161 wxJoystick *arg1 = (wxJoystick *) 0 ;
15162 int result;
15163 void *argp1 = 0 ;
15164 int res1 = 0 ;
15165 PyObject *swig_obj[1] ;
15166
15167 if (!args) SWIG_fail;
15168 swig_obj[0] = args;
15169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15170 if (!SWIG_IsOK(res1)) {
15171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVCTSPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15172 }
15173 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15174 {
15175 PyThreadState* __tstate = wxPyBeginAllowThreads();
15176 result = (int)(arg1)->GetPOVCTSPosition();
15177 wxPyEndAllowThreads(__tstate);
15178 if (PyErr_Occurred()) SWIG_fail;
15179 }
15180 resultobj = SWIG_From_int(static_cast< int >(result));
15181 return resultobj;
15182 fail:
15183 return NULL;
15184 }
15185
15186
15187 SWIGINTERN PyObject *_wrap_Joystick_GetRudderPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15188 PyObject *resultobj = 0;
15189 wxJoystick *arg1 = (wxJoystick *) 0 ;
15190 int result;
15191 void *argp1 = 0 ;
15192 int res1 = 0 ;
15193 PyObject *swig_obj[1] ;
15194
15195 if (!args) SWIG_fail;
15196 swig_obj[0] = args;
15197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15198 if (!SWIG_IsOK(res1)) {
15199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15200 }
15201 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15202 {
15203 PyThreadState* __tstate = wxPyBeginAllowThreads();
15204 result = (int)(arg1)->GetRudderPosition();
15205 wxPyEndAllowThreads(__tstate);
15206 if (PyErr_Occurred()) SWIG_fail;
15207 }
15208 resultobj = SWIG_From_int(static_cast< int >(result));
15209 return resultobj;
15210 fail:
15211 return NULL;
15212 }
15213
15214
15215 SWIGINTERN PyObject *_wrap_Joystick_GetUPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15216 PyObject *resultobj = 0;
15217 wxJoystick *arg1 = (wxJoystick *) 0 ;
15218 int result;
15219 void *argp1 = 0 ;
15220 int res1 = 0 ;
15221 PyObject *swig_obj[1] ;
15222
15223 if (!args) SWIG_fail;
15224 swig_obj[0] = args;
15225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15226 if (!SWIG_IsOK(res1)) {
15227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15228 }
15229 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15230 {
15231 PyThreadState* __tstate = wxPyBeginAllowThreads();
15232 result = (int)(arg1)->GetUPosition();
15233 wxPyEndAllowThreads(__tstate);
15234 if (PyErr_Occurred()) SWIG_fail;
15235 }
15236 resultobj = SWIG_From_int(static_cast< int >(result));
15237 return resultobj;
15238 fail:
15239 return NULL;
15240 }
15241
15242
15243 SWIGINTERN PyObject *_wrap_Joystick_GetVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15244 PyObject *resultobj = 0;
15245 wxJoystick *arg1 = (wxJoystick *) 0 ;
15246 int result;
15247 void *argp1 = 0 ;
15248 int res1 = 0 ;
15249 PyObject *swig_obj[1] ;
15250
15251 if (!args) SWIG_fail;
15252 swig_obj[0] = args;
15253 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15254 if (!SWIG_IsOK(res1)) {
15255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15256 }
15257 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15258 {
15259 PyThreadState* __tstate = wxPyBeginAllowThreads();
15260 result = (int)(arg1)->GetVPosition();
15261 wxPyEndAllowThreads(__tstate);
15262 if (PyErr_Occurred()) SWIG_fail;
15263 }
15264 resultobj = SWIG_From_int(static_cast< int >(result));
15265 return resultobj;
15266 fail:
15267 return NULL;
15268 }
15269
15270
15271 SWIGINTERN PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15272 PyObject *resultobj = 0;
15273 wxJoystick *arg1 = (wxJoystick *) 0 ;
15274 int result;
15275 void *argp1 = 0 ;
15276 int res1 = 0 ;
15277 PyObject *swig_obj[1] ;
15278
15279 if (!args) SWIG_fail;
15280 swig_obj[0] = args;
15281 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15282 if (!SWIG_IsOK(res1)) {
15283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
15284 }
15285 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15286 {
15287 PyThreadState* __tstate = wxPyBeginAllowThreads();
15288 result = (int)(arg1)->GetMovementThreshold();
15289 wxPyEndAllowThreads(__tstate);
15290 if (PyErr_Occurred()) SWIG_fail;
15291 }
15292 resultobj = SWIG_From_int(static_cast< int >(result));
15293 return resultobj;
15294 fail:
15295 return NULL;
15296 }
15297
15298
15299 SWIGINTERN PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15300 PyObject *resultobj = 0;
15301 wxJoystick *arg1 = (wxJoystick *) 0 ;
15302 int arg2 ;
15303 void *argp1 = 0 ;
15304 int res1 = 0 ;
15305 int val2 ;
15306 int ecode2 = 0 ;
15307 PyObject * obj0 = 0 ;
15308 PyObject * obj1 = 0 ;
15309 char * kwnames[] = {
15310 (char *) "self",(char *) "threshold", NULL
15311 };
15312
15313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) SWIG_fail;
15314 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15315 if (!SWIG_IsOK(res1)) {
15316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
15317 }
15318 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15319 ecode2 = SWIG_AsVal_int(obj1, &val2);
15320 if (!SWIG_IsOK(ecode2)) {
15321 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "2"" of type '" "int""'");
15322 }
15323 arg2 = static_cast< int >(val2);
15324 {
15325 PyThreadState* __tstate = wxPyBeginAllowThreads();
15326 (arg1)->SetMovementThreshold(arg2);
15327 wxPyEndAllowThreads(__tstate);
15328 if (PyErr_Occurred()) SWIG_fail;
15329 }
15330 resultobj = SWIG_Py_Void();
15331 return resultobj;
15332 fail:
15333 return NULL;
15334 }
15335
15336
15337 SWIGINTERN PyObject *_wrap_Joystick_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15338 PyObject *resultobj = 0;
15339 wxJoystick *arg1 = (wxJoystick *) 0 ;
15340 bool result;
15341 void *argp1 = 0 ;
15342 int res1 = 0 ;
15343 PyObject *swig_obj[1] ;
15344
15345 if (!args) SWIG_fail;
15346 swig_obj[0] = args;
15347 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15348 if (!SWIG_IsOK(res1)) {
15349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_IsOk" "', expected argument " "1"" of type '" "wxJoystick *""'");
15350 }
15351 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15352 {
15353 PyThreadState* __tstate = wxPyBeginAllowThreads();
15354 result = (bool)(arg1)->IsOk();
15355 wxPyEndAllowThreads(__tstate);
15356 if (PyErr_Occurred()) SWIG_fail;
15357 }
15358 {
15359 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15360 }
15361 return resultobj;
15362 fail:
15363 return NULL;
15364 }
15365
15366
15367 SWIGINTERN PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15368 PyObject *resultobj = 0;
15369 wxJoystick *arg1 = (wxJoystick *) 0 ;
15370 int result;
15371 void *argp1 = 0 ;
15372 int res1 = 0 ;
15373 PyObject *swig_obj[1] ;
15374
15375 if (!args) SWIG_fail;
15376 swig_obj[0] = args;
15377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15378 if (!SWIG_IsOK(res1)) {
15379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberJoysticks" "', expected argument " "1"" of type '" "wxJoystick *""'");
15380 }
15381 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15382 {
15383 PyThreadState* __tstate = wxPyBeginAllowThreads();
15384 result = (int)(arg1)->GetNumberJoysticks();
15385 wxPyEndAllowThreads(__tstate);
15386 if (PyErr_Occurred()) SWIG_fail;
15387 }
15388 resultobj = SWIG_From_int(static_cast< int >(result));
15389 return resultobj;
15390 fail:
15391 return NULL;
15392 }
15393
15394
15395 SWIGINTERN PyObject *_wrap_Joystick_GetManufacturerId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15396 PyObject *resultobj = 0;
15397 wxJoystick *arg1 = (wxJoystick *) 0 ;
15398 int result;
15399 void *argp1 = 0 ;
15400 int res1 = 0 ;
15401 PyObject *swig_obj[1] ;
15402
15403 if (!args) SWIG_fail;
15404 swig_obj[0] = args;
15405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15406 if (!SWIG_IsOK(res1)) {
15407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetManufacturerId" "', expected argument " "1"" of type '" "wxJoystick *""'");
15408 }
15409 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15410 {
15411 PyThreadState* __tstate = wxPyBeginAllowThreads();
15412 result = (int)(arg1)->GetManufacturerId();
15413 wxPyEndAllowThreads(__tstate);
15414 if (PyErr_Occurred()) SWIG_fail;
15415 }
15416 resultobj = SWIG_From_int(static_cast< int >(result));
15417 return resultobj;
15418 fail:
15419 return NULL;
15420 }
15421
15422
15423 SWIGINTERN PyObject *_wrap_Joystick_GetProductId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15424 PyObject *resultobj = 0;
15425 wxJoystick *arg1 = (wxJoystick *) 0 ;
15426 int result;
15427 void *argp1 = 0 ;
15428 int res1 = 0 ;
15429 PyObject *swig_obj[1] ;
15430
15431 if (!args) SWIG_fail;
15432 swig_obj[0] = args;
15433 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15434 if (!SWIG_IsOK(res1)) {
15435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductId" "', expected argument " "1"" of type '" "wxJoystick *""'");
15436 }
15437 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15438 {
15439 PyThreadState* __tstate = wxPyBeginAllowThreads();
15440 result = (int)(arg1)->GetProductId();
15441 wxPyEndAllowThreads(__tstate);
15442 if (PyErr_Occurred()) SWIG_fail;
15443 }
15444 resultobj = SWIG_From_int(static_cast< int >(result));
15445 return resultobj;
15446 fail:
15447 return NULL;
15448 }
15449
15450
15451 SWIGINTERN PyObject *_wrap_Joystick_GetProductName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15452 PyObject *resultobj = 0;
15453 wxJoystick *arg1 = (wxJoystick *) 0 ;
15454 wxString result;
15455 void *argp1 = 0 ;
15456 int res1 = 0 ;
15457 PyObject *swig_obj[1] ;
15458
15459 if (!args) SWIG_fail;
15460 swig_obj[0] = args;
15461 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15462 if (!SWIG_IsOK(res1)) {
15463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductName" "', expected argument " "1"" of type '" "wxJoystick *""'");
15464 }
15465 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15466 {
15467 PyThreadState* __tstate = wxPyBeginAllowThreads();
15468 result = (arg1)->GetProductName();
15469 wxPyEndAllowThreads(__tstate);
15470 if (PyErr_Occurred()) SWIG_fail;
15471 }
15472 {
15473 #if wxUSE_UNICODE
15474 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15475 #else
15476 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15477 #endif
15478 }
15479 return resultobj;
15480 fail:
15481 return NULL;
15482 }
15483
15484
15485 SWIGINTERN PyObject *_wrap_Joystick_GetXMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15486 PyObject *resultobj = 0;
15487 wxJoystick *arg1 = (wxJoystick *) 0 ;
15488 int result;
15489 void *argp1 = 0 ;
15490 int res1 = 0 ;
15491 PyObject *swig_obj[1] ;
15492
15493 if (!args) SWIG_fail;
15494 swig_obj[0] = args;
15495 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15496 if (!SWIG_IsOK(res1)) {
15497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15498 }
15499 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15500 {
15501 PyThreadState* __tstate = wxPyBeginAllowThreads();
15502 result = (int)(arg1)->GetXMin();
15503 wxPyEndAllowThreads(__tstate);
15504 if (PyErr_Occurred()) SWIG_fail;
15505 }
15506 resultobj = SWIG_From_int(static_cast< int >(result));
15507 return resultobj;
15508 fail:
15509 return NULL;
15510 }
15511
15512
15513 SWIGINTERN PyObject *_wrap_Joystick_GetYMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15514 PyObject *resultobj = 0;
15515 wxJoystick *arg1 = (wxJoystick *) 0 ;
15516 int result;
15517 void *argp1 = 0 ;
15518 int res1 = 0 ;
15519 PyObject *swig_obj[1] ;
15520
15521 if (!args) SWIG_fail;
15522 swig_obj[0] = args;
15523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15524 if (!SWIG_IsOK(res1)) {
15525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15526 }
15527 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15528 {
15529 PyThreadState* __tstate = wxPyBeginAllowThreads();
15530 result = (int)(arg1)->GetYMin();
15531 wxPyEndAllowThreads(__tstate);
15532 if (PyErr_Occurred()) SWIG_fail;
15533 }
15534 resultobj = SWIG_From_int(static_cast< int >(result));
15535 return resultobj;
15536 fail:
15537 return NULL;
15538 }
15539
15540
15541 SWIGINTERN PyObject *_wrap_Joystick_GetZMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15542 PyObject *resultobj = 0;
15543 wxJoystick *arg1 = (wxJoystick *) 0 ;
15544 int result;
15545 void *argp1 = 0 ;
15546 int res1 = 0 ;
15547 PyObject *swig_obj[1] ;
15548
15549 if (!args) SWIG_fail;
15550 swig_obj[0] = args;
15551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15552 if (!SWIG_IsOK(res1)) {
15553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15554 }
15555 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15556 {
15557 PyThreadState* __tstate = wxPyBeginAllowThreads();
15558 result = (int)(arg1)->GetZMin();
15559 wxPyEndAllowThreads(__tstate);
15560 if (PyErr_Occurred()) SWIG_fail;
15561 }
15562 resultobj = SWIG_From_int(static_cast< int >(result));
15563 return resultobj;
15564 fail:
15565 return NULL;
15566 }
15567
15568
15569 SWIGINTERN PyObject *_wrap_Joystick_GetXMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15570 PyObject *resultobj = 0;
15571 wxJoystick *arg1 = (wxJoystick *) 0 ;
15572 int result;
15573 void *argp1 = 0 ;
15574 int res1 = 0 ;
15575 PyObject *swig_obj[1] ;
15576
15577 if (!args) SWIG_fail;
15578 swig_obj[0] = args;
15579 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15580 if (!SWIG_IsOK(res1)) {
15581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15582 }
15583 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15584 {
15585 PyThreadState* __tstate = wxPyBeginAllowThreads();
15586 result = (int)(arg1)->GetXMax();
15587 wxPyEndAllowThreads(__tstate);
15588 if (PyErr_Occurred()) SWIG_fail;
15589 }
15590 resultobj = SWIG_From_int(static_cast< int >(result));
15591 return resultobj;
15592 fail:
15593 return NULL;
15594 }
15595
15596
15597 SWIGINTERN PyObject *_wrap_Joystick_GetYMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15598 PyObject *resultobj = 0;
15599 wxJoystick *arg1 = (wxJoystick *) 0 ;
15600 int result;
15601 void *argp1 = 0 ;
15602 int res1 = 0 ;
15603 PyObject *swig_obj[1] ;
15604
15605 if (!args) SWIG_fail;
15606 swig_obj[0] = args;
15607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15608 if (!SWIG_IsOK(res1)) {
15609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15610 }
15611 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15612 {
15613 PyThreadState* __tstate = wxPyBeginAllowThreads();
15614 result = (int)(arg1)->GetYMax();
15615 wxPyEndAllowThreads(__tstate);
15616 if (PyErr_Occurred()) SWIG_fail;
15617 }
15618 resultobj = SWIG_From_int(static_cast< int >(result));
15619 return resultobj;
15620 fail:
15621 return NULL;
15622 }
15623
15624
15625 SWIGINTERN PyObject *_wrap_Joystick_GetZMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15626 PyObject *resultobj = 0;
15627 wxJoystick *arg1 = (wxJoystick *) 0 ;
15628 int result;
15629 void *argp1 = 0 ;
15630 int res1 = 0 ;
15631 PyObject *swig_obj[1] ;
15632
15633 if (!args) SWIG_fail;
15634 swig_obj[0] = args;
15635 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15636 if (!SWIG_IsOK(res1)) {
15637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15638 }
15639 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15640 {
15641 PyThreadState* __tstate = wxPyBeginAllowThreads();
15642 result = (int)(arg1)->GetZMax();
15643 wxPyEndAllowThreads(__tstate);
15644 if (PyErr_Occurred()) SWIG_fail;
15645 }
15646 resultobj = SWIG_From_int(static_cast< int >(result));
15647 return resultobj;
15648 fail:
15649 return NULL;
15650 }
15651
15652
15653 SWIGINTERN PyObject *_wrap_Joystick_GetNumberButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15654 PyObject *resultobj = 0;
15655 wxJoystick *arg1 = (wxJoystick *) 0 ;
15656 int result;
15657 void *argp1 = 0 ;
15658 int res1 = 0 ;
15659 PyObject *swig_obj[1] ;
15660
15661 if (!args) SWIG_fail;
15662 swig_obj[0] = args;
15663 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15664 if (!SWIG_IsOK(res1)) {
15665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
15666 }
15667 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15668 {
15669 PyThreadState* __tstate = wxPyBeginAllowThreads();
15670 result = (int)(arg1)->GetNumberButtons();
15671 wxPyEndAllowThreads(__tstate);
15672 if (PyErr_Occurred()) SWIG_fail;
15673 }
15674 resultobj = SWIG_From_int(static_cast< int >(result));
15675 return resultobj;
15676 fail:
15677 return NULL;
15678 }
15679
15680
15681 SWIGINTERN PyObject *_wrap_Joystick_GetNumberAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15682 PyObject *resultobj = 0;
15683 wxJoystick *arg1 = (wxJoystick *) 0 ;
15684 int result;
15685 void *argp1 = 0 ;
15686 int res1 = 0 ;
15687 PyObject *swig_obj[1] ;
15688
15689 if (!args) SWIG_fail;
15690 swig_obj[0] = args;
15691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15692 if (!SWIG_IsOK(res1)) {
15693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
15694 }
15695 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15696 {
15697 PyThreadState* __tstate = wxPyBeginAllowThreads();
15698 result = (int)(arg1)->GetNumberAxes();
15699 wxPyEndAllowThreads(__tstate);
15700 if (PyErr_Occurred()) SWIG_fail;
15701 }
15702 resultobj = SWIG_From_int(static_cast< int >(result));
15703 return resultobj;
15704 fail:
15705 return NULL;
15706 }
15707
15708
15709 SWIGINTERN PyObject *_wrap_Joystick_GetMaxButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15710 PyObject *resultobj = 0;
15711 wxJoystick *arg1 = (wxJoystick *) 0 ;
15712 int result;
15713 void *argp1 = 0 ;
15714 int res1 = 0 ;
15715 PyObject *swig_obj[1] ;
15716
15717 if (!args) SWIG_fail;
15718 swig_obj[0] = args;
15719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15720 if (!SWIG_IsOK(res1)) {
15721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
15722 }
15723 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15724 {
15725 PyThreadState* __tstate = wxPyBeginAllowThreads();
15726 result = (int)(arg1)->GetMaxButtons();
15727 wxPyEndAllowThreads(__tstate);
15728 if (PyErr_Occurred()) SWIG_fail;
15729 }
15730 resultobj = SWIG_From_int(static_cast< int >(result));
15731 return resultobj;
15732 fail:
15733 return NULL;
15734 }
15735
15736
15737 SWIGINTERN PyObject *_wrap_Joystick_GetMaxAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15738 PyObject *resultobj = 0;
15739 wxJoystick *arg1 = (wxJoystick *) 0 ;
15740 int result;
15741 void *argp1 = 0 ;
15742 int res1 = 0 ;
15743 PyObject *swig_obj[1] ;
15744
15745 if (!args) SWIG_fail;
15746 swig_obj[0] = args;
15747 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15748 if (!SWIG_IsOK(res1)) {
15749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
15750 }
15751 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15752 {
15753 PyThreadState* __tstate = wxPyBeginAllowThreads();
15754 result = (int)(arg1)->GetMaxAxes();
15755 wxPyEndAllowThreads(__tstate);
15756 if (PyErr_Occurred()) SWIG_fail;
15757 }
15758 resultobj = SWIG_From_int(static_cast< int >(result));
15759 return resultobj;
15760 fail:
15761 return NULL;
15762 }
15763
15764
15765 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15766 PyObject *resultobj = 0;
15767 wxJoystick *arg1 = (wxJoystick *) 0 ;
15768 int result;
15769 void *argp1 = 0 ;
15770 int res1 = 0 ;
15771 PyObject *swig_obj[1] ;
15772
15773 if (!args) SWIG_fail;
15774 swig_obj[0] = args;
15775 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15776 if (!SWIG_IsOK(res1)) {
15777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15778 }
15779 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15780 {
15781 PyThreadState* __tstate = wxPyBeginAllowThreads();
15782 result = (int)(arg1)->GetPollingMin();
15783 wxPyEndAllowThreads(__tstate);
15784 if (PyErr_Occurred()) SWIG_fail;
15785 }
15786 resultobj = SWIG_From_int(static_cast< int >(result));
15787 return resultobj;
15788 fail:
15789 return NULL;
15790 }
15791
15792
15793 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15794 PyObject *resultobj = 0;
15795 wxJoystick *arg1 = (wxJoystick *) 0 ;
15796 int result;
15797 void *argp1 = 0 ;
15798 int res1 = 0 ;
15799 PyObject *swig_obj[1] ;
15800
15801 if (!args) SWIG_fail;
15802 swig_obj[0] = args;
15803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15804 if (!SWIG_IsOK(res1)) {
15805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15806 }
15807 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15808 {
15809 PyThreadState* __tstate = wxPyBeginAllowThreads();
15810 result = (int)(arg1)->GetPollingMax();
15811 wxPyEndAllowThreads(__tstate);
15812 if (PyErr_Occurred()) SWIG_fail;
15813 }
15814 resultobj = SWIG_From_int(static_cast< int >(result));
15815 return resultobj;
15816 fail:
15817 return NULL;
15818 }
15819
15820
15821 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15822 PyObject *resultobj = 0;
15823 wxJoystick *arg1 = (wxJoystick *) 0 ;
15824 int result;
15825 void *argp1 = 0 ;
15826 int res1 = 0 ;
15827 PyObject *swig_obj[1] ;
15828
15829 if (!args) SWIG_fail;
15830 swig_obj[0] = args;
15831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15832 if (!SWIG_IsOK(res1)) {
15833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15834 }
15835 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15836 {
15837 PyThreadState* __tstate = wxPyBeginAllowThreads();
15838 result = (int)(arg1)->GetRudderMin();
15839 wxPyEndAllowThreads(__tstate);
15840 if (PyErr_Occurred()) SWIG_fail;
15841 }
15842 resultobj = SWIG_From_int(static_cast< int >(result));
15843 return resultobj;
15844 fail:
15845 return NULL;
15846 }
15847
15848
15849 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15850 PyObject *resultobj = 0;
15851 wxJoystick *arg1 = (wxJoystick *) 0 ;
15852 int result;
15853 void *argp1 = 0 ;
15854 int res1 = 0 ;
15855 PyObject *swig_obj[1] ;
15856
15857 if (!args) SWIG_fail;
15858 swig_obj[0] = args;
15859 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15860 if (!SWIG_IsOK(res1)) {
15861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15862 }
15863 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15864 {
15865 PyThreadState* __tstate = wxPyBeginAllowThreads();
15866 result = (int)(arg1)->GetRudderMax();
15867 wxPyEndAllowThreads(__tstate);
15868 if (PyErr_Occurred()) SWIG_fail;
15869 }
15870 resultobj = SWIG_From_int(static_cast< int >(result));
15871 return resultobj;
15872 fail:
15873 return NULL;
15874 }
15875
15876
15877 SWIGINTERN PyObject *_wrap_Joystick_GetUMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15878 PyObject *resultobj = 0;
15879 wxJoystick *arg1 = (wxJoystick *) 0 ;
15880 int result;
15881 void *argp1 = 0 ;
15882 int res1 = 0 ;
15883 PyObject *swig_obj[1] ;
15884
15885 if (!args) SWIG_fail;
15886 swig_obj[0] = args;
15887 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15888 if (!SWIG_IsOK(res1)) {
15889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15890 }
15891 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15892 {
15893 PyThreadState* __tstate = wxPyBeginAllowThreads();
15894 result = (int)(arg1)->GetUMin();
15895 wxPyEndAllowThreads(__tstate);
15896 if (PyErr_Occurred()) SWIG_fail;
15897 }
15898 resultobj = SWIG_From_int(static_cast< int >(result));
15899 return resultobj;
15900 fail:
15901 return NULL;
15902 }
15903
15904
15905 SWIGINTERN PyObject *_wrap_Joystick_GetUMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15906 PyObject *resultobj = 0;
15907 wxJoystick *arg1 = (wxJoystick *) 0 ;
15908 int result;
15909 void *argp1 = 0 ;
15910 int res1 = 0 ;
15911 PyObject *swig_obj[1] ;
15912
15913 if (!args) SWIG_fail;
15914 swig_obj[0] = args;
15915 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15916 if (!SWIG_IsOK(res1)) {
15917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15918 }
15919 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15920 {
15921 PyThreadState* __tstate = wxPyBeginAllowThreads();
15922 result = (int)(arg1)->GetUMax();
15923 wxPyEndAllowThreads(__tstate);
15924 if (PyErr_Occurred()) SWIG_fail;
15925 }
15926 resultobj = SWIG_From_int(static_cast< int >(result));
15927 return resultobj;
15928 fail:
15929 return NULL;
15930 }
15931
15932
15933 SWIGINTERN PyObject *_wrap_Joystick_GetVMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15934 PyObject *resultobj = 0;
15935 wxJoystick *arg1 = (wxJoystick *) 0 ;
15936 int result;
15937 void *argp1 = 0 ;
15938 int res1 = 0 ;
15939 PyObject *swig_obj[1] ;
15940
15941 if (!args) SWIG_fail;
15942 swig_obj[0] = args;
15943 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15944 if (!SWIG_IsOK(res1)) {
15945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15946 }
15947 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15948 {
15949 PyThreadState* __tstate = wxPyBeginAllowThreads();
15950 result = (int)(arg1)->GetVMin();
15951 wxPyEndAllowThreads(__tstate);
15952 if (PyErr_Occurred()) SWIG_fail;
15953 }
15954 resultobj = SWIG_From_int(static_cast< int >(result));
15955 return resultobj;
15956 fail:
15957 return NULL;
15958 }
15959
15960
15961 SWIGINTERN PyObject *_wrap_Joystick_GetVMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15962 PyObject *resultobj = 0;
15963 wxJoystick *arg1 = (wxJoystick *) 0 ;
15964 int result;
15965 void *argp1 = 0 ;
15966 int res1 = 0 ;
15967 PyObject *swig_obj[1] ;
15968
15969 if (!args) SWIG_fail;
15970 swig_obj[0] = args;
15971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15972 if (!SWIG_IsOK(res1)) {
15973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15974 }
15975 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15976 {
15977 PyThreadState* __tstate = wxPyBeginAllowThreads();
15978 result = (int)(arg1)->GetVMax();
15979 wxPyEndAllowThreads(__tstate);
15980 if (PyErr_Occurred()) SWIG_fail;
15981 }
15982 resultobj = SWIG_From_int(static_cast< int >(result));
15983 return resultobj;
15984 fail:
15985 return NULL;
15986 }
15987
15988
15989 SWIGINTERN PyObject *_wrap_Joystick_HasRudder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15990 PyObject *resultobj = 0;
15991 wxJoystick *arg1 = (wxJoystick *) 0 ;
15992 bool result;
15993 void *argp1 = 0 ;
15994 int res1 = 0 ;
15995 PyObject *swig_obj[1] ;
15996
15997 if (!args) SWIG_fail;
15998 swig_obj[0] = args;
15999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16000 if (!SWIG_IsOK(res1)) {
16001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasRudder" "', expected argument " "1"" of type '" "wxJoystick *""'");
16002 }
16003 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16004 {
16005 PyThreadState* __tstate = wxPyBeginAllowThreads();
16006 result = (bool)(arg1)->HasRudder();
16007 wxPyEndAllowThreads(__tstate);
16008 if (PyErr_Occurred()) SWIG_fail;
16009 }
16010 {
16011 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16012 }
16013 return resultobj;
16014 fail:
16015 return NULL;
16016 }
16017
16018
16019 SWIGINTERN PyObject *_wrap_Joystick_HasZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16020 PyObject *resultobj = 0;
16021 wxJoystick *arg1 = (wxJoystick *) 0 ;
16022 bool result;
16023 void *argp1 = 0 ;
16024 int res1 = 0 ;
16025 PyObject *swig_obj[1] ;
16026
16027 if (!args) SWIG_fail;
16028 swig_obj[0] = args;
16029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16030 if (!SWIG_IsOK(res1)) {
16031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasZ" "', expected argument " "1"" of type '" "wxJoystick *""'");
16032 }
16033 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16034 {
16035 PyThreadState* __tstate = wxPyBeginAllowThreads();
16036 result = (bool)(arg1)->HasZ();
16037 wxPyEndAllowThreads(__tstate);
16038 if (PyErr_Occurred()) SWIG_fail;
16039 }
16040 {
16041 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16042 }
16043 return resultobj;
16044 fail:
16045 return NULL;
16046 }
16047
16048
16049 SWIGINTERN PyObject *_wrap_Joystick_HasU(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16050 PyObject *resultobj = 0;
16051 wxJoystick *arg1 = (wxJoystick *) 0 ;
16052 bool result;
16053 void *argp1 = 0 ;
16054 int res1 = 0 ;
16055 PyObject *swig_obj[1] ;
16056
16057 if (!args) SWIG_fail;
16058 swig_obj[0] = args;
16059 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16060 if (!SWIG_IsOK(res1)) {
16061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasU" "', expected argument " "1"" of type '" "wxJoystick *""'");
16062 }
16063 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16064 {
16065 PyThreadState* __tstate = wxPyBeginAllowThreads();
16066 result = (bool)(arg1)->HasU();
16067 wxPyEndAllowThreads(__tstate);
16068 if (PyErr_Occurred()) SWIG_fail;
16069 }
16070 {
16071 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16072 }
16073 return resultobj;
16074 fail:
16075 return NULL;
16076 }
16077
16078
16079 SWIGINTERN PyObject *_wrap_Joystick_HasV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16080 PyObject *resultobj = 0;
16081 wxJoystick *arg1 = (wxJoystick *) 0 ;
16082 bool result;
16083 void *argp1 = 0 ;
16084 int res1 = 0 ;
16085 PyObject *swig_obj[1] ;
16086
16087 if (!args) SWIG_fail;
16088 swig_obj[0] = args;
16089 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16090 if (!SWIG_IsOK(res1)) {
16091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasV" "', expected argument " "1"" of type '" "wxJoystick *""'");
16092 }
16093 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16094 {
16095 PyThreadState* __tstate = wxPyBeginAllowThreads();
16096 result = (bool)(arg1)->HasV();
16097 wxPyEndAllowThreads(__tstate);
16098 if (PyErr_Occurred()) SWIG_fail;
16099 }
16100 {
16101 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16102 }
16103 return resultobj;
16104 fail:
16105 return NULL;
16106 }
16107
16108
16109 SWIGINTERN PyObject *_wrap_Joystick_HasPOV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16110 PyObject *resultobj = 0;
16111 wxJoystick *arg1 = (wxJoystick *) 0 ;
16112 bool result;
16113 void *argp1 = 0 ;
16114 int res1 = 0 ;
16115 PyObject *swig_obj[1] ;
16116
16117 if (!args) SWIG_fail;
16118 swig_obj[0] = args;
16119 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16120 if (!SWIG_IsOK(res1)) {
16121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV" "', expected argument " "1"" of type '" "wxJoystick *""'");
16122 }
16123 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16124 {
16125 PyThreadState* __tstate = wxPyBeginAllowThreads();
16126 result = (bool)(arg1)->HasPOV();
16127 wxPyEndAllowThreads(__tstate);
16128 if (PyErr_Occurred()) SWIG_fail;
16129 }
16130 {
16131 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16132 }
16133 return resultobj;
16134 fail:
16135 return NULL;
16136 }
16137
16138
16139 SWIGINTERN PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16140 PyObject *resultobj = 0;
16141 wxJoystick *arg1 = (wxJoystick *) 0 ;
16142 bool result;
16143 void *argp1 = 0 ;
16144 int res1 = 0 ;
16145 PyObject *swig_obj[1] ;
16146
16147 if (!args) SWIG_fail;
16148 swig_obj[0] = args;
16149 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16150 if (!SWIG_IsOK(res1)) {
16151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV4Dir" "', expected argument " "1"" of type '" "wxJoystick *""'");
16152 }
16153 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16154 {
16155 PyThreadState* __tstate = wxPyBeginAllowThreads();
16156 result = (bool)(arg1)->HasPOV4Dir();
16157 wxPyEndAllowThreads(__tstate);
16158 if (PyErr_Occurred()) SWIG_fail;
16159 }
16160 {
16161 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16162 }
16163 return resultobj;
16164 fail:
16165 return NULL;
16166 }
16167
16168
16169 SWIGINTERN PyObject *_wrap_Joystick_HasPOVCTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16170 PyObject *resultobj = 0;
16171 wxJoystick *arg1 = (wxJoystick *) 0 ;
16172 bool result;
16173 void *argp1 = 0 ;
16174 int res1 = 0 ;
16175 PyObject *swig_obj[1] ;
16176
16177 if (!args) SWIG_fail;
16178 swig_obj[0] = args;
16179 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16180 if (!SWIG_IsOK(res1)) {
16181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOVCTS" "', expected argument " "1"" of type '" "wxJoystick *""'");
16182 }
16183 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16184 {
16185 PyThreadState* __tstate = wxPyBeginAllowThreads();
16186 result = (bool)(arg1)->HasPOVCTS();
16187 wxPyEndAllowThreads(__tstate);
16188 if (PyErr_Occurred()) SWIG_fail;
16189 }
16190 {
16191 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16192 }
16193 return resultobj;
16194 fail:
16195 return NULL;
16196 }
16197
16198
16199 SWIGINTERN PyObject *_wrap_Joystick_SetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16200 PyObject *resultobj = 0;
16201 wxJoystick *arg1 = (wxJoystick *) 0 ;
16202 wxWindow *arg2 = (wxWindow *) 0 ;
16203 int arg3 = (int) 0 ;
16204 bool result;
16205 void *argp1 = 0 ;
16206 int res1 = 0 ;
16207 void *argp2 = 0 ;
16208 int res2 = 0 ;
16209 int val3 ;
16210 int ecode3 = 0 ;
16211 PyObject * obj0 = 0 ;
16212 PyObject * obj1 = 0 ;
16213 PyObject * obj2 = 0 ;
16214 char * kwnames[] = {
16215 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
16216 };
16217
16218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16220 if (!SWIG_IsOK(res1)) {
16221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
16222 }
16223 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16224 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
16225 if (!SWIG_IsOK(res2)) {
16226 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Joystick_SetCapture" "', expected argument " "2"" of type '" "wxWindow *""'");
16227 }
16228 arg2 = reinterpret_cast< wxWindow * >(argp2);
16229 if (obj2) {
16230 ecode3 = SWIG_AsVal_int(obj2, &val3);
16231 if (!SWIG_IsOK(ecode3)) {
16232 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Joystick_SetCapture" "', expected argument " "3"" of type '" "int""'");
16233 }
16234 arg3 = static_cast< int >(val3);
16235 }
16236 {
16237 PyThreadState* __tstate = wxPyBeginAllowThreads();
16238 result = (bool)(arg1)->SetCapture(arg2,arg3);
16239 wxPyEndAllowThreads(__tstate);
16240 if (PyErr_Occurred()) SWIG_fail;
16241 }
16242 {
16243 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16244 }
16245 return resultobj;
16246 fail:
16247 return NULL;
16248 }
16249
16250
16251 SWIGINTERN PyObject *_wrap_Joystick_ReleaseCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16252 PyObject *resultobj = 0;
16253 wxJoystick *arg1 = (wxJoystick *) 0 ;
16254 bool result;
16255 void *argp1 = 0 ;
16256 int res1 = 0 ;
16257 PyObject *swig_obj[1] ;
16258
16259 if (!args) SWIG_fail;
16260 swig_obj[0] = args;
16261 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16262 if (!SWIG_IsOK(res1)) {
16263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_ReleaseCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
16264 }
16265 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16266 {
16267 PyThreadState* __tstate = wxPyBeginAllowThreads();
16268 result = (bool)(arg1)->ReleaseCapture();
16269 wxPyEndAllowThreads(__tstate);
16270 if (PyErr_Occurred()) SWIG_fail;
16271 }
16272 {
16273 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16274 }
16275 return resultobj;
16276 fail:
16277 return NULL;
16278 }
16279
16280
16281 SWIGINTERN PyObject *Joystick_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16282 PyObject *obj;
16283 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16284 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystick, SWIG_NewClientData(obj));
16285 return SWIG_Py_Void();
16286 }
16287
16288 SWIGINTERN PyObject *Joystick_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16289 return SWIG_Python_InitShadowInstance(args);
16290 }
16291
16292 SWIGINTERN PyObject *_wrap_new_JoystickEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16293 PyObject *resultobj = 0;
16294 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16295 int arg2 = (int) 0 ;
16296 int arg3 = (int) wxJOYSTICK1 ;
16297 int arg4 = (int) 0 ;
16298 wxJoystickEvent *result = 0 ;
16299 int val1 ;
16300 int ecode1 = 0 ;
16301 int val2 ;
16302 int ecode2 = 0 ;
16303 int val3 ;
16304 int ecode3 = 0 ;
16305 int val4 ;
16306 int ecode4 = 0 ;
16307 PyObject * obj0 = 0 ;
16308 PyObject * obj1 = 0 ;
16309 PyObject * obj2 = 0 ;
16310 PyObject * obj3 = 0 ;
16311 char * kwnames[] = {
16312 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
16313 };
16314
16315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16316 if (obj0) {
16317 ecode1 = SWIG_AsVal_int(obj0, &val1);
16318 if (!SWIG_IsOK(ecode1)) {
16319 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_JoystickEvent" "', expected argument " "1"" of type '" "wxEventType""'");
16320 }
16321 arg1 = static_cast< wxEventType >(val1);
16322 }
16323 if (obj1) {
16324 ecode2 = SWIG_AsVal_int(obj1, &val2);
16325 if (!SWIG_IsOK(ecode2)) {
16326 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_JoystickEvent" "', expected argument " "2"" of type '" "int""'");
16327 }
16328 arg2 = static_cast< int >(val2);
16329 }
16330 if (obj2) {
16331 ecode3 = SWIG_AsVal_int(obj2, &val3);
16332 if (!SWIG_IsOK(ecode3)) {
16333 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_JoystickEvent" "', expected argument " "3"" of type '" "int""'");
16334 }
16335 arg3 = static_cast< int >(val3);
16336 }
16337 if (obj3) {
16338 ecode4 = SWIG_AsVal_int(obj3, &val4);
16339 if (!SWIG_IsOK(ecode4)) {
16340 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_JoystickEvent" "', expected argument " "4"" of type '" "int""'");
16341 }
16342 arg4 = static_cast< int >(val4);
16343 }
16344 {
16345 PyThreadState* __tstate = wxPyBeginAllowThreads();
16346 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
16347 wxPyEndAllowThreads(__tstate);
16348 if (PyErr_Occurred()) SWIG_fail;
16349 }
16350 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_NEW | 0 );
16351 return resultobj;
16352 fail:
16353 return NULL;
16354 }
16355
16356
16357 SWIGINTERN PyObject *_wrap_JoystickEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16358 PyObject *resultobj = 0;
16359 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16360 wxPoint result;
16361 void *argp1 = 0 ;
16362 int res1 = 0 ;
16363 PyObject *swig_obj[1] ;
16364
16365 if (!args) SWIG_fail;
16366 swig_obj[0] = args;
16367 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16368 if (!SWIG_IsOK(res1)) {
16369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16370 }
16371 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16372 {
16373 PyThreadState* __tstate = wxPyBeginAllowThreads();
16374 result = ((wxJoystickEvent const *)arg1)->GetPosition();
16375 wxPyEndAllowThreads(__tstate);
16376 if (PyErr_Occurred()) SWIG_fail;
16377 }
16378 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
16379 return resultobj;
16380 fail:
16381 return NULL;
16382 }
16383
16384
16385 SWIGINTERN PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16386 PyObject *resultobj = 0;
16387 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16388 int result;
16389 void *argp1 = 0 ;
16390 int res1 = 0 ;
16391 PyObject *swig_obj[1] ;
16392
16393 if (!args) SWIG_fail;
16394 swig_obj[0] = args;
16395 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16396 if (!SWIG_IsOK(res1)) {
16397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16398 }
16399 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16400 {
16401 PyThreadState* __tstate = wxPyBeginAllowThreads();
16402 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
16403 wxPyEndAllowThreads(__tstate);
16404 if (PyErr_Occurred()) SWIG_fail;
16405 }
16406 resultobj = SWIG_From_int(static_cast< int >(result));
16407 return resultobj;
16408 fail:
16409 return NULL;
16410 }
16411
16412
16413 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16414 PyObject *resultobj = 0;
16415 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16416 int result;
16417 void *argp1 = 0 ;
16418 int res1 = 0 ;
16419 PyObject *swig_obj[1] ;
16420
16421 if (!args) SWIG_fail;
16422 swig_obj[0] = args;
16423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16424 if (!SWIG_IsOK(res1)) {
16425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16426 }
16427 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16428 {
16429 PyThreadState* __tstate = wxPyBeginAllowThreads();
16430 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
16431 wxPyEndAllowThreads(__tstate);
16432 if (PyErr_Occurred()) SWIG_fail;
16433 }
16434 resultobj = SWIG_From_int(static_cast< int >(result));
16435 return resultobj;
16436 fail:
16437 return NULL;
16438 }
16439
16440
16441 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16442 PyObject *resultobj = 0;
16443 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16444 int result;
16445 void *argp1 = 0 ;
16446 int res1 = 0 ;
16447 PyObject *swig_obj[1] ;
16448
16449 if (!args) SWIG_fail;
16450 swig_obj[0] = args;
16451 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16452 if (!SWIG_IsOK(res1)) {
16453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16454 }
16455 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16456 {
16457 PyThreadState* __tstate = wxPyBeginAllowThreads();
16458 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
16459 wxPyEndAllowThreads(__tstate);
16460 if (PyErr_Occurred()) SWIG_fail;
16461 }
16462 resultobj = SWIG_From_int(static_cast< int >(result));
16463 return resultobj;
16464 fail:
16465 return NULL;
16466 }
16467
16468
16469 SWIGINTERN PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16470 PyObject *resultobj = 0;
16471 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16472 int result;
16473 void *argp1 = 0 ;
16474 int res1 = 0 ;
16475 PyObject *swig_obj[1] ;
16476
16477 if (!args) SWIG_fail;
16478 swig_obj[0] = args;
16479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16480 if (!SWIG_IsOK(res1)) {
16481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16482 }
16483 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16484 {
16485 PyThreadState* __tstate = wxPyBeginAllowThreads();
16486 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
16487 wxPyEndAllowThreads(__tstate);
16488 if (PyErr_Occurred()) SWIG_fail;
16489 }
16490 resultobj = SWIG_From_int(static_cast< int >(result));
16491 return resultobj;
16492 fail:
16493 return NULL;
16494 }
16495
16496
16497 SWIGINTERN PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16498 PyObject *resultobj = 0;
16499 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16500 int arg2 ;
16501 void *argp1 = 0 ;
16502 int res1 = 0 ;
16503 int val2 ;
16504 int ecode2 = 0 ;
16505 PyObject * obj0 = 0 ;
16506 PyObject * obj1 = 0 ;
16507 char * kwnames[] = {
16508 (char *) "self",(char *) "stick", NULL
16509 };
16510
16511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) SWIG_fail;
16512 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16513 if (!SWIG_IsOK(res1)) {
16514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16515 }
16516 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16517 ecode2 = SWIG_AsVal_int(obj1, &val2);
16518 if (!SWIG_IsOK(ecode2)) {
16519 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "2"" of type '" "int""'");
16520 }
16521 arg2 = static_cast< int >(val2);
16522 {
16523 PyThreadState* __tstate = wxPyBeginAllowThreads();
16524 (arg1)->SetJoystick(arg2);
16525 wxPyEndAllowThreads(__tstate);
16526 if (PyErr_Occurred()) SWIG_fail;
16527 }
16528 resultobj = SWIG_Py_Void();
16529 return resultobj;
16530 fail:
16531 return NULL;
16532 }
16533
16534
16535 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16536 PyObject *resultobj = 0;
16537 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16538 int arg2 ;
16539 void *argp1 = 0 ;
16540 int res1 = 0 ;
16541 int val2 ;
16542 int ecode2 = 0 ;
16543 PyObject * obj0 = 0 ;
16544 PyObject * obj1 = 0 ;
16545 char * kwnames[] = {
16546 (char *) "self",(char *) "state", NULL
16547 };
16548
16549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) SWIG_fail;
16550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16551 if (!SWIG_IsOK(res1)) {
16552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16553 }
16554 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16555 ecode2 = SWIG_AsVal_int(obj1, &val2);
16556 if (!SWIG_IsOK(ecode2)) {
16557 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "2"" of type '" "int""'");
16558 }
16559 arg2 = static_cast< int >(val2);
16560 {
16561 PyThreadState* __tstate = wxPyBeginAllowThreads();
16562 (arg1)->SetButtonState(arg2);
16563 wxPyEndAllowThreads(__tstate);
16564 if (PyErr_Occurred()) SWIG_fail;
16565 }
16566 resultobj = SWIG_Py_Void();
16567 return resultobj;
16568 fail:
16569 return NULL;
16570 }
16571
16572
16573 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16574 PyObject *resultobj = 0;
16575 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16576 int arg2 ;
16577 void *argp1 = 0 ;
16578 int res1 = 0 ;
16579 int val2 ;
16580 int ecode2 = 0 ;
16581 PyObject * obj0 = 0 ;
16582 PyObject * obj1 = 0 ;
16583 char * kwnames[] = {
16584 (char *) "self",(char *) "change", NULL
16585 };
16586
16587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) SWIG_fail;
16588 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16589 if (!SWIG_IsOK(res1)) {
16590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16591 }
16592 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16593 ecode2 = SWIG_AsVal_int(obj1, &val2);
16594 if (!SWIG_IsOK(ecode2)) {
16595 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "2"" of type '" "int""'");
16596 }
16597 arg2 = static_cast< int >(val2);
16598 {
16599 PyThreadState* __tstate = wxPyBeginAllowThreads();
16600 (arg1)->SetButtonChange(arg2);
16601 wxPyEndAllowThreads(__tstate);
16602 if (PyErr_Occurred()) SWIG_fail;
16603 }
16604 resultobj = SWIG_Py_Void();
16605 return resultobj;
16606 fail:
16607 return NULL;
16608 }
16609
16610
16611 SWIGINTERN PyObject *_wrap_JoystickEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16612 PyObject *resultobj = 0;
16613 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16614 wxPoint *arg2 = 0 ;
16615 void *argp1 = 0 ;
16616 int res1 = 0 ;
16617 wxPoint temp2 ;
16618 PyObject * obj0 = 0 ;
16619 PyObject * obj1 = 0 ;
16620 char * kwnames[] = {
16621 (char *) "self",(char *) "pos", NULL
16622 };
16623
16624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
16625 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16626 if (!SWIG_IsOK(res1)) {
16627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16628 }
16629 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16630 {
16631 arg2 = &temp2;
16632 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
16633 }
16634 {
16635 PyThreadState* __tstate = wxPyBeginAllowThreads();
16636 (arg1)->SetPosition((wxPoint const &)*arg2);
16637 wxPyEndAllowThreads(__tstate);
16638 if (PyErr_Occurred()) SWIG_fail;
16639 }
16640 resultobj = SWIG_Py_Void();
16641 return resultobj;
16642 fail:
16643 return NULL;
16644 }
16645
16646
16647 SWIGINTERN PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16648 PyObject *resultobj = 0;
16649 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16650 int arg2 ;
16651 void *argp1 = 0 ;
16652 int res1 = 0 ;
16653 int val2 ;
16654 int ecode2 = 0 ;
16655 PyObject * obj0 = 0 ;
16656 PyObject * obj1 = 0 ;
16657 char * kwnames[] = {
16658 (char *) "self",(char *) "zPos", NULL
16659 };
16660
16661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) SWIG_fail;
16662 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16663 if (!SWIG_IsOK(res1)) {
16664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16665 }
16666 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16667 ecode2 = SWIG_AsVal_int(obj1, &val2);
16668 if (!SWIG_IsOK(ecode2)) {
16669 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "2"" of type '" "int""'");
16670 }
16671 arg2 = static_cast< int >(val2);
16672 {
16673 PyThreadState* __tstate = wxPyBeginAllowThreads();
16674 (arg1)->SetZPosition(arg2);
16675 wxPyEndAllowThreads(__tstate);
16676 if (PyErr_Occurred()) SWIG_fail;
16677 }
16678 resultobj = SWIG_Py_Void();
16679 return resultobj;
16680 fail:
16681 return NULL;
16682 }
16683
16684
16685 SWIGINTERN PyObject *_wrap_JoystickEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16686 PyObject *resultobj = 0;
16687 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16688 bool result;
16689 void *argp1 = 0 ;
16690 int res1 = 0 ;
16691 PyObject *swig_obj[1] ;
16692
16693 if (!args) SWIG_fail;
16694 swig_obj[0] = args;
16695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16696 if (!SWIG_IsOK(res1)) {
16697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsButton" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16698 }
16699 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16700 {
16701 PyThreadState* __tstate = wxPyBeginAllowThreads();
16702 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
16703 wxPyEndAllowThreads(__tstate);
16704 if (PyErr_Occurred()) SWIG_fail;
16705 }
16706 {
16707 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16708 }
16709 return resultobj;
16710 fail:
16711 return NULL;
16712 }
16713
16714
16715 SWIGINTERN PyObject *_wrap_JoystickEvent_IsMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16716 PyObject *resultobj = 0;
16717 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16718 bool result;
16719 void *argp1 = 0 ;
16720 int res1 = 0 ;
16721 PyObject *swig_obj[1] ;
16722
16723 if (!args) SWIG_fail;
16724 swig_obj[0] = args;
16725 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16726 if (!SWIG_IsOK(res1)) {
16727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16728 }
16729 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16730 {
16731 PyThreadState* __tstate = wxPyBeginAllowThreads();
16732 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
16733 wxPyEndAllowThreads(__tstate);
16734 if (PyErr_Occurred()) SWIG_fail;
16735 }
16736 {
16737 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16738 }
16739 return resultobj;
16740 fail:
16741 return NULL;
16742 }
16743
16744
16745 SWIGINTERN PyObject *_wrap_JoystickEvent_IsZMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16746 PyObject *resultobj = 0;
16747 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16748 bool result;
16749 void *argp1 = 0 ;
16750 int res1 = 0 ;
16751 PyObject *swig_obj[1] ;
16752
16753 if (!args) SWIG_fail;
16754 swig_obj[0] = args;
16755 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16756 if (!SWIG_IsOK(res1)) {
16757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsZMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16758 }
16759 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16760 {
16761 PyThreadState* __tstate = wxPyBeginAllowThreads();
16762 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
16763 wxPyEndAllowThreads(__tstate);
16764 if (PyErr_Occurred()) SWIG_fail;
16765 }
16766 {
16767 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16768 }
16769 return resultobj;
16770 fail:
16771 return NULL;
16772 }
16773
16774
16775 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16776 PyObject *resultobj = 0;
16777 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16778 int arg2 = (int) wxJOY_BUTTON_ANY ;
16779 bool result;
16780 void *argp1 = 0 ;
16781 int res1 = 0 ;
16782 int val2 ;
16783 int ecode2 = 0 ;
16784 PyObject * obj0 = 0 ;
16785 PyObject * obj1 = 0 ;
16786 char * kwnames[] = {
16787 (char *) "self",(char *) "but", NULL
16788 };
16789
16790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
16791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16792 if (!SWIG_IsOK(res1)) {
16793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16794 }
16795 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16796 if (obj1) {
16797 ecode2 = SWIG_AsVal_int(obj1, &val2);
16798 if (!SWIG_IsOK(ecode2)) {
16799 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
16800 }
16801 arg2 = static_cast< int >(val2);
16802 }
16803 {
16804 PyThreadState* __tstate = wxPyBeginAllowThreads();
16805 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
16806 wxPyEndAllowThreads(__tstate);
16807 if (PyErr_Occurred()) SWIG_fail;
16808 }
16809 {
16810 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16811 }
16812 return resultobj;
16813 fail:
16814 return NULL;
16815 }
16816
16817
16818 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16819 PyObject *resultobj = 0;
16820 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16821 int arg2 = (int) wxJOY_BUTTON_ANY ;
16822 bool result;
16823 void *argp1 = 0 ;
16824 int res1 = 0 ;
16825 int val2 ;
16826 int ecode2 = 0 ;
16827 PyObject * obj0 = 0 ;
16828 PyObject * obj1 = 0 ;
16829 char * kwnames[] = {
16830 (char *) "self",(char *) "but", NULL
16831 };
16832
16833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
16834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16835 if (!SWIG_IsOK(res1)) {
16836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16837 }
16838 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16839 if (obj1) {
16840 ecode2 = SWIG_AsVal_int(obj1, &val2);
16841 if (!SWIG_IsOK(ecode2)) {
16842 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
16843 }
16844 arg2 = static_cast< int >(val2);
16845 }
16846 {
16847 PyThreadState* __tstate = wxPyBeginAllowThreads();
16848 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
16849 wxPyEndAllowThreads(__tstate);
16850 if (PyErr_Occurred()) SWIG_fail;
16851 }
16852 {
16853 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16854 }
16855 return resultobj;
16856 fail:
16857 return NULL;
16858 }
16859
16860
16861 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16862 PyObject *resultobj = 0;
16863 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16864 int arg2 = (int) wxJOY_BUTTON_ANY ;
16865 bool result;
16866 void *argp1 = 0 ;
16867 int res1 = 0 ;
16868 int val2 ;
16869 int ecode2 = 0 ;
16870 PyObject * obj0 = 0 ;
16871 PyObject * obj1 = 0 ;
16872 char * kwnames[] = {
16873 (char *) "self",(char *) "but", NULL
16874 };
16875
16876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
16877 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16878 if (!SWIG_IsOK(res1)) {
16879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16880 }
16881 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16882 if (obj1) {
16883 ecode2 = SWIG_AsVal_int(obj1, &val2);
16884 if (!SWIG_IsOK(ecode2)) {
16885 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
16886 }
16887 arg2 = static_cast< int >(val2);
16888 }
16889 {
16890 PyThreadState* __tstate = wxPyBeginAllowThreads();
16891 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
16892 wxPyEndAllowThreads(__tstate);
16893 if (PyErr_Occurred()) SWIG_fail;
16894 }
16895 {
16896 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16897 }
16898 return resultobj;
16899 fail:
16900 return NULL;
16901 }
16902
16903
16904 SWIGINTERN PyObject *JoystickEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16905 PyObject *obj;
16906 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16907 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystickEvent, SWIG_NewClientData(obj));
16908 return SWIG_Py_Void();
16909 }
16910
16911 SWIGINTERN PyObject *JoystickEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16912 return SWIG_Python_InitShadowInstance(args);
16913 }
16914
16915 SWIGINTERN PyObject *_wrap_new_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16916 PyObject *resultobj = 0;
16917 wxString const &arg1_defvalue = wxPyEmptyString ;
16918 wxString *arg1 = (wxString *) &arg1_defvalue ;
16919 wxSound *result = 0 ;
16920 bool temp1 = false ;
16921 PyObject * obj0 = 0 ;
16922 char * kwnames[] = {
16923 (char *) "fileName", NULL
16924 };
16925
16926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) SWIG_fail;
16927 if (obj0) {
16928 {
16929 arg1 = wxString_in_helper(obj0);
16930 if (arg1 == NULL) SWIG_fail;
16931 temp1 = true;
16932 }
16933 }
16934 {
16935 if (!wxPyCheckForApp()) SWIG_fail;
16936 PyThreadState* __tstate = wxPyBeginAllowThreads();
16937 result = (wxSound *)new_wxSound((wxString const &)*arg1);
16938 wxPyEndAllowThreads(__tstate);
16939 if (PyErr_Occurred()) SWIG_fail;
16940 }
16941 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_NEW | 0 );
16942 {
16943 if (temp1)
16944 delete arg1;
16945 }
16946 return resultobj;
16947 fail:
16948 {
16949 if (temp1)
16950 delete arg1;
16951 }
16952 return NULL;
16953 }
16954
16955
16956 SWIGINTERN PyObject *_wrap_new_SoundFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16957 PyObject *resultobj = 0;
16958 PyObject *arg1 = (PyObject *) 0 ;
16959 wxSound *result = 0 ;
16960 PyObject * obj0 = 0 ;
16961 char * kwnames[] = {
16962 (char *) "data", NULL
16963 };
16964
16965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) SWIG_fail;
16966 arg1 = obj0;
16967 {
16968 if (!wxPyCheckForApp()) SWIG_fail;
16969 PyThreadState* __tstate = wxPyBeginAllowThreads();
16970 result = (wxSound *)new_wxSound(arg1);
16971 wxPyEndAllowThreads(__tstate);
16972 if (PyErr_Occurred()) SWIG_fail;
16973 }
16974 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_OWN | 0 );
16975 return resultobj;
16976 fail:
16977 return NULL;
16978 }
16979
16980
16981 SWIGINTERN PyObject *_wrap_delete_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16982 PyObject *resultobj = 0;
16983 wxSound *arg1 = (wxSound *) 0 ;
16984 void *argp1 = 0 ;
16985 int res1 = 0 ;
16986 PyObject *swig_obj[1] ;
16987
16988 if (!args) SWIG_fail;
16989 swig_obj[0] = args;
16990 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, SWIG_POINTER_DISOWN | 0 );
16991 if (!SWIG_IsOK(res1)) {
16992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sound" "', expected argument " "1"" of type '" "wxSound *""'");
16993 }
16994 arg1 = reinterpret_cast< wxSound * >(argp1);
16995 {
16996 PyThreadState* __tstate = wxPyBeginAllowThreads();
16997 delete arg1;
16998
16999 wxPyEndAllowThreads(__tstate);
17000 if (PyErr_Occurred()) SWIG_fail;
17001 }
17002 resultobj = SWIG_Py_Void();
17003 return resultobj;
17004 fail:
17005 return NULL;
17006 }
17007
17008
17009 SWIGINTERN PyObject *_wrap_Sound_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17010 PyObject *resultobj = 0;
17011 wxSound *arg1 = (wxSound *) 0 ;
17012 wxString *arg2 = 0 ;
17013 bool result;
17014 void *argp1 = 0 ;
17015 int res1 = 0 ;
17016 bool temp2 = false ;
17017 PyObject * obj0 = 0 ;
17018 PyObject * obj1 = 0 ;
17019 char * kwnames[] = {
17020 (char *) "self",(char *) "fileName", NULL
17021 };
17022
17023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) SWIG_fail;
17024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17025 if (!SWIG_IsOK(res1)) {
17026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Create" "', expected argument " "1"" of type '" "wxSound *""'");
17027 }
17028 arg1 = reinterpret_cast< wxSound * >(argp1);
17029 {
17030 arg2 = wxString_in_helper(obj1);
17031 if (arg2 == NULL) SWIG_fail;
17032 temp2 = true;
17033 }
17034 {
17035 PyThreadState* __tstate = wxPyBeginAllowThreads();
17036 result = (bool)(arg1)->Create((wxString const &)*arg2);
17037 wxPyEndAllowThreads(__tstate);
17038 if (PyErr_Occurred()) SWIG_fail;
17039 }
17040 {
17041 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17042 }
17043 {
17044 if (temp2)
17045 delete arg2;
17046 }
17047 return resultobj;
17048 fail:
17049 {
17050 if (temp2)
17051 delete arg2;
17052 }
17053 return NULL;
17054 }
17055
17056
17057 SWIGINTERN PyObject *_wrap_Sound_CreateFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17058 PyObject *resultobj = 0;
17059 wxSound *arg1 = (wxSound *) 0 ;
17060 PyObject *arg2 = (PyObject *) 0 ;
17061 bool result;
17062 void *argp1 = 0 ;
17063 int res1 = 0 ;
17064 PyObject * obj0 = 0 ;
17065 PyObject * obj1 = 0 ;
17066 char * kwnames[] = {
17067 (char *) "self",(char *) "data", NULL
17068 };
17069
17070 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) SWIG_fail;
17071 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17072 if (!SWIG_IsOK(res1)) {
17073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_CreateFromData" "', expected argument " "1"" of type '" "wxSound *""'");
17074 }
17075 arg1 = reinterpret_cast< wxSound * >(argp1);
17076 arg2 = obj1;
17077 {
17078 PyThreadState* __tstate = wxPyBeginAllowThreads();
17079 result = (bool)wxSound_CreateFromData(arg1,arg2);
17080 wxPyEndAllowThreads(__tstate);
17081 if (PyErr_Occurred()) SWIG_fail;
17082 }
17083 {
17084 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17085 }
17086 return resultobj;
17087 fail:
17088 return NULL;
17089 }
17090
17091
17092 SWIGINTERN PyObject *_wrap_Sound_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17093 PyObject *resultobj = 0;
17094 wxSound *arg1 = (wxSound *) 0 ;
17095 bool result;
17096 void *argp1 = 0 ;
17097 int res1 = 0 ;
17098 PyObject *swig_obj[1] ;
17099
17100 if (!args) SWIG_fail;
17101 swig_obj[0] = args;
17102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17103 if (!SWIG_IsOK(res1)) {
17104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_IsOk" "', expected argument " "1"" of type '" "wxSound *""'");
17105 }
17106 arg1 = reinterpret_cast< wxSound * >(argp1);
17107 {
17108 PyThreadState* __tstate = wxPyBeginAllowThreads();
17109 result = (bool)(arg1)->IsOk();
17110 wxPyEndAllowThreads(__tstate);
17111 if (PyErr_Occurred()) SWIG_fail;
17112 }
17113 {
17114 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17115 }
17116 return resultobj;
17117 fail:
17118 return NULL;
17119 }
17120
17121
17122 SWIGINTERN PyObject *_wrap_Sound_Play(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17123 PyObject *resultobj = 0;
17124 wxSound *arg1 = (wxSound *) 0 ;
17125 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
17126 bool result;
17127 void *argp1 = 0 ;
17128 int res1 = 0 ;
17129 unsigned int val2 ;
17130 int ecode2 = 0 ;
17131 PyObject * obj0 = 0 ;
17132 PyObject * obj1 = 0 ;
17133 char * kwnames[] = {
17134 (char *) "self",(char *) "flags", NULL
17135 };
17136
17137 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) SWIG_fail;
17138 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17139 if (!SWIG_IsOK(res1)) {
17140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Play" "', expected argument " "1"" of type '" "wxSound const *""'");
17141 }
17142 arg1 = reinterpret_cast< wxSound * >(argp1);
17143 if (obj1) {
17144 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
17145 if (!SWIG_IsOK(ecode2)) {
17146 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_Play" "', expected argument " "2"" of type '" "unsigned int""'");
17147 }
17148 arg2 = static_cast< unsigned int >(val2);
17149 }
17150 {
17151 if (!wxPyCheckForApp()) SWIG_fail;
17152 PyThreadState* __tstate = wxPyBeginAllowThreads();
17153 result = (bool)((wxSound const *)arg1)->Play(arg2);
17154 wxPyEndAllowThreads(__tstate);
17155 if (PyErr_Occurred()) SWIG_fail;
17156 }
17157 {
17158 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17159 }
17160 return resultobj;
17161 fail:
17162 return NULL;
17163 }
17164
17165
17166 SWIGINTERN PyObject *_wrap_Sound_PlaySound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17167 PyObject *resultobj = 0;
17168 wxString *arg1 = 0 ;
17169 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
17170 bool result;
17171 bool temp1 = false ;
17172 unsigned int val2 ;
17173 int ecode2 = 0 ;
17174 PyObject * obj0 = 0 ;
17175 PyObject * obj1 = 0 ;
17176 char * kwnames[] = {
17177 (char *) "filename",(char *) "flags", NULL
17178 };
17179
17180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) SWIG_fail;
17181 {
17182 arg1 = wxString_in_helper(obj0);
17183 if (arg1 == NULL) SWIG_fail;
17184 temp1 = true;
17185 }
17186 if (obj1) {
17187 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
17188 if (!SWIG_IsOK(ecode2)) {
17189 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_PlaySound" "', expected argument " "2"" of type '" "unsigned int""'");
17190 }
17191 arg2 = static_cast< unsigned int >(val2);
17192 }
17193 {
17194 if (!wxPyCheckForApp()) SWIG_fail;
17195 PyThreadState* __tstate = wxPyBeginAllowThreads();
17196 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
17197 wxPyEndAllowThreads(__tstate);
17198 if (PyErr_Occurred()) SWIG_fail;
17199 }
17200 {
17201 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17202 }
17203 {
17204 if (temp1)
17205 delete arg1;
17206 }
17207 return resultobj;
17208 fail:
17209 {
17210 if (temp1)
17211 delete arg1;
17212 }
17213 return NULL;
17214 }
17215
17216
17217 SWIGINTERN PyObject *_wrap_Sound_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17218 PyObject *resultobj = 0;
17219
17220 if (!SWIG_Python_UnpackTuple(args,"Sound_Stop",0,0,0)) SWIG_fail;
17221 {
17222 if (!wxPyCheckForApp()) SWIG_fail;
17223 PyThreadState* __tstate = wxPyBeginAllowThreads();
17224 wxSound::Stop();
17225 wxPyEndAllowThreads(__tstate);
17226 if (PyErr_Occurred()) SWIG_fail;
17227 }
17228 resultobj = SWIG_Py_Void();
17229 return resultobj;
17230 fail:
17231 return NULL;
17232 }
17233
17234
17235 SWIGINTERN PyObject *Sound_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17236 PyObject *obj;
17237 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17238 SWIG_TypeNewClientData(SWIGTYPE_p_wxSound, SWIG_NewClientData(obj));
17239 return SWIG_Py_Void();
17240 }
17241
17242 SWIGINTERN PyObject *Sound_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17243 return SWIG_Python_InitShadowInstance(args);
17244 }
17245
17246 SWIGINTERN PyObject *_wrap_new_FileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17247 PyObject *resultobj = 0;
17248 wxString *arg1 = 0 ;
17249 wxString *arg2 = 0 ;
17250 wxString *arg3 = 0 ;
17251 wxString *arg4 = 0 ;
17252 wxFileTypeInfo *result = 0 ;
17253 bool temp1 = false ;
17254 bool temp2 = false ;
17255 bool temp3 = false ;
17256 bool temp4 = false ;
17257 PyObject * obj0 = 0 ;
17258 PyObject * obj1 = 0 ;
17259 PyObject * obj2 = 0 ;
17260 PyObject * obj3 = 0 ;
17261 char * kwnames[] = {
17262 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
17263 };
17264
17265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17266 {
17267 arg1 = wxString_in_helper(obj0);
17268 if (arg1 == NULL) SWIG_fail;
17269 temp1 = true;
17270 }
17271 {
17272 arg2 = wxString_in_helper(obj1);
17273 if (arg2 == NULL) SWIG_fail;
17274 temp2 = true;
17275 }
17276 {
17277 arg3 = wxString_in_helper(obj2);
17278 if (arg3 == NULL) SWIG_fail;
17279 temp3 = true;
17280 }
17281 {
17282 arg4 = wxString_in_helper(obj3);
17283 if (arg4 == NULL) SWIG_fail;
17284 temp4 = true;
17285 }
17286 {
17287 PyThreadState* __tstate = wxPyBeginAllowThreads();
17288 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
17289 wxPyEndAllowThreads(__tstate);
17290 if (PyErr_Occurred()) SWIG_fail;
17291 }
17292 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_NEW | 0 );
17293 {
17294 if (temp1)
17295 delete arg1;
17296 }
17297 {
17298 if (temp2)
17299 delete arg2;
17300 }
17301 {
17302 if (temp3)
17303 delete arg3;
17304 }
17305 {
17306 if (temp4)
17307 delete arg4;
17308 }
17309 return resultobj;
17310 fail:
17311 {
17312 if (temp1)
17313 delete arg1;
17314 }
17315 {
17316 if (temp2)
17317 delete arg2;
17318 }
17319 {
17320 if (temp3)
17321 delete arg3;
17322 }
17323 {
17324 if (temp4)
17325 delete arg4;
17326 }
17327 return NULL;
17328 }
17329
17330
17331 SWIGINTERN PyObject *_wrap_new_FileTypeInfoSequence(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17332 PyObject *resultobj = 0;
17333 wxArrayString *arg1 = 0 ;
17334 wxFileTypeInfo *result = 0 ;
17335 bool temp1 = false ;
17336 PyObject * obj0 = 0 ;
17337 char * kwnames[] = {
17338 (char *) "sArray", NULL
17339 };
17340
17341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) SWIG_fail;
17342 {
17343 if (! PySequence_Check(obj0)) {
17344 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
17345 SWIG_fail;
17346 }
17347 arg1 = new wxArrayString;
17348 temp1 = true;
17349 int i, len=PySequence_Length(obj0);
17350 for (i=0; i<len; i++) {
17351 PyObject* item = PySequence_GetItem(obj0, i);
17352 wxString* s = wxString_in_helper(item);
17353 if (PyErr_Occurred()) SWIG_fail;
17354 arg1->Add(*s);
17355 delete s;
17356 Py_DECREF(item);
17357 }
17358 }
17359 {
17360 PyThreadState* __tstate = wxPyBeginAllowThreads();
17361 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
17362 wxPyEndAllowThreads(__tstate);
17363 if (PyErr_Occurred()) SWIG_fail;
17364 }
17365 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
17366 {
17367 if (temp1) delete arg1;
17368 }
17369 return resultobj;
17370 fail:
17371 {
17372 if (temp1) delete arg1;
17373 }
17374 return NULL;
17375 }
17376
17377
17378 SWIGINTERN PyObject *_wrap_new_NullFileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17379 PyObject *resultobj = 0;
17380 wxFileTypeInfo *result = 0 ;
17381
17382 if (!SWIG_Python_UnpackTuple(args,"new_NullFileTypeInfo",0,0,0)) SWIG_fail;
17383 {
17384 PyThreadState* __tstate = wxPyBeginAllowThreads();
17385 result = (wxFileTypeInfo *)new wxFileTypeInfo();
17386 wxPyEndAllowThreads(__tstate);
17387 if (PyErr_Occurred()) SWIG_fail;
17388 }
17389 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
17390 return resultobj;
17391 fail:
17392 return NULL;
17393 }
17394
17395
17396 SWIGINTERN PyObject *_wrap_FileTypeInfo_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17397 PyObject *resultobj = 0;
17398 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17399 bool result;
17400 void *argp1 = 0 ;
17401 int res1 = 0 ;
17402 PyObject *swig_obj[1] ;
17403
17404 if (!args) SWIG_fail;
17405 swig_obj[0] = args;
17406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17407 if (!SWIG_IsOK(res1)) {
17408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_IsValid" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17409 }
17410 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17411 {
17412 PyThreadState* __tstate = wxPyBeginAllowThreads();
17413 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
17414 wxPyEndAllowThreads(__tstate);
17415 if (PyErr_Occurred()) SWIG_fail;
17416 }
17417 {
17418 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17419 }
17420 return resultobj;
17421 fail:
17422 return NULL;
17423 }
17424
17425
17426 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17427 PyObject *resultobj = 0;
17428 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17429 wxString *arg2 = 0 ;
17430 int arg3 = (int) 0 ;
17431 void *argp1 = 0 ;
17432 int res1 = 0 ;
17433 bool temp2 = false ;
17434 int val3 ;
17435 int ecode3 = 0 ;
17436 PyObject * obj0 = 0 ;
17437 PyObject * obj1 = 0 ;
17438 PyObject * obj2 = 0 ;
17439 char * kwnames[] = {
17440 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
17441 };
17442
17443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17444 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17445 if (!SWIG_IsOK(res1)) {
17446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
17447 }
17448 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17449 {
17450 arg2 = wxString_in_helper(obj1);
17451 if (arg2 == NULL) SWIG_fail;
17452 temp2 = true;
17453 }
17454 if (obj2) {
17455 ecode3 = SWIG_AsVal_int(obj2, &val3);
17456 if (!SWIG_IsOK(ecode3)) {
17457 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "3"" of type '" "int""'");
17458 }
17459 arg3 = static_cast< int >(val3);
17460 }
17461 {
17462 PyThreadState* __tstate = wxPyBeginAllowThreads();
17463 (arg1)->SetIcon((wxString const &)*arg2,arg3);
17464 wxPyEndAllowThreads(__tstate);
17465 if (PyErr_Occurred()) SWIG_fail;
17466 }
17467 resultobj = SWIG_Py_Void();
17468 {
17469 if (temp2)
17470 delete arg2;
17471 }
17472 return resultobj;
17473 fail:
17474 {
17475 if (temp2)
17476 delete arg2;
17477 }
17478 return NULL;
17479 }
17480
17481
17482 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17483 PyObject *resultobj = 0;
17484 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17485 wxString *arg2 = 0 ;
17486 void *argp1 = 0 ;
17487 int res1 = 0 ;
17488 bool temp2 = false ;
17489 PyObject * obj0 = 0 ;
17490 PyObject * obj1 = 0 ;
17491 char * kwnames[] = {
17492 (char *) "self",(char *) "shortDesc", NULL
17493 };
17494
17495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) SWIG_fail;
17496 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17497 if (!SWIG_IsOK(res1)) {
17498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
17499 }
17500 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17501 {
17502 arg2 = wxString_in_helper(obj1);
17503 if (arg2 == NULL) SWIG_fail;
17504 temp2 = true;
17505 }
17506 {
17507 PyThreadState* __tstate = wxPyBeginAllowThreads();
17508 (arg1)->SetShortDesc((wxString const &)*arg2);
17509 wxPyEndAllowThreads(__tstate);
17510 if (PyErr_Occurred()) SWIG_fail;
17511 }
17512 resultobj = SWIG_Py_Void();
17513 {
17514 if (temp2)
17515 delete arg2;
17516 }
17517 return resultobj;
17518 fail:
17519 {
17520 if (temp2)
17521 delete arg2;
17522 }
17523 return NULL;
17524 }
17525
17526
17527 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17528 PyObject *resultobj = 0;
17529 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17530 wxString *result = 0 ;
17531 void *argp1 = 0 ;
17532 int res1 = 0 ;
17533 PyObject *swig_obj[1] ;
17534
17535 if (!args) SWIG_fail;
17536 swig_obj[0] = args;
17537 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17538 if (!SWIG_IsOK(res1)) {
17539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetMimeType" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17540 }
17541 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17542 {
17543 PyThreadState* __tstate = wxPyBeginAllowThreads();
17544 {
17545 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
17546 result = (wxString *) &_result_ref;
17547 }
17548 wxPyEndAllowThreads(__tstate);
17549 if (PyErr_Occurred()) SWIG_fail;
17550 }
17551 {
17552 #if wxUSE_UNICODE
17553 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17554 #else
17555 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17556 #endif
17557 }
17558 return resultobj;
17559 fail:
17560 return NULL;
17561 }
17562
17563
17564 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17565 PyObject *resultobj = 0;
17566 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17567 wxString *result = 0 ;
17568 void *argp1 = 0 ;
17569 int res1 = 0 ;
17570 PyObject *swig_obj[1] ;
17571
17572 if (!args) SWIG_fail;
17573 swig_obj[0] = args;
17574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17575 if (!SWIG_IsOK(res1)) {
17576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17577 }
17578 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17579 {
17580 PyThreadState* __tstate = wxPyBeginAllowThreads();
17581 {
17582 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
17583 result = (wxString *) &_result_ref;
17584 }
17585 wxPyEndAllowThreads(__tstate);
17586 if (PyErr_Occurred()) SWIG_fail;
17587 }
17588 {
17589 #if wxUSE_UNICODE
17590 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17591 #else
17592 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17593 #endif
17594 }
17595 return resultobj;
17596 fail:
17597 return NULL;
17598 }
17599
17600
17601 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17602 PyObject *resultobj = 0;
17603 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17604 wxString *result = 0 ;
17605 void *argp1 = 0 ;
17606 int res1 = 0 ;
17607 PyObject *swig_obj[1] ;
17608
17609 if (!args) SWIG_fail;
17610 swig_obj[0] = args;
17611 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17612 if (!SWIG_IsOK(res1)) {
17613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17614 }
17615 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17616 {
17617 PyThreadState* __tstate = wxPyBeginAllowThreads();
17618 {
17619 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
17620 result = (wxString *) &_result_ref;
17621 }
17622 wxPyEndAllowThreads(__tstate);
17623 if (PyErr_Occurred()) SWIG_fail;
17624 }
17625 {
17626 #if wxUSE_UNICODE
17627 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17628 #else
17629 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17630 #endif
17631 }
17632 return resultobj;
17633 fail:
17634 return NULL;
17635 }
17636
17637
17638 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17639 PyObject *resultobj = 0;
17640 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17641 wxString *result = 0 ;
17642 void *argp1 = 0 ;
17643 int res1 = 0 ;
17644 PyObject *swig_obj[1] ;
17645
17646 if (!args) SWIG_fail;
17647 swig_obj[0] = args;
17648 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17649 if (!SWIG_IsOK(res1)) {
17650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17651 }
17652 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17653 {
17654 PyThreadState* __tstate = wxPyBeginAllowThreads();
17655 {
17656 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
17657 result = (wxString *) &_result_ref;
17658 }
17659 wxPyEndAllowThreads(__tstate);
17660 if (PyErr_Occurred()) SWIG_fail;
17661 }
17662 {
17663 #if wxUSE_UNICODE
17664 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17665 #else
17666 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17667 #endif
17668 }
17669 return resultobj;
17670 fail:
17671 return NULL;
17672 }
17673
17674
17675 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17676 PyObject *resultobj = 0;
17677 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17678 wxString *result = 0 ;
17679 void *argp1 = 0 ;
17680 int res1 = 0 ;
17681 PyObject *swig_obj[1] ;
17682
17683 if (!args) SWIG_fail;
17684 swig_obj[0] = args;
17685 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17686 if (!SWIG_IsOK(res1)) {
17687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetDescription" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17688 }
17689 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17690 {
17691 PyThreadState* __tstate = wxPyBeginAllowThreads();
17692 {
17693 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
17694 result = (wxString *) &_result_ref;
17695 }
17696 wxPyEndAllowThreads(__tstate);
17697 if (PyErr_Occurred()) SWIG_fail;
17698 }
17699 {
17700 #if wxUSE_UNICODE
17701 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17702 #else
17703 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17704 #endif
17705 }
17706 return resultobj;
17707 fail:
17708 return NULL;
17709 }
17710
17711
17712 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17713 PyObject *resultobj = 0;
17714 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17715 wxArrayString *result = 0 ;
17716 void *argp1 = 0 ;
17717 int res1 = 0 ;
17718 PyObject *swig_obj[1] ;
17719
17720 if (!args) SWIG_fail;
17721 swig_obj[0] = args;
17722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17723 if (!SWIG_IsOK(res1)) {
17724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensions" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17725 }
17726 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17727 {
17728 PyThreadState* __tstate = wxPyBeginAllowThreads();
17729 {
17730 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
17731 result = (wxArrayString *) &_result_ref;
17732 }
17733 wxPyEndAllowThreads(__tstate);
17734 if (PyErr_Occurred()) SWIG_fail;
17735 }
17736 {
17737 resultobj = wxArrayString2PyList_helper(*result);
17738 }
17739 return resultobj;
17740 fail:
17741 return NULL;
17742 }
17743
17744
17745 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17746 PyObject *resultobj = 0;
17747 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17748 size_t result;
17749 void *argp1 = 0 ;
17750 int res1 = 0 ;
17751 PyObject *swig_obj[1] ;
17752
17753 if (!args) SWIG_fail;
17754 swig_obj[0] = args;
17755 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17756 if (!SWIG_IsOK(res1)) {
17757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensionsCount" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17758 }
17759 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17760 {
17761 PyThreadState* __tstate = wxPyBeginAllowThreads();
17762 result = (size_t)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
17763 wxPyEndAllowThreads(__tstate);
17764 if (PyErr_Occurred()) SWIG_fail;
17765 }
17766 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
17767 return resultobj;
17768 fail:
17769 return NULL;
17770 }
17771
17772
17773 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17774 PyObject *resultobj = 0;
17775 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17776 wxString *result = 0 ;
17777 void *argp1 = 0 ;
17778 int res1 = 0 ;
17779 PyObject *swig_obj[1] ;
17780
17781 if (!args) SWIG_fail;
17782 swig_obj[0] = args;
17783 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17784 if (!SWIG_IsOK(res1)) {
17785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconFile" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17786 }
17787 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17788 {
17789 PyThreadState* __tstate = wxPyBeginAllowThreads();
17790 {
17791 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
17792 result = (wxString *) &_result_ref;
17793 }
17794 wxPyEndAllowThreads(__tstate);
17795 if (PyErr_Occurred()) SWIG_fail;
17796 }
17797 {
17798 #if wxUSE_UNICODE
17799 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17800 #else
17801 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17802 #endif
17803 }
17804 return resultobj;
17805 fail:
17806 return NULL;
17807 }
17808
17809
17810 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17811 PyObject *resultobj = 0;
17812 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17813 int result;
17814 void *argp1 = 0 ;
17815 int res1 = 0 ;
17816 PyObject *swig_obj[1] ;
17817
17818 if (!args) SWIG_fail;
17819 swig_obj[0] = args;
17820 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17821 if (!SWIG_IsOK(res1)) {
17822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconIndex" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17823 }
17824 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17825 {
17826 PyThreadState* __tstate = wxPyBeginAllowThreads();
17827 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
17828 wxPyEndAllowThreads(__tstate);
17829 if (PyErr_Occurred()) SWIG_fail;
17830 }
17831 resultobj = SWIG_From_int(static_cast< int >(result));
17832 return resultobj;
17833 fail:
17834 return NULL;
17835 }
17836
17837
17838 SWIGINTERN PyObject *FileTypeInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17839 PyObject *obj;
17840 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17841 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileTypeInfo, SWIG_NewClientData(obj));
17842 return SWIG_Py_Void();
17843 }
17844
17845 SWIGINTERN PyObject *FileTypeInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17846 return SWIG_Python_InitShadowInstance(args);
17847 }
17848
17849 SWIGINTERN PyObject *_wrap_new_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17850 PyObject *resultobj = 0;
17851 wxFileTypeInfo *arg1 = 0 ;
17852 wxFileType *result = 0 ;
17853 void *argp1 = 0 ;
17854 int res1 = 0 ;
17855 PyObject * obj0 = 0 ;
17856 char * kwnames[] = {
17857 (char *) "ftInfo", NULL
17858 };
17859
17860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) SWIG_fail;
17861 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
17862 if (!SWIG_IsOK(res1)) {
17863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
17864 }
17865 if (!argp1) {
17866 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
17867 }
17868 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17869 {
17870 PyThreadState* __tstate = wxPyBeginAllowThreads();
17871 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
17872 wxPyEndAllowThreads(__tstate);
17873 if (PyErr_Occurred()) SWIG_fail;
17874 }
17875 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_NEW | 0 );
17876 return resultobj;
17877 fail:
17878 return NULL;
17879 }
17880
17881
17882 SWIGINTERN PyObject *_wrap_delete_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17883 PyObject *resultobj = 0;
17884 wxFileType *arg1 = (wxFileType *) 0 ;
17885 void *argp1 = 0 ;
17886 int res1 = 0 ;
17887 PyObject *swig_obj[1] ;
17888
17889 if (!args) SWIG_fail;
17890 swig_obj[0] = args;
17891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, SWIG_POINTER_DISOWN | 0 );
17892 if (!SWIG_IsOK(res1)) {
17893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileType" "', expected argument " "1"" of type '" "wxFileType *""'");
17894 }
17895 arg1 = reinterpret_cast< wxFileType * >(argp1);
17896 {
17897 PyThreadState* __tstate = wxPyBeginAllowThreads();
17898 delete arg1;
17899
17900 wxPyEndAllowThreads(__tstate);
17901 if (PyErr_Occurred()) SWIG_fail;
17902 }
17903 resultobj = SWIG_Py_Void();
17904 return resultobj;
17905 fail:
17906 return NULL;
17907 }
17908
17909
17910 SWIGINTERN PyObject *_wrap_FileType_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17911 PyObject *resultobj = 0;
17912 wxFileType *arg1 = (wxFileType *) 0 ;
17913 PyObject *result = 0 ;
17914 void *argp1 = 0 ;
17915 int res1 = 0 ;
17916 PyObject *swig_obj[1] ;
17917
17918 if (!args) SWIG_fail;
17919 swig_obj[0] = args;
17920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17921 if (!SWIG_IsOK(res1)) {
17922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeType" "', expected argument " "1"" of type '" "wxFileType *""'");
17923 }
17924 arg1 = reinterpret_cast< wxFileType * >(argp1);
17925 {
17926 PyThreadState* __tstate = wxPyBeginAllowThreads();
17927 result = (PyObject *)wxFileType_GetMimeType(arg1);
17928 wxPyEndAllowThreads(__tstate);
17929 if (PyErr_Occurred()) SWIG_fail;
17930 }
17931 resultobj = result;
17932 return resultobj;
17933 fail:
17934 return NULL;
17935 }
17936
17937
17938 SWIGINTERN PyObject *_wrap_FileType_GetMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17939 PyObject *resultobj = 0;
17940 wxFileType *arg1 = (wxFileType *) 0 ;
17941 PyObject *result = 0 ;
17942 void *argp1 = 0 ;
17943 int res1 = 0 ;
17944 PyObject *swig_obj[1] ;
17945
17946 if (!args) SWIG_fail;
17947 swig_obj[0] = args;
17948 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17949 if (!SWIG_IsOK(res1)) {
17950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeTypes" "', expected argument " "1"" of type '" "wxFileType *""'");
17951 }
17952 arg1 = reinterpret_cast< wxFileType * >(argp1);
17953 {
17954 PyThreadState* __tstate = wxPyBeginAllowThreads();
17955 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
17956 wxPyEndAllowThreads(__tstate);
17957 if (PyErr_Occurred()) SWIG_fail;
17958 }
17959 resultobj = result;
17960 return resultobj;
17961 fail:
17962 return NULL;
17963 }
17964
17965
17966 SWIGINTERN PyObject *_wrap_FileType_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17967 PyObject *resultobj = 0;
17968 wxFileType *arg1 = (wxFileType *) 0 ;
17969 PyObject *result = 0 ;
17970 void *argp1 = 0 ;
17971 int res1 = 0 ;
17972 PyObject *swig_obj[1] ;
17973
17974 if (!args) SWIG_fail;
17975 swig_obj[0] = args;
17976 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17977 if (!SWIG_IsOK(res1)) {
17978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetExtensions" "', expected argument " "1"" of type '" "wxFileType *""'");
17979 }
17980 arg1 = reinterpret_cast< wxFileType * >(argp1);
17981 {
17982 PyThreadState* __tstate = wxPyBeginAllowThreads();
17983 result = (PyObject *)wxFileType_GetExtensions(arg1);
17984 wxPyEndAllowThreads(__tstate);
17985 if (PyErr_Occurred()) SWIG_fail;
17986 }
17987 resultobj = result;
17988 return resultobj;
17989 fail:
17990 return NULL;
17991 }
17992
17993
17994 SWIGINTERN PyObject *_wrap_FileType_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17995 PyObject *resultobj = 0;
17996 wxFileType *arg1 = (wxFileType *) 0 ;
17997 wxIcon *result = 0 ;
17998 void *argp1 = 0 ;
17999 int res1 = 0 ;
18000 PyObject *swig_obj[1] ;
18001
18002 if (!args) SWIG_fail;
18003 swig_obj[0] = args;
18004 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18005 if (!SWIG_IsOK(res1)) {
18006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
18007 }
18008 arg1 = reinterpret_cast< wxFileType * >(argp1);
18009 {
18010 PyThreadState* __tstate = wxPyBeginAllowThreads();
18011 result = (wxIcon *)wxFileType_GetIcon(arg1);
18012 wxPyEndAllowThreads(__tstate);
18013 if (PyErr_Occurred()) SWIG_fail;
18014 }
18015 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
18016 return resultobj;
18017 fail:
18018 return NULL;
18019 }
18020
18021
18022 SWIGINTERN PyObject *_wrap_FileType_GetIconInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18023 PyObject *resultobj = 0;
18024 wxFileType *arg1 = (wxFileType *) 0 ;
18025 PyObject *result = 0 ;
18026 void *argp1 = 0 ;
18027 int res1 = 0 ;
18028 PyObject *swig_obj[1] ;
18029
18030 if (!args) SWIG_fail;
18031 swig_obj[0] = args;
18032 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18033 if (!SWIG_IsOK(res1)) {
18034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIconInfo" "', expected argument " "1"" of type '" "wxFileType *""'");
18035 }
18036 arg1 = reinterpret_cast< wxFileType * >(argp1);
18037 {
18038 PyThreadState* __tstate = wxPyBeginAllowThreads();
18039 result = (PyObject *)wxFileType_GetIconInfo(arg1);
18040 wxPyEndAllowThreads(__tstate);
18041 if (PyErr_Occurred()) SWIG_fail;
18042 }
18043 resultobj = result;
18044 return resultobj;
18045 fail:
18046 return NULL;
18047 }
18048
18049
18050 SWIGINTERN PyObject *_wrap_FileType_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18051 PyObject *resultobj = 0;
18052 wxFileType *arg1 = (wxFileType *) 0 ;
18053 PyObject *result = 0 ;
18054 void *argp1 = 0 ;
18055 int res1 = 0 ;
18056 PyObject *swig_obj[1] ;
18057
18058 if (!args) SWIG_fail;
18059 swig_obj[0] = args;
18060 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18061 if (!SWIG_IsOK(res1)) {
18062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetDescription" "', expected argument " "1"" of type '" "wxFileType *""'");
18063 }
18064 arg1 = reinterpret_cast< wxFileType * >(argp1);
18065 {
18066 PyThreadState* __tstate = wxPyBeginAllowThreads();
18067 result = (PyObject *)wxFileType_GetDescription(arg1);
18068 wxPyEndAllowThreads(__tstate);
18069 if (PyErr_Occurred()) SWIG_fail;
18070 }
18071 resultobj = result;
18072 return resultobj;
18073 fail:
18074 return NULL;
18075 }
18076
18077
18078 SWIGINTERN PyObject *_wrap_FileType_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18079 PyObject *resultobj = 0;
18080 wxFileType *arg1 = (wxFileType *) 0 ;
18081 wxString *arg2 = 0 ;
18082 wxString const &arg3_defvalue = wxPyEmptyString ;
18083 wxString *arg3 = (wxString *) &arg3_defvalue ;
18084 PyObject *result = 0 ;
18085 void *argp1 = 0 ;
18086 int res1 = 0 ;
18087 bool temp2 = false ;
18088 bool temp3 = false ;
18089 PyObject * obj0 = 0 ;
18090 PyObject * obj1 = 0 ;
18091 PyObject * obj2 = 0 ;
18092 char * kwnames[] = {
18093 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18094 };
18095
18096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18098 if (!SWIG_IsOK(res1)) {
18099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18100 }
18101 arg1 = reinterpret_cast< wxFileType * >(argp1);
18102 {
18103 arg2 = wxString_in_helper(obj1);
18104 if (arg2 == NULL) SWIG_fail;
18105 temp2 = true;
18106 }
18107 if (obj2) {
18108 {
18109 arg3 = wxString_in_helper(obj2);
18110 if (arg3 == NULL) SWIG_fail;
18111 temp3 = true;
18112 }
18113 }
18114 {
18115 PyThreadState* __tstate = wxPyBeginAllowThreads();
18116 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18117 wxPyEndAllowThreads(__tstate);
18118 if (PyErr_Occurred()) SWIG_fail;
18119 }
18120 resultobj = result;
18121 {
18122 if (temp2)
18123 delete arg2;
18124 }
18125 {
18126 if (temp3)
18127 delete arg3;
18128 }
18129 return resultobj;
18130 fail:
18131 {
18132 if (temp2)
18133 delete arg2;
18134 }
18135 {
18136 if (temp3)
18137 delete arg3;
18138 }
18139 return NULL;
18140 }
18141
18142
18143 SWIGINTERN PyObject *_wrap_FileType_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18144 PyObject *resultobj = 0;
18145 wxFileType *arg1 = (wxFileType *) 0 ;
18146 wxString *arg2 = 0 ;
18147 wxString const &arg3_defvalue = wxPyEmptyString ;
18148 wxString *arg3 = (wxString *) &arg3_defvalue ;
18149 PyObject *result = 0 ;
18150 void *argp1 = 0 ;
18151 int res1 = 0 ;
18152 bool temp2 = false ;
18153 bool temp3 = false ;
18154 PyObject * obj0 = 0 ;
18155 PyObject * obj1 = 0 ;
18156 PyObject * obj2 = 0 ;
18157 char * kwnames[] = {
18158 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18159 };
18160
18161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18162 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18163 if (!SWIG_IsOK(res1)) {
18164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18165 }
18166 arg1 = reinterpret_cast< wxFileType * >(argp1);
18167 {
18168 arg2 = wxString_in_helper(obj1);
18169 if (arg2 == NULL) SWIG_fail;
18170 temp2 = true;
18171 }
18172 if (obj2) {
18173 {
18174 arg3 = wxString_in_helper(obj2);
18175 if (arg3 == NULL) SWIG_fail;
18176 temp3 = true;
18177 }
18178 }
18179 {
18180 PyThreadState* __tstate = wxPyBeginAllowThreads();
18181 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18182 wxPyEndAllowThreads(__tstate);
18183 if (PyErr_Occurred()) SWIG_fail;
18184 }
18185 resultobj = result;
18186 {
18187 if (temp2)
18188 delete arg2;
18189 }
18190 {
18191 if (temp3)
18192 delete arg3;
18193 }
18194 return resultobj;
18195 fail:
18196 {
18197 if (temp2)
18198 delete arg2;
18199 }
18200 {
18201 if (temp3)
18202 delete arg3;
18203 }
18204 return NULL;
18205 }
18206
18207
18208 SWIGINTERN PyObject *_wrap_FileType_GetAllCommands(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18209 PyObject *resultobj = 0;
18210 wxFileType *arg1 = (wxFileType *) 0 ;
18211 wxString *arg2 = 0 ;
18212 wxString const &arg3_defvalue = wxPyEmptyString ;
18213 wxString *arg3 = (wxString *) &arg3_defvalue ;
18214 PyObject *result = 0 ;
18215 void *argp1 = 0 ;
18216 int res1 = 0 ;
18217 bool temp2 = false ;
18218 bool temp3 = false ;
18219 PyObject * obj0 = 0 ;
18220 PyObject * obj1 = 0 ;
18221 PyObject * obj2 = 0 ;
18222 char * kwnames[] = {
18223 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18224 };
18225
18226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18227 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18228 if (!SWIG_IsOK(res1)) {
18229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetAllCommands" "', expected argument " "1"" of type '" "wxFileType *""'");
18230 }
18231 arg1 = reinterpret_cast< wxFileType * >(argp1);
18232 {
18233 arg2 = wxString_in_helper(obj1);
18234 if (arg2 == NULL) SWIG_fail;
18235 temp2 = true;
18236 }
18237 if (obj2) {
18238 {
18239 arg3 = wxString_in_helper(obj2);
18240 if (arg3 == NULL) SWIG_fail;
18241 temp3 = true;
18242 }
18243 }
18244 {
18245 PyThreadState* __tstate = wxPyBeginAllowThreads();
18246 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18247 wxPyEndAllowThreads(__tstate);
18248 if (PyErr_Occurred()) SWIG_fail;
18249 }
18250 resultobj = result;
18251 {
18252 if (temp2)
18253 delete arg2;
18254 }
18255 {
18256 if (temp3)
18257 delete arg3;
18258 }
18259 return resultobj;
18260 fail:
18261 {
18262 if (temp2)
18263 delete arg2;
18264 }
18265 {
18266 if (temp3)
18267 delete arg3;
18268 }
18269 return NULL;
18270 }
18271
18272
18273 SWIGINTERN PyObject *_wrap_FileType_SetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18274 PyObject *resultobj = 0;
18275 wxFileType *arg1 = (wxFileType *) 0 ;
18276 wxString *arg2 = 0 ;
18277 wxString *arg3 = 0 ;
18278 bool arg4 = (bool) true ;
18279 bool result;
18280 void *argp1 = 0 ;
18281 int res1 = 0 ;
18282 bool temp2 = false ;
18283 bool temp3 = false ;
18284 bool val4 ;
18285 int ecode4 = 0 ;
18286 PyObject * obj0 = 0 ;
18287 PyObject * obj1 = 0 ;
18288 PyObject * obj2 = 0 ;
18289 PyObject * obj3 = 0 ;
18290 char * kwnames[] = {
18291 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
18292 };
18293
18294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18295 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18296 if (!SWIG_IsOK(res1)) {
18297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18298 }
18299 arg1 = reinterpret_cast< wxFileType * >(argp1);
18300 {
18301 arg2 = wxString_in_helper(obj1);
18302 if (arg2 == NULL) SWIG_fail;
18303 temp2 = true;
18304 }
18305 {
18306 arg3 = wxString_in_helper(obj2);
18307 if (arg3 == NULL) SWIG_fail;
18308 temp3 = true;
18309 }
18310 if (obj3) {
18311 ecode4 = SWIG_AsVal_bool(obj3, &val4);
18312 if (!SWIG_IsOK(ecode4)) {
18313 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileType_SetCommand" "', expected argument " "4"" of type '" "bool""'");
18314 }
18315 arg4 = static_cast< bool >(val4);
18316 }
18317 {
18318 PyThreadState* __tstate = wxPyBeginAllowThreads();
18319 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
18320 wxPyEndAllowThreads(__tstate);
18321 if (PyErr_Occurred()) SWIG_fail;
18322 }
18323 {
18324 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18325 }
18326 {
18327 if (temp2)
18328 delete arg2;
18329 }
18330 {
18331 if (temp3)
18332 delete arg3;
18333 }
18334 return resultobj;
18335 fail:
18336 {
18337 if (temp2)
18338 delete arg2;
18339 }
18340 {
18341 if (temp3)
18342 delete arg3;
18343 }
18344 return NULL;
18345 }
18346
18347
18348 SWIGINTERN PyObject *_wrap_FileType_SetDefaultIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18349 PyObject *resultobj = 0;
18350 wxFileType *arg1 = (wxFileType *) 0 ;
18351 wxString const &arg2_defvalue = wxPyEmptyString ;
18352 wxString *arg2 = (wxString *) &arg2_defvalue ;
18353 int arg3 = (int) 0 ;
18354 bool result;
18355 void *argp1 = 0 ;
18356 int res1 = 0 ;
18357 bool temp2 = false ;
18358 int val3 ;
18359 int ecode3 = 0 ;
18360 PyObject * obj0 = 0 ;
18361 PyObject * obj1 = 0 ;
18362 PyObject * obj2 = 0 ;
18363 char * kwnames[] = {
18364 (char *) "self",(char *) "cmd",(char *) "index", NULL
18365 };
18366
18367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18368 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18369 if (!SWIG_IsOK(res1)) {
18370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetDefaultIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
18371 }
18372 arg1 = reinterpret_cast< wxFileType * >(argp1);
18373 if (obj1) {
18374 {
18375 arg2 = wxString_in_helper(obj1);
18376 if (arg2 == NULL) SWIG_fail;
18377 temp2 = true;
18378 }
18379 }
18380 if (obj2) {
18381 ecode3 = SWIG_AsVal_int(obj2, &val3);
18382 if (!SWIG_IsOK(ecode3)) {
18383 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileType_SetDefaultIcon" "', expected argument " "3"" of type '" "int""'");
18384 }
18385 arg3 = static_cast< int >(val3);
18386 }
18387 {
18388 PyThreadState* __tstate = wxPyBeginAllowThreads();
18389 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
18390 wxPyEndAllowThreads(__tstate);
18391 if (PyErr_Occurred()) SWIG_fail;
18392 }
18393 {
18394 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18395 }
18396 {
18397 if (temp2)
18398 delete arg2;
18399 }
18400 return resultobj;
18401 fail:
18402 {
18403 if (temp2)
18404 delete arg2;
18405 }
18406 return NULL;
18407 }
18408
18409
18410 SWIGINTERN PyObject *_wrap_FileType_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18411 PyObject *resultobj = 0;
18412 wxFileType *arg1 = (wxFileType *) 0 ;
18413 bool result;
18414 void *argp1 = 0 ;
18415 int res1 = 0 ;
18416 PyObject *swig_obj[1] ;
18417
18418 if (!args) SWIG_fail;
18419 swig_obj[0] = args;
18420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18421 if (!SWIG_IsOK(res1)) {
18422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_Unassociate" "', expected argument " "1"" of type '" "wxFileType *""'");
18423 }
18424 arg1 = reinterpret_cast< wxFileType * >(argp1);
18425 {
18426 PyThreadState* __tstate = wxPyBeginAllowThreads();
18427 result = (bool)(arg1)->Unassociate();
18428 wxPyEndAllowThreads(__tstate);
18429 if (PyErr_Occurred()) SWIG_fail;
18430 }
18431 {
18432 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18433 }
18434 return resultobj;
18435 fail:
18436 return NULL;
18437 }
18438
18439
18440 SWIGINTERN PyObject *_wrap_FileType_ExpandCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18441 PyObject *resultobj = 0;
18442 wxString *arg1 = 0 ;
18443 wxString *arg2 = 0 ;
18444 wxString const &arg3_defvalue = wxPyEmptyString ;
18445 wxString *arg3 = (wxString *) &arg3_defvalue ;
18446 wxString result;
18447 bool temp1 = false ;
18448 bool temp2 = false ;
18449 bool temp3 = false ;
18450 PyObject * obj0 = 0 ;
18451 PyObject * obj1 = 0 ;
18452 PyObject * obj2 = 0 ;
18453 char * kwnames[] = {
18454 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
18455 };
18456
18457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18458 {
18459 arg1 = wxString_in_helper(obj0);
18460 if (arg1 == NULL) SWIG_fail;
18461 temp1 = true;
18462 }
18463 {
18464 arg2 = wxString_in_helper(obj1);
18465 if (arg2 == NULL) SWIG_fail;
18466 temp2 = true;
18467 }
18468 if (obj2) {
18469 {
18470 arg3 = wxString_in_helper(obj2);
18471 if (arg3 == NULL) SWIG_fail;
18472 temp3 = true;
18473 }
18474 }
18475 {
18476 PyThreadState* __tstate = wxPyBeginAllowThreads();
18477 result = wxFileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18478 wxPyEndAllowThreads(__tstate);
18479 if (PyErr_Occurred()) SWIG_fail;
18480 }
18481 {
18482 #if wxUSE_UNICODE
18483 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18484 #else
18485 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18486 #endif
18487 }
18488 {
18489 if (temp1)
18490 delete arg1;
18491 }
18492 {
18493 if (temp2)
18494 delete arg2;
18495 }
18496 {
18497 if (temp3)
18498 delete arg3;
18499 }
18500 return resultobj;
18501 fail:
18502 {
18503 if (temp1)
18504 delete arg1;
18505 }
18506 {
18507 if (temp2)
18508 delete arg2;
18509 }
18510 {
18511 if (temp3)
18512 delete arg3;
18513 }
18514 return NULL;
18515 }
18516
18517
18518 SWIGINTERN PyObject *FileType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18519 PyObject *obj;
18520 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18521 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileType, SWIG_NewClientData(obj));
18522 return SWIG_Py_Void();
18523 }
18524
18525 SWIGINTERN PyObject *FileType_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18526 return SWIG_Python_InitShadowInstance(args);
18527 }
18528
18529 SWIGINTERN int TheMimeTypesManager_set(PyObject *) {
18530 SWIG_Error(SWIG_AttributeError,"Variable TheMimeTypesManager is read-only.");
18531 return 1;
18532 }
18533
18534
18535 SWIGINTERN PyObject *TheMimeTypesManager_get(void) {
18536 PyObject *pyobj = 0;
18537
18538 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0 );
18539 return pyobj;
18540 }
18541
18542
18543 SWIGINTERN PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18544 PyObject *resultobj = 0;
18545 wxString *arg1 = 0 ;
18546 wxString *arg2 = 0 ;
18547 bool result;
18548 bool temp1 = false ;
18549 bool temp2 = false ;
18550 PyObject * obj0 = 0 ;
18551 PyObject * obj1 = 0 ;
18552 char * kwnames[] = {
18553 (char *) "mimeType",(char *) "wildcard", NULL
18554 };
18555
18556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) SWIG_fail;
18557 {
18558 arg1 = wxString_in_helper(obj0);
18559 if (arg1 == NULL) SWIG_fail;
18560 temp1 = true;
18561 }
18562 {
18563 arg2 = wxString_in_helper(obj1);
18564 if (arg2 == NULL) SWIG_fail;
18565 temp2 = true;
18566 }
18567 {
18568 PyThreadState* __tstate = wxPyBeginAllowThreads();
18569 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
18570 wxPyEndAllowThreads(__tstate);
18571 if (PyErr_Occurred()) SWIG_fail;
18572 }
18573 {
18574 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18575 }
18576 {
18577 if (temp1)
18578 delete arg1;
18579 }
18580 {
18581 if (temp2)
18582 delete arg2;
18583 }
18584 return resultobj;
18585 fail:
18586 {
18587 if (temp1)
18588 delete arg1;
18589 }
18590 {
18591 if (temp2)
18592 delete arg2;
18593 }
18594 return NULL;
18595 }
18596
18597
18598 SWIGINTERN PyObject *_wrap_new_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18599 PyObject *resultobj = 0;
18600 wxMimeTypesManager *result = 0 ;
18601
18602 if (!SWIG_Python_UnpackTuple(args,"new_MimeTypesManager",0,0,0)) SWIG_fail;
18603 {
18604 PyThreadState* __tstate = wxPyBeginAllowThreads();
18605 result = (wxMimeTypesManager *)new wxMimeTypesManager();
18606 wxPyEndAllowThreads(__tstate);
18607 if (PyErr_Occurred()) SWIG_fail;
18608 }
18609 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_NEW | 0 );
18610 return resultobj;
18611 fail:
18612 return NULL;
18613 }
18614
18615
18616 SWIGINTERN PyObject *_wrap_MimeTypesManager_Initialize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18617 PyObject *resultobj = 0;
18618 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18619 int arg2 = (int) wxMAILCAP_ALL ;
18620 wxString const &arg3_defvalue = wxPyEmptyString ;
18621 wxString *arg3 = (wxString *) &arg3_defvalue ;
18622 void *argp1 = 0 ;
18623 int res1 = 0 ;
18624 int val2 ;
18625 int ecode2 = 0 ;
18626 bool temp3 = false ;
18627 PyObject * obj0 = 0 ;
18628 PyObject * obj1 = 0 ;
18629 PyObject * obj2 = 0 ;
18630 char * kwnames[] = {
18631 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
18632 };
18633
18634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18636 if (!SWIG_IsOK(res1)) {
18637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Initialize" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18638 }
18639 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18640 if (obj1) {
18641 ecode2 = SWIG_AsVal_int(obj1, &val2);
18642 if (!SWIG_IsOK(ecode2)) {
18643 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MimeTypesManager_Initialize" "', expected argument " "2"" of type '" "int""'");
18644 }
18645 arg2 = static_cast< int >(val2);
18646 }
18647 if (obj2) {
18648 {
18649 arg3 = wxString_in_helper(obj2);
18650 if (arg3 == NULL) SWIG_fail;
18651 temp3 = true;
18652 }
18653 }
18654 {
18655 PyThreadState* __tstate = wxPyBeginAllowThreads();
18656 (arg1)->Initialize(arg2,(wxString const &)*arg3);
18657 wxPyEndAllowThreads(__tstate);
18658 if (PyErr_Occurred()) SWIG_fail;
18659 }
18660 resultobj = SWIG_Py_Void();
18661 {
18662 if (temp3)
18663 delete arg3;
18664 }
18665 return resultobj;
18666 fail:
18667 {
18668 if (temp3)
18669 delete arg3;
18670 }
18671 return NULL;
18672 }
18673
18674
18675 SWIGINTERN PyObject *_wrap_MimeTypesManager_ClearData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18676 PyObject *resultobj = 0;
18677 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18678 void *argp1 = 0 ;
18679 int res1 = 0 ;
18680 PyObject *swig_obj[1] ;
18681
18682 if (!args) SWIG_fail;
18683 swig_obj[0] = args;
18684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18685 if (!SWIG_IsOK(res1)) {
18686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ClearData" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18687 }
18688 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18689 {
18690 PyThreadState* __tstate = wxPyBeginAllowThreads();
18691 (arg1)->ClearData();
18692 wxPyEndAllowThreads(__tstate);
18693 if (PyErr_Occurred()) SWIG_fail;
18694 }
18695 resultobj = SWIG_Py_Void();
18696 return resultobj;
18697 fail:
18698 return NULL;
18699 }
18700
18701
18702 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18703 PyObject *resultobj = 0;
18704 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18705 wxString *arg2 = 0 ;
18706 wxFileType *result = 0 ;
18707 void *argp1 = 0 ;
18708 int res1 = 0 ;
18709 bool temp2 = false ;
18710 PyObject * obj0 = 0 ;
18711 PyObject * obj1 = 0 ;
18712 char * kwnames[] = {
18713 (char *) "self",(char *) "ext", NULL
18714 };
18715
18716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) SWIG_fail;
18717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18718 if (!SWIG_IsOK(res1)) {
18719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromExtension" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18720 }
18721 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18722 {
18723 arg2 = wxString_in_helper(obj1);
18724 if (arg2 == NULL) SWIG_fail;
18725 temp2 = true;
18726 }
18727 {
18728 PyThreadState* __tstate = wxPyBeginAllowThreads();
18729 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
18730 wxPyEndAllowThreads(__tstate);
18731 if (PyErr_Occurred()) SWIG_fail;
18732 }
18733 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
18734 {
18735 if (temp2)
18736 delete arg2;
18737 }
18738 return resultobj;
18739 fail:
18740 {
18741 if (temp2)
18742 delete arg2;
18743 }
18744 return NULL;
18745 }
18746
18747
18748 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18749 PyObject *resultobj = 0;
18750 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18751 wxString *arg2 = 0 ;
18752 wxFileType *result = 0 ;
18753 void *argp1 = 0 ;
18754 int res1 = 0 ;
18755 bool temp2 = false ;
18756 PyObject * obj0 = 0 ;
18757 PyObject * obj1 = 0 ;
18758 char * kwnames[] = {
18759 (char *) "self",(char *) "mimeType", NULL
18760 };
18761
18762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
18763 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18764 if (!SWIG_IsOK(res1)) {
18765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromMimeType" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18766 }
18767 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18768 {
18769 arg2 = wxString_in_helper(obj1);
18770 if (arg2 == NULL) SWIG_fail;
18771 temp2 = true;
18772 }
18773 {
18774 PyThreadState* __tstate = wxPyBeginAllowThreads();
18775 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
18776 wxPyEndAllowThreads(__tstate);
18777 if (PyErr_Occurred()) SWIG_fail;
18778 }
18779 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
18780 {
18781 if (temp2)
18782 delete arg2;
18783 }
18784 return resultobj;
18785 fail:
18786 {
18787 if (temp2)
18788 delete arg2;
18789 }
18790 return NULL;
18791 }
18792
18793
18794 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18795 PyObject *resultobj = 0;
18796 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18797 wxString *arg2 = 0 ;
18798 bool arg3 = (bool) false ;
18799 bool result;
18800 void *argp1 = 0 ;
18801 int res1 = 0 ;
18802 bool temp2 = false ;
18803 bool val3 ;
18804 int ecode3 = 0 ;
18805 PyObject * obj0 = 0 ;
18806 PyObject * obj1 = 0 ;
18807 PyObject * obj2 = 0 ;
18808 char * kwnames[] = {
18809 (char *) "self",(char *) "filename",(char *) "fallback", NULL
18810 };
18811
18812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18813 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18814 if (!SWIG_IsOK(res1)) {
18815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18816 }
18817 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18818 {
18819 arg2 = wxString_in_helper(obj1);
18820 if (arg2 == NULL) SWIG_fail;
18821 temp2 = true;
18822 }
18823 if (obj2) {
18824 ecode3 = SWIG_AsVal_bool(obj2, &val3);
18825 if (!SWIG_IsOK(ecode3)) {
18826 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "3"" of type '" "bool""'");
18827 }
18828 arg3 = static_cast< bool >(val3);
18829 }
18830 {
18831 PyThreadState* __tstate = wxPyBeginAllowThreads();
18832 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
18833 wxPyEndAllowThreads(__tstate);
18834 if (PyErr_Occurred()) SWIG_fail;
18835 }
18836 {
18837 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18838 }
18839 {
18840 if (temp2)
18841 delete arg2;
18842 }
18843 return resultobj;
18844 fail:
18845 {
18846 if (temp2)
18847 delete arg2;
18848 }
18849 return NULL;
18850 }
18851
18852
18853 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18854 PyObject *resultobj = 0;
18855 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18856 wxString *arg2 = 0 ;
18857 bool result;
18858 void *argp1 = 0 ;
18859 int res1 = 0 ;
18860 bool temp2 = false ;
18861 PyObject * obj0 = 0 ;
18862 PyObject * obj1 = 0 ;
18863 char * kwnames[] = {
18864 (char *) "self",(char *) "filename", NULL
18865 };
18866
18867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) SWIG_fail;
18868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18869 if (!SWIG_IsOK(res1)) {
18870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMimeTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18871 }
18872 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18873 {
18874 arg2 = wxString_in_helper(obj1);
18875 if (arg2 == NULL) SWIG_fail;
18876 temp2 = true;
18877 }
18878 {
18879 PyThreadState* __tstate = wxPyBeginAllowThreads();
18880 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
18881 wxPyEndAllowThreads(__tstate);
18882 if (PyErr_Occurred()) SWIG_fail;
18883 }
18884 {
18885 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18886 }
18887 {
18888 if (temp2)
18889 delete arg2;
18890 }
18891 return resultobj;
18892 fail:
18893 {
18894 if (temp2)
18895 delete arg2;
18896 }
18897 return NULL;
18898 }
18899
18900
18901 SWIGINTERN PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18902 PyObject *resultobj = 0;
18903 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18904 PyObject *result = 0 ;
18905 void *argp1 = 0 ;
18906 int res1 = 0 ;
18907 PyObject *swig_obj[1] ;
18908
18909 if (!args) SWIG_fail;
18910 swig_obj[0] = args;
18911 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18912 if (!SWIG_IsOK(res1)) {
18913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_EnumAllFileTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18914 }
18915 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18916 {
18917 PyThreadState* __tstate = wxPyBeginAllowThreads();
18918 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
18919 wxPyEndAllowThreads(__tstate);
18920 if (PyErr_Occurred()) SWIG_fail;
18921 }
18922 resultobj = result;
18923 return resultobj;
18924 fail:
18925 return NULL;
18926 }
18927
18928
18929 SWIGINTERN PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18930 PyObject *resultobj = 0;
18931 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18932 wxFileTypeInfo *arg2 = 0 ;
18933 void *argp1 = 0 ;
18934 int res1 = 0 ;
18935 void *argp2 = 0 ;
18936 int res2 = 0 ;
18937 PyObject * obj0 = 0 ;
18938 PyObject * obj1 = 0 ;
18939 char * kwnames[] = {
18940 (char *) "self",(char *) "ft", NULL
18941 };
18942
18943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) SWIG_fail;
18944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18945 if (!SWIG_IsOK(res1)) {
18946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18947 }
18948 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18949 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
18950 if (!SWIG_IsOK(res2)) {
18951 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
18952 }
18953 if (!argp2) {
18954 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
18955 }
18956 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
18957 {
18958 PyThreadState* __tstate = wxPyBeginAllowThreads();
18959 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
18960 wxPyEndAllowThreads(__tstate);
18961 if (PyErr_Occurred()) SWIG_fail;
18962 }
18963 resultobj = SWIG_Py_Void();
18964 return resultobj;
18965 fail:
18966 return NULL;
18967 }
18968
18969
18970 SWIGINTERN PyObject *_wrap_MimeTypesManager_Associate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18971 PyObject *resultobj = 0;
18972 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18973 wxFileTypeInfo *arg2 = 0 ;
18974 wxFileType *result = 0 ;
18975 void *argp1 = 0 ;
18976 int res1 = 0 ;
18977 void *argp2 = 0 ;
18978 int res2 = 0 ;
18979 PyObject * obj0 = 0 ;
18980 PyObject * obj1 = 0 ;
18981 char * kwnames[] = {
18982 (char *) "self",(char *) "ftInfo", NULL
18983 };
18984
18985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) SWIG_fail;
18986 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18987 if (!SWIG_IsOK(res1)) {
18988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Associate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18989 }
18990 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18991 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
18992 if (!SWIG_IsOK(res2)) {
18993 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
18994 }
18995 if (!argp2) {
18996 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
18997 }
18998 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
18999 {
19000 PyThreadState* __tstate = wxPyBeginAllowThreads();
19001 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
19002 wxPyEndAllowThreads(__tstate);
19003 if (PyErr_Occurred()) SWIG_fail;
19004 }
19005 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
19006 return resultobj;
19007 fail:
19008 return NULL;
19009 }
19010
19011
19012 SWIGINTERN PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19013 PyObject *resultobj = 0;
19014 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19015 wxFileType *arg2 = (wxFileType *) 0 ;
19016 bool result;
19017 void *argp1 = 0 ;
19018 int res1 = 0 ;
19019 void *argp2 = 0 ;
19020 int res2 = 0 ;
19021 PyObject * obj0 = 0 ;
19022 PyObject * obj1 = 0 ;
19023 char * kwnames[] = {
19024 (char *) "self",(char *) "ft", NULL
19025 };
19026
19027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) SWIG_fail;
19028 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19029 if (!SWIG_IsOK(res1)) {
19030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19031 }
19032 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19033 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFileType, 0 | 0 );
19034 if (!SWIG_IsOK(res2)) {
19035 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "2"" of type '" "wxFileType *""'");
19036 }
19037 arg2 = reinterpret_cast< wxFileType * >(argp2);
19038 {
19039 PyThreadState* __tstate = wxPyBeginAllowThreads();
19040 result = (bool)(arg1)->Unassociate(arg2);
19041 wxPyEndAllowThreads(__tstate);
19042 if (PyErr_Occurred()) SWIG_fail;
19043 }
19044 {
19045 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19046 }
19047 return resultobj;
19048 fail:
19049 return NULL;
19050 }
19051
19052
19053 SWIGINTERN PyObject *_wrap_delete_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19054 PyObject *resultobj = 0;
19055 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19056 void *argp1 = 0 ;
19057 int res1 = 0 ;
19058 PyObject *swig_obj[1] ;
19059
19060 if (!args) SWIG_fail;
19061 swig_obj[0] = args;
19062 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_DISOWN | 0 );
19063 if (!SWIG_IsOK(res1)) {
19064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MimeTypesManager" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19065 }
19066 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19067 {
19068 PyThreadState* __tstate = wxPyBeginAllowThreads();
19069 delete arg1;
19070
19071 wxPyEndAllowThreads(__tstate);
19072 if (PyErr_Occurred()) SWIG_fail;
19073 }
19074 resultobj = SWIG_Py_Void();
19075 return resultobj;
19076 fail:
19077 return NULL;
19078 }
19079
19080
19081 SWIGINTERN PyObject *MimeTypesManager_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19082 PyObject *obj;
19083 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19084 SWIG_TypeNewClientData(SWIGTYPE_p_wxMimeTypesManager, SWIG_NewClientData(obj));
19085 return SWIG_Py_Void();
19086 }
19087
19088 SWIGINTERN PyObject *MimeTypesManager_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19089 return SWIG_Python_InitShadowInstance(args);
19090 }
19091
19092 SWIGINTERN int ART_TOOLBAR_set(PyObject *) {
19093 SWIG_Error(SWIG_AttributeError,"Variable ART_TOOLBAR is read-only.");
19094 return 1;
19095 }
19096
19097
19098 SWIGINTERN PyObject *ART_TOOLBAR_get(void) {
19099 PyObject *pyobj = 0;
19100
19101 {
19102 #if wxUSE_UNICODE
19103 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
19104 #else
19105 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
19106 #endif
19107 }
19108 return pyobj;
19109 }
19110
19111
19112 SWIGINTERN int ART_MENU_set(PyObject *) {
19113 SWIG_Error(SWIG_AttributeError,"Variable ART_MENU is read-only.");
19114 return 1;
19115 }
19116
19117
19118 SWIGINTERN PyObject *ART_MENU_get(void) {
19119 PyObject *pyobj = 0;
19120
19121 {
19122 #if wxUSE_UNICODE
19123 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
19124 #else
19125 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
19126 #endif
19127 }
19128 return pyobj;
19129 }
19130
19131
19132 SWIGINTERN int ART_FRAME_ICON_set(PyObject *) {
19133 SWIG_Error(SWIG_AttributeError,"Variable ART_FRAME_ICON is read-only.");
19134 return 1;
19135 }
19136
19137
19138 SWIGINTERN PyObject *ART_FRAME_ICON_get(void) {
19139 PyObject *pyobj = 0;
19140
19141 {
19142 #if wxUSE_UNICODE
19143 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
19144 #else
19145 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
19146 #endif
19147 }
19148 return pyobj;
19149 }
19150
19151
19152 SWIGINTERN int ART_CMN_DIALOG_set(PyObject *) {
19153 SWIG_Error(SWIG_AttributeError,"Variable ART_CMN_DIALOG is read-only.");
19154 return 1;
19155 }
19156
19157
19158 SWIGINTERN PyObject *ART_CMN_DIALOG_get(void) {
19159 PyObject *pyobj = 0;
19160
19161 {
19162 #if wxUSE_UNICODE
19163 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
19164 #else
19165 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
19166 #endif
19167 }
19168 return pyobj;
19169 }
19170
19171
19172 SWIGINTERN int ART_HELP_BROWSER_set(PyObject *) {
19173 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BROWSER is read-only.");
19174 return 1;
19175 }
19176
19177
19178 SWIGINTERN PyObject *ART_HELP_BROWSER_get(void) {
19179 PyObject *pyobj = 0;
19180
19181 {
19182 #if wxUSE_UNICODE
19183 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
19184 #else
19185 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
19186 #endif
19187 }
19188 return pyobj;
19189 }
19190
19191
19192 SWIGINTERN int ART_MESSAGE_BOX_set(PyObject *) {
19193 SWIG_Error(SWIG_AttributeError,"Variable ART_MESSAGE_BOX is read-only.");
19194 return 1;
19195 }
19196
19197
19198 SWIGINTERN PyObject *ART_MESSAGE_BOX_get(void) {
19199 PyObject *pyobj = 0;
19200
19201 {
19202 #if wxUSE_UNICODE
19203 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
19204 #else
19205 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
19206 #endif
19207 }
19208 return pyobj;
19209 }
19210
19211
19212 SWIGINTERN int ART_BUTTON_set(PyObject *) {
19213 SWIG_Error(SWIG_AttributeError,"Variable ART_BUTTON is read-only.");
19214 return 1;
19215 }
19216
19217
19218 SWIGINTERN PyObject *ART_BUTTON_get(void) {
19219 PyObject *pyobj = 0;
19220
19221 {
19222 #if wxUSE_UNICODE
19223 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
19224 #else
19225 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
19226 #endif
19227 }
19228 return pyobj;
19229 }
19230
19231
19232 SWIGINTERN int ART_OTHER_set(PyObject *) {
19233 SWIG_Error(SWIG_AttributeError,"Variable ART_OTHER is read-only.");
19234 return 1;
19235 }
19236
19237
19238 SWIGINTERN PyObject *ART_OTHER_get(void) {
19239 PyObject *pyobj = 0;
19240
19241 {
19242 #if wxUSE_UNICODE
19243 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
19244 #else
19245 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
19246 #endif
19247 }
19248 return pyobj;
19249 }
19250
19251
19252 SWIGINTERN int ART_ADD_BOOKMARK_set(PyObject *) {
19253 SWIG_Error(SWIG_AttributeError,"Variable ART_ADD_BOOKMARK is read-only.");
19254 return 1;
19255 }
19256
19257
19258 SWIGINTERN PyObject *ART_ADD_BOOKMARK_get(void) {
19259 PyObject *pyobj = 0;
19260
19261 {
19262 #if wxUSE_UNICODE
19263 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
19264 #else
19265 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
19266 #endif
19267 }
19268 return pyobj;
19269 }
19270
19271
19272 SWIGINTERN int ART_DEL_BOOKMARK_set(PyObject *) {
19273 SWIG_Error(SWIG_AttributeError,"Variable ART_DEL_BOOKMARK is read-only.");
19274 return 1;
19275 }
19276
19277
19278 SWIGINTERN PyObject *ART_DEL_BOOKMARK_get(void) {
19279 PyObject *pyobj = 0;
19280
19281 {
19282 #if wxUSE_UNICODE
19283 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
19284 #else
19285 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
19286 #endif
19287 }
19288 return pyobj;
19289 }
19290
19291
19292 SWIGINTERN int ART_HELP_SIDE_PANEL_set(PyObject *) {
19293 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
19294 return 1;
19295 }
19296
19297
19298 SWIGINTERN PyObject *ART_HELP_SIDE_PANEL_get(void) {
19299 PyObject *pyobj = 0;
19300
19301 {
19302 #if wxUSE_UNICODE
19303 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
19304 #else
19305 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
19306 #endif
19307 }
19308 return pyobj;
19309 }
19310
19311
19312 SWIGINTERN int ART_HELP_SETTINGS_set(PyObject *) {
19313 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SETTINGS is read-only.");
19314 return 1;
19315 }
19316
19317
19318 SWIGINTERN PyObject *ART_HELP_SETTINGS_get(void) {
19319 PyObject *pyobj = 0;
19320
19321 {
19322 #if wxUSE_UNICODE
19323 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
19324 #else
19325 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
19326 #endif
19327 }
19328 return pyobj;
19329 }
19330
19331
19332 SWIGINTERN int ART_HELP_BOOK_set(PyObject *) {
19333 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BOOK is read-only.");
19334 return 1;
19335 }
19336
19337
19338 SWIGINTERN PyObject *ART_HELP_BOOK_get(void) {
19339 PyObject *pyobj = 0;
19340
19341 {
19342 #if wxUSE_UNICODE
19343 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
19344 #else
19345 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
19346 #endif
19347 }
19348 return pyobj;
19349 }
19350
19351
19352 SWIGINTERN int ART_HELP_FOLDER_set(PyObject *) {
19353 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_FOLDER is read-only.");
19354 return 1;
19355 }
19356
19357
19358 SWIGINTERN PyObject *ART_HELP_FOLDER_get(void) {
19359 PyObject *pyobj = 0;
19360
19361 {
19362 #if wxUSE_UNICODE
19363 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
19364 #else
19365 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
19366 #endif
19367 }
19368 return pyobj;
19369 }
19370
19371
19372 SWIGINTERN int ART_HELP_PAGE_set(PyObject *) {
19373 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_PAGE is read-only.");
19374 return 1;
19375 }
19376
19377
19378 SWIGINTERN PyObject *ART_HELP_PAGE_get(void) {
19379 PyObject *pyobj = 0;
19380
19381 {
19382 #if wxUSE_UNICODE
19383 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
19384 #else
19385 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
19386 #endif
19387 }
19388 return pyobj;
19389 }
19390
19391
19392 SWIGINTERN int ART_GO_BACK_set(PyObject *) {
19393 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_BACK is read-only.");
19394 return 1;
19395 }
19396
19397
19398 SWIGINTERN PyObject *ART_GO_BACK_get(void) {
19399 PyObject *pyobj = 0;
19400
19401 {
19402 #if wxUSE_UNICODE
19403 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
19404 #else
19405 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
19406 #endif
19407 }
19408 return pyobj;
19409 }
19410
19411
19412 SWIGINTERN int ART_GO_FORWARD_set(PyObject *) {
19413 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_FORWARD is read-only.");
19414 return 1;
19415 }
19416
19417
19418 SWIGINTERN PyObject *ART_GO_FORWARD_get(void) {
19419 PyObject *pyobj = 0;
19420
19421 {
19422 #if wxUSE_UNICODE
19423 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
19424 #else
19425 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
19426 #endif
19427 }
19428 return pyobj;
19429 }
19430
19431
19432 SWIGINTERN int ART_GO_UP_set(PyObject *) {
19433 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_UP is read-only.");
19434 return 1;
19435 }
19436
19437
19438 SWIGINTERN PyObject *ART_GO_UP_get(void) {
19439 PyObject *pyobj = 0;
19440
19441 {
19442 #if wxUSE_UNICODE
19443 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
19444 #else
19445 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
19446 #endif
19447 }
19448 return pyobj;
19449 }
19450
19451
19452 SWIGINTERN int ART_GO_DOWN_set(PyObject *) {
19453 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DOWN is read-only.");
19454 return 1;
19455 }
19456
19457
19458 SWIGINTERN PyObject *ART_GO_DOWN_get(void) {
19459 PyObject *pyobj = 0;
19460
19461 {
19462 #if wxUSE_UNICODE
19463 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
19464 #else
19465 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
19466 #endif
19467 }
19468 return pyobj;
19469 }
19470
19471
19472 SWIGINTERN int ART_GO_TO_PARENT_set(PyObject *) {
19473 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_TO_PARENT is read-only.");
19474 return 1;
19475 }
19476
19477
19478 SWIGINTERN PyObject *ART_GO_TO_PARENT_get(void) {
19479 PyObject *pyobj = 0;
19480
19481 {
19482 #if wxUSE_UNICODE
19483 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
19484 #else
19485 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
19486 #endif
19487 }
19488 return pyobj;
19489 }
19490
19491
19492 SWIGINTERN int ART_GO_HOME_set(PyObject *) {
19493 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_HOME is read-only.");
19494 return 1;
19495 }
19496
19497
19498 SWIGINTERN PyObject *ART_GO_HOME_get(void) {
19499 PyObject *pyobj = 0;
19500
19501 {
19502 #if wxUSE_UNICODE
19503 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
19504 #else
19505 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
19506 #endif
19507 }
19508 return pyobj;
19509 }
19510
19511
19512 SWIGINTERN int ART_FILE_OPEN_set(PyObject *) {
19513 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_OPEN is read-only.");
19514 return 1;
19515 }
19516
19517
19518 SWIGINTERN PyObject *ART_FILE_OPEN_get(void) {
19519 PyObject *pyobj = 0;
19520
19521 {
19522 #if wxUSE_UNICODE
19523 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
19524 #else
19525 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
19526 #endif
19527 }
19528 return pyobj;
19529 }
19530
19531
19532 SWIGINTERN int ART_FILE_SAVE_set(PyObject *) {
19533 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE is read-only.");
19534 return 1;
19535 }
19536
19537
19538 SWIGINTERN PyObject *ART_FILE_SAVE_get(void) {
19539 PyObject *pyobj = 0;
19540
19541 {
19542 #if wxUSE_UNICODE
19543 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
19544 #else
19545 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
19546 #endif
19547 }
19548 return pyobj;
19549 }
19550
19551
19552 SWIGINTERN int ART_FILE_SAVE_AS_set(PyObject *) {
19553 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE_AS is read-only.");
19554 return 1;
19555 }
19556
19557
19558 SWIGINTERN PyObject *ART_FILE_SAVE_AS_get(void) {
19559 PyObject *pyobj = 0;
19560
19561 {
19562 #if wxUSE_UNICODE
19563 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
19564 #else
19565 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
19566 #endif
19567 }
19568 return pyobj;
19569 }
19570
19571
19572 SWIGINTERN int ART_PRINT_set(PyObject *) {
19573 SWIG_Error(SWIG_AttributeError,"Variable ART_PRINT is read-only.");
19574 return 1;
19575 }
19576
19577
19578 SWIGINTERN PyObject *ART_PRINT_get(void) {
19579 PyObject *pyobj = 0;
19580
19581 {
19582 #if wxUSE_UNICODE
19583 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
19584 #else
19585 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
19586 #endif
19587 }
19588 return pyobj;
19589 }
19590
19591
19592 SWIGINTERN int ART_HELP_set(PyObject *) {
19593 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP is read-only.");
19594 return 1;
19595 }
19596
19597
19598 SWIGINTERN PyObject *ART_HELP_get(void) {
19599 PyObject *pyobj = 0;
19600
19601 {
19602 #if wxUSE_UNICODE
19603 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
19604 #else
19605 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
19606 #endif
19607 }
19608 return pyobj;
19609 }
19610
19611
19612 SWIGINTERN int ART_TIP_set(PyObject *) {
19613 SWIG_Error(SWIG_AttributeError,"Variable ART_TIP is read-only.");
19614 return 1;
19615 }
19616
19617
19618 SWIGINTERN PyObject *ART_TIP_get(void) {
19619 PyObject *pyobj = 0;
19620
19621 {
19622 #if wxUSE_UNICODE
19623 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
19624 #else
19625 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
19626 #endif
19627 }
19628 return pyobj;
19629 }
19630
19631
19632 SWIGINTERN int ART_REPORT_VIEW_set(PyObject *) {
19633 SWIG_Error(SWIG_AttributeError,"Variable ART_REPORT_VIEW is read-only.");
19634 return 1;
19635 }
19636
19637
19638 SWIGINTERN PyObject *ART_REPORT_VIEW_get(void) {
19639 PyObject *pyobj = 0;
19640
19641 {
19642 #if wxUSE_UNICODE
19643 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
19644 #else
19645 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
19646 #endif
19647 }
19648 return pyobj;
19649 }
19650
19651
19652 SWIGINTERN int ART_LIST_VIEW_set(PyObject *) {
19653 SWIG_Error(SWIG_AttributeError,"Variable ART_LIST_VIEW is read-only.");
19654 return 1;
19655 }
19656
19657
19658 SWIGINTERN PyObject *ART_LIST_VIEW_get(void) {
19659 PyObject *pyobj = 0;
19660
19661 {
19662 #if wxUSE_UNICODE
19663 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
19664 #else
19665 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
19666 #endif
19667 }
19668 return pyobj;
19669 }
19670
19671
19672 SWIGINTERN int ART_NEW_DIR_set(PyObject *) {
19673 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW_DIR is read-only.");
19674 return 1;
19675 }
19676
19677
19678 SWIGINTERN PyObject *ART_NEW_DIR_get(void) {
19679 PyObject *pyobj = 0;
19680
19681 {
19682 #if wxUSE_UNICODE
19683 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
19684 #else
19685 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
19686 #endif
19687 }
19688 return pyobj;
19689 }
19690
19691
19692 SWIGINTERN int ART_HARDDISK_set(PyObject *) {
19693 SWIG_Error(SWIG_AttributeError,"Variable ART_HARDDISK is read-only.");
19694 return 1;
19695 }
19696
19697
19698 SWIGINTERN PyObject *ART_HARDDISK_get(void) {
19699 PyObject *pyobj = 0;
19700
19701 {
19702 #if wxUSE_UNICODE
19703 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
19704 #else
19705 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
19706 #endif
19707 }
19708 return pyobj;
19709 }
19710
19711
19712 SWIGINTERN int ART_FLOPPY_set(PyObject *) {
19713 SWIG_Error(SWIG_AttributeError,"Variable ART_FLOPPY is read-only.");
19714 return 1;
19715 }
19716
19717
19718 SWIGINTERN PyObject *ART_FLOPPY_get(void) {
19719 PyObject *pyobj = 0;
19720
19721 {
19722 #if wxUSE_UNICODE
19723 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
19724 #else
19725 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
19726 #endif
19727 }
19728 return pyobj;
19729 }
19730
19731
19732 SWIGINTERN int ART_CDROM_set(PyObject *) {
19733 SWIG_Error(SWIG_AttributeError,"Variable ART_CDROM is read-only.");
19734 return 1;
19735 }
19736
19737
19738 SWIGINTERN PyObject *ART_CDROM_get(void) {
19739 PyObject *pyobj = 0;
19740
19741 {
19742 #if wxUSE_UNICODE
19743 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
19744 #else
19745 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
19746 #endif
19747 }
19748 return pyobj;
19749 }
19750
19751
19752 SWIGINTERN int ART_REMOVABLE_set(PyObject *) {
19753 SWIG_Error(SWIG_AttributeError,"Variable ART_REMOVABLE is read-only.");
19754 return 1;
19755 }
19756
19757
19758 SWIGINTERN PyObject *ART_REMOVABLE_get(void) {
19759 PyObject *pyobj = 0;
19760
19761 {
19762 #if wxUSE_UNICODE
19763 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
19764 #else
19765 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
19766 #endif
19767 }
19768 return pyobj;
19769 }
19770
19771
19772 SWIGINTERN int ART_FOLDER_set(PyObject *) {
19773 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER is read-only.");
19774 return 1;
19775 }
19776
19777
19778 SWIGINTERN PyObject *ART_FOLDER_get(void) {
19779 PyObject *pyobj = 0;
19780
19781 {
19782 #if wxUSE_UNICODE
19783 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
19784 #else
19785 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
19786 #endif
19787 }
19788 return pyobj;
19789 }
19790
19791
19792 SWIGINTERN int ART_FOLDER_OPEN_set(PyObject *) {
19793 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER_OPEN is read-only.");
19794 return 1;
19795 }
19796
19797
19798 SWIGINTERN PyObject *ART_FOLDER_OPEN_get(void) {
19799 PyObject *pyobj = 0;
19800
19801 {
19802 #if wxUSE_UNICODE
19803 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
19804 #else
19805 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
19806 #endif
19807 }
19808 return pyobj;
19809 }
19810
19811
19812 SWIGINTERN int ART_GO_DIR_UP_set(PyObject *) {
19813 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DIR_UP is read-only.");
19814 return 1;
19815 }
19816
19817
19818 SWIGINTERN PyObject *ART_GO_DIR_UP_get(void) {
19819 PyObject *pyobj = 0;
19820
19821 {
19822 #if wxUSE_UNICODE
19823 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
19824 #else
19825 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
19826 #endif
19827 }
19828 return pyobj;
19829 }
19830
19831
19832 SWIGINTERN int ART_EXECUTABLE_FILE_set(PyObject *) {
19833 SWIG_Error(SWIG_AttributeError,"Variable ART_EXECUTABLE_FILE is read-only.");
19834 return 1;
19835 }
19836
19837
19838 SWIGINTERN PyObject *ART_EXECUTABLE_FILE_get(void) {
19839 PyObject *pyobj = 0;
19840
19841 {
19842 #if wxUSE_UNICODE
19843 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
19844 #else
19845 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
19846 #endif
19847 }
19848 return pyobj;
19849 }
19850
19851
19852 SWIGINTERN int ART_NORMAL_FILE_set(PyObject *) {
19853 SWIG_Error(SWIG_AttributeError,"Variable ART_NORMAL_FILE is read-only.");
19854 return 1;
19855 }
19856
19857
19858 SWIGINTERN PyObject *ART_NORMAL_FILE_get(void) {
19859 PyObject *pyobj = 0;
19860
19861 {
19862 #if wxUSE_UNICODE
19863 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
19864 #else
19865 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
19866 #endif
19867 }
19868 return pyobj;
19869 }
19870
19871
19872 SWIGINTERN int ART_TICK_MARK_set(PyObject *) {
19873 SWIG_Error(SWIG_AttributeError,"Variable ART_TICK_MARK is read-only.");
19874 return 1;
19875 }
19876
19877
19878 SWIGINTERN PyObject *ART_TICK_MARK_get(void) {
19879 PyObject *pyobj = 0;
19880
19881 {
19882 #if wxUSE_UNICODE
19883 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
19884 #else
19885 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
19886 #endif
19887 }
19888 return pyobj;
19889 }
19890
19891
19892 SWIGINTERN int ART_CROSS_MARK_set(PyObject *) {
19893 SWIG_Error(SWIG_AttributeError,"Variable ART_CROSS_MARK is read-only.");
19894 return 1;
19895 }
19896
19897
19898 SWIGINTERN PyObject *ART_CROSS_MARK_get(void) {
19899 PyObject *pyobj = 0;
19900
19901 {
19902 #if wxUSE_UNICODE
19903 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
19904 #else
19905 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
19906 #endif
19907 }
19908 return pyobj;
19909 }
19910
19911
19912 SWIGINTERN int ART_ERROR_set(PyObject *) {
19913 SWIG_Error(SWIG_AttributeError,"Variable ART_ERROR is read-only.");
19914 return 1;
19915 }
19916
19917
19918 SWIGINTERN PyObject *ART_ERROR_get(void) {
19919 PyObject *pyobj = 0;
19920
19921 {
19922 #if wxUSE_UNICODE
19923 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
19924 #else
19925 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
19926 #endif
19927 }
19928 return pyobj;
19929 }
19930
19931
19932 SWIGINTERN int ART_QUESTION_set(PyObject *) {
19933 SWIG_Error(SWIG_AttributeError,"Variable ART_QUESTION is read-only.");
19934 return 1;
19935 }
19936
19937
19938 SWIGINTERN PyObject *ART_QUESTION_get(void) {
19939 PyObject *pyobj = 0;
19940
19941 {
19942 #if wxUSE_UNICODE
19943 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
19944 #else
19945 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
19946 #endif
19947 }
19948 return pyobj;
19949 }
19950
19951
19952 SWIGINTERN int ART_WARNING_set(PyObject *) {
19953 SWIG_Error(SWIG_AttributeError,"Variable ART_WARNING is read-only.");
19954 return 1;
19955 }
19956
19957
19958 SWIGINTERN PyObject *ART_WARNING_get(void) {
19959 PyObject *pyobj = 0;
19960
19961 {
19962 #if wxUSE_UNICODE
19963 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
19964 #else
19965 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
19966 #endif
19967 }
19968 return pyobj;
19969 }
19970
19971
19972 SWIGINTERN int ART_INFORMATION_set(PyObject *) {
19973 SWIG_Error(SWIG_AttributeError,"Variable ART_INFORMATION is read-only.");
19974 return 1;
19975 }
19976
19977
19978 SWIGINTERN PyObject *ART_INFORMATION_get(void) {
19979 PyObject *pyobj = 0;
19980
19981 {
19982 #if wxUSE_UNICODE
19983 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
19984 #else
19985 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
19986 #endif
19987 }
19988 return pyobj;
19989 }
19990
19991
19992 SWIGINTERN int ART_MISSING_IMAGE_set(PyObject *) {
19993 SWIG_Error(SWIG_AttributeError,"Variable ART_MISSING_IMAGE is read-only.");
19994 return 1;
19995 }
19996
19997
19998 SWIGINTERN PyObject *ART_MISSING_IMAGE_get(void) {
19999 PyObject *pyobj = 0;
20000
20001 {
20002 #if wxUSE_UNICODE
20003 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
20004 #else
20005 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
20006 #endif
20007 }
20008 return pyobj;
20009 }
20010
20011
20012 SWIGINTERN int ART_COPY_set(PyObject *) {
20013 SWIG_Error(SWIG_AttributeError,"Variable ART_COPY is read-only.");
20014 return 1;
20015 }
20016
20017
20018 SWIGINTERN PyObject *ART_COPY_get(void) {
20019 PyObject *pyobj = 0;
20020
20021 {
20022 #if wxUSE_UNICODE
20023 pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
20024 #else
20025 pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
20026 #endif
20027 }
20028 return pyobj;
20029 }
20030
20031
20032 SWIGINTERN int ART_CUT_set(PyObject *) {
20033 SWIG_Error(SWIG_AttributeError,"Variable ART_CUT is read-only.");
20034 return 1;
20035 }
20036
20037
20038 SWIGINTERN PyObject *ART_CUT_get(void) {
20039 PyObject *pyobj = 0;
20040
20041 {
20042 #if wxUSE_UNICODE
20043 pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
20044 #else
20045 pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
20046 #endif
20047 }
20048 return pyobj;
20049 }
20050
20051
20052 SWIGINTERN int ART_PASTE_set(PyObject *) {
20053 SWIG_Error(SWIG_AttributeError,"Variable ART_PASTE is read-only.");
20054 return 1;
20055 }
20056
20057
20058 SWIGINTERN PyObject *ART_PASTE_get(void) {
20059 PyObject *pyobj = 0;
20060
20061 {
20062 #if wxUSE_UNICODE
20063 pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
20064 #else
20065 pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
20066 #endif
20067 }
20068 return pyobj;
20069 }
20070
20071
20072 SWIGINTERN int ART_DELETE_set(PyObject *) {
20073 SWIG_Error(SWIG_AttributeError,"Variable ART_DELETE is read-only.");
20074 return 1;
20075 }
20076
20077
20078 SWIGINTERN PyObject *ART_DELETE_get(void) {
20079 PyObject *pyobj = 0;
20080
20081 {
20082 #if wxUSE_UNICODE
20083 pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
20084 #else
20085 pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
20086 #endif
20087 }
20088 return pyobj;
20089 }
20090
20091
20092 SWIGINTERN int ART_NEW_set(PyObject *) {
20093 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW is read-only.");
20094 return 1;
20095 }
20096
20097
20098 SWIGINTERN PyObject *ART_NEW_get(void) {
20099 PyObject *pyobj = 0;
20100
20101 {
20102 #if wxUSE_UNICODE
20103 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
20104 #else
20105 pyobj = PyString_FromStringAndSize((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
20106 #endif
20107 }
20108 return pyobj;
20109 }
20110
20111
20112 SWIGINTERN int ART_UNDO_set(PyObject *) {
20113 SWIG_Error(SWIG_AttributeError,"Variable ART_UNDO is read-only.");
20114 return 1;
20115 }
20116
20117
20118 SWIGINTERN PyObject *ART_UNDO_get(void) {
20119 PyObject *pyobj = 0;
20120
20121 {
20122 #if wxUSE_UNICODE
20123 pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
20124 #else
20125 pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
20126 #endif
20127 }
20128 return pyobj;
20129 }
20130
20131
20132 SWIGINTERN int ART_REDO_set(PyObject *) {
20133 SWIG_Error(SWIG_AttributeError,"Variable ART_REDO is read-only.");
20134 return 1;
20135 }
20136
20137
20138 SWIGINTERN PyObject *ART_REDO_get(void) {
20139 PyObject *pyobj = 0;
20140
20141 {
20142 #if wxUSE_UNICODE
20143 pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
20144 #else
20145 pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
20146 #endif
20147 }
20148 return pyobj;
20149 }
20150
20151
20152 SWIGINTERN int ART_QUIT_set(PyObject *) {
20153 SWIG_Error(SWIG_AttributeError,"Variable ART_QUIT is read-only.");
20154 return 1;
20155 }
20156
20157
20158 SWIGINTERN PyObject *ART_QUIT_get(void) {
20159 PyObject *pyobj = 0;
20160
20161 {
20162 #if wxUSE_UNICODE
20163 pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
20164 #else
20165 pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
20166 #endif
20167 }
20168 return pyobj;
20169 }
20170
20171
20172 SWIGINTERN int ART_FIND_set(PyObject *) {
20173 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND is read-only.");
20174 return 1;
20175 }
20176
20177
20178 SWIGINTERN PyObject *ART_FIND_get(void) {
20179 PyObject *pyobj = 0;
20180
20181 {
20182 #if wxUSE_UNICODE
20183 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
20184 #else
20185 pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
20186 #endif
20187 }
20188 return pyobj;
20189 }
20190
20191
20192 SWIGINTERN int ART_FIND_AND_REPLACE_set(PyObject *) {
20193 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND_AND_REPLACE is read-only.");
20194 return 1;
20195 }
20196
20197
20198 SWIGINTERN PyObject *ART_FIND_AND_REPLACE_get(void) {
20199 PyObject *pyobj = 0;
20200
20201 {
20202 #if wxUSE_UNICODE
20203 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
20204 #else
20205 pyobj = PyString_FromStringAndSize((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
20206 #endif
20207 }
20208 return pyobj;
20209 }
20210
20211
20212 SWIGINTERN PyObject *_wrap_new_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20213 PyObject *resultobj = 0;
20214 wxPyArtProvider *result = 0 ;
20215
20216 if (!SWIG_Python_UnpackTuple(args,"new_ArtProvider",0,0,0)) SWIG_fail;
20217 {
20218 if (!wxPyCheckForApp()) SWIG_fail;
20219 PyThreadState* __tstate = wxPyBeginAllowThreads();
20220 result = (wxPyArtProvider *)new wxPyArtProvider();
20221 wxPyEndAllowThreads(__tstate);
20222 if (PyErr_Occurred()) SWIG_fail;
20223 }
20224 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_NEW | 0 );
20225 return resultobj;
20226 fail:
20227 return NULL;
20228 }
20229
20230
20231 SWIGINTERN PyObject *_wrap_delete_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20232 PyObject *resultobj = 0;
20233 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20234 void *argp1 = 0 ;
20235 int res1 = 0 ;
20236 PyObject *swig_obj[1] ;
20237
20238 if (!args) SWIG_fail;
20239 swig_obj[0] = args;
20240 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
20241 if (!SWIG_IsOK(res1)) {
20242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArtProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20243 }
20244 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20245 {
20246 PyThreadState* __tstate = wxPyBeginAllowThreads();
20247 delete arg1;
20248
20249 wxPyEndAllowThreads(__tstate);
20250 if (PyErr_Occurred()) SWIG_fail;
20251 }
20252 resultobj = SWIG_Py_Void();
20253 return resultobj;
20254 fail:
20255 return NULL;
20256 }
20257
20258
20259 SWIGINTERN PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20260 PyObject *resultobj = 0;
20261 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20262 PyObject *arg2 = (PyObject *) 0 ;
20263 PyObject *arg3 = (PyObject *) 0 ;
20264 void *argp1 = 0 ;
20265 int res1 = 0 ;
20266 PyObject * obj0 = 0 ;
20267 PyObject * obj1 = 0 ;
20268 PyObject * obj2 = 0 ;
20269 char * kwnames[] = {
20270 (char *) "self",(char *) "self",(char *) "_class", NULL
20271 };
20272
20273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20274 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20275 if (!SWIG_IsOK(res1)) {
20276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20277 }
20278 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20279 arg2 = obj1;
20280 arg3 = obj2;
20281 {
20282 PyThreadState* __tstate = wxPyBeginAllowThreads();
20283 (arg1)->_setCallbackInfo(arg2,arg3);
20284 wxPyEndAllowThreads(__tstate);
20285 if (PyErr_Occurred()) SWIG_fail;
20286 }
20287 resultobj = SWIG_Py_Void();
20288 return resultobj;
20289 fail:
20290 return NULL;
20291 }
20292
20293
20294 SWIGINTERN PyObject *_wrap_ArtProvider_PushProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20295 PyObject *resultobj = 0;
20296 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20297 int res1 = 0 ;
20298 PyObject * obj0 = 0 ;
20299 char * kwnames[] = {
20300 (char *) "provider", NULL
20301 };
20302
20303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_PushProvider",kwnames,&obj0)) SWIG_fail;
20304 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
20305 if (!SWIG_IsOK(res1)) {
20306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_PushProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20307 }
20308 {
20309 PyThreadState* __tstate = wxPyBeginAllowThreads();
20310 wxPyArtProvider::PushProvider(arg1);
20311 wxPyEndAllowThreads(__tstate);
20312 if (PyErr_Occurred()) SWIG_fail;
20313 }
20314 resultobj = SWIG_Py_Void();
20315 return resultobj;
20316 fail:
20317 return NULL;
20318 }
20319
20320
20321 SWIGINTERN PyObject *_wrap_ArtProvider_InsertProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20322 PyObject *resultobj = 0;
20323 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20324 int res1 = 0 ;
20325 PyObject * obj0 = 0 ;
20326 char * kwnames[] = {
20327 (char *) "provider", NULL
20328 };
20329
20330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_InsertProvider",kwnames,&obj0)) SWIG_fail;
20331 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
20332 if (!SWIG_IsOK(res1)) {
20333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_InsertProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20334 }
20335 {
20336 PyThreadState* __tstate = wxPyBeginAllowThreads();
20337 wxPyArtProvider::InsertProvider(arg1);
20338 wxPyEndAllowThreads(__tstate);
20339 if (PyErr_Occurred()) SWIG_fail;
20340 }
20341 resultobj = SWIG_Py_Void();
20342 return resultobj;
20343 fail:
20344 return NULL;
20345 }
20346
20347
20348 SWIGINTERN PyObject *_wrap_ArtProvider_PopProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20349 PyObject *resultobj = 0;
20350 bool result;
20351
20352 if (!SWIG_Python_UnpackTuple(args,"ArtProvider_PopProvider",0,0,0)) SWIG_fail;
20353 {
20354 PyThreadState* __tstate = wxPyBeginAllowThreads();
20355 result = (bool)wxPyArtProvider::PopProvider();
20356 wxPyEndAllowThreads(__tstate);
20357 if (PyErr_Occurred()) SWIG_fail;
20358 }
20359 {
20360 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20361 }
20362 return resultobj;
20363 fail:
20364 return NULL;
20365 }
20366
20367
20368 SWIGINTERN PyObject *_wrap_ArtProvider_RemoveProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20369 PyObject *resultobj = 0;
20370 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20371 bool result;
20372 void *argp1 = 0 ;
20373 int res1 = 0 ;
20374 PyObject * obj0 = 0 ;
20375 char * kwnames[] = {
20376 (char *) "provider", NULL
20377 };
20378
20379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_RemoveProvider",kwnames,&obj0)) SWIG_fail;
20380 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20381 if (!SWIG_IsOK(res1)) {
20382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_RemoveProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20383 }
20384 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20385 {
20386 PyThreadState* __tstate = wxPyBeginAllowThreads();
20387 result = (bool)wxPyArtProvider::RemoveProvider(arg1);
20388 wxPyEndAllowThreads(__tstate);
20389 if (PyErr_Occurred()) SWIG_fail;
20390 }
20391 {
20392 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20393 }
20394 return resultobj;
20395 fail:
20396 return NULL;
20397 }
20398
20399
20400 SWIGINTERN PyObject *_wrap_ArtProvider_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20401 PyObject *resultobj = 0;
20402 wxString *arg1 = 0 ;
20403 wxString const &arg2_defvalue = wxPyART_OTHER ;
20404 wxString *arg2 = (wxString *) &arg2_defvalue ;
20405 wxSize const &arg3_defvalue = wxDefaultSize ;
20406 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
20407 wxBitmap result;
20408 bool temp1 = false ;
20409 bool temp2 = false ;
20410 wxSize temp3 ;
20411 PyObject * obj0 = 0 ;
20412 PyObject * obj1 = 0 ;
20413 PyObject * obj2 = 0 ;
20414 char * kwnames[] = {
20415 (char *) "id",(char *) "client",(char *) "size", NULL
20416 };
20417
20418 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20419 {
20420 arg1 = wxString_in_helper(obj0);
20421 if (arg1 == NULL) SWIG_fail;
20422 temp1 = true;
20423 }
20424 if (obj1) {
20425 {
20426 arg2 = wxString_in_helper(obj1);
20427 if (arg2 == NULL) SWIG_fail;
20428 temp2 = true;
20429 }
20430 }
20431 if (obj2) {
20432 {
20433 arg3 = &temp3;
20434 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
20435 }
20436 }
20437 {
20438 if (!wxPyCheckForApp()) SWIG_fail;
20439 PyThreadState* __tstate = wxPyBeginAllowThreads();
20440 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
20441 wxPyEndAllowThreads(__tstate);
20442 if (PyErr_Occurred()) SWIG_fail;
20443 }
20444 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
20445 {
20446 if (temp1)
20447 delete arg1;
20448 }
20449 {
20450 if (temp2)
20451 delete arg2;
20452 }
20453 return resultobj;
20454 fail:
20455 {
20456 if (temp1)
20457 delete arg1;
20458 }
20459 {
20460 if (temp2)
20461 delete arg2;
20462 }
20463 return NULL;
20464 }
20465
20466
20467 SWIGINTERN PyObject *_wrap_ArtProvider_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20468 PyObject *resultobj = 0;
20469 wxString *arg1 = 0 ;
20470 wxString const &arg2_defvalue = wxPyART_OTHER ;
20471 wxString *arg2 = (wxString *) &arg2_defvalue ;
20472 wxSize const &arg3_defvalue = wxDefaultSize ;
20473 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
20474 wxIcon result;
20475 bool temp1 = false ;
20476 bool temp2 = false ;
20477 wxSize temp3 ;
20478 PyObject * obj0 = 0 ;
20479 PyObject * obj1 = 0 ;
20480 PyObject * obj2 = 0 ;
20481 char * kwnames[] = {
20482 (char *) "id",(char *) "client",(char *) "size", NULL
20483 };
20484
20485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20486 {
20487 arg1 = wxString_in_helper(obj0);
20488 if (arg1 == NULL) SWIG_fail;
20489 temp1 = true;
20490 }
20491 if (obj1) {
20492 {
20493 arg2 = wxString_in_helper(obj1);
20494 if (arg2 == NULL) SWIG_fail;
20495 temp2 = true;
20496 }
20497 }
20498 if (obj2) {
20499 {
20500 arg3 = &temp3;
20501 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
20502 }
20503 }
20504 {
20505 if (!wxPyCheckForApp()) SWIG_fail;
20506 PyThreadState* __tstate = wxPyBeginAllowThreads();
20507 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
20508 wxPyEndAllowThreads(__tstate);
20509 if (PyErr_Occurred()) SWIG_fail;
20510 }
20511 resultobj = SWIG_NewPointerObj((new wxIcon(static_cast< const wxIcon& >(result))), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
20512 {
20513 if (temp1)
20514 delete arg1;
20515 }
20516 {
20517 if (temp2)
20518 delete arg2;
20519 }
20520 return resultobj;
20521 fail:
20522 {
20523 if (temp1)
20524 delete arg1;
20525 }
20526 {
20527 if (temp2)
20528 delete arg2;
20529 }
20530 return NULL;
20531 }
20532
20533
20534 SWIGINTERN PyObject *_wrap_ArtProvider_GetSizeHint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20535 PyObject *resultobj = 0;
20536 wxString *arg1 = 0 ;
20537 bool arg2 = (bool) false ;
20538 wxSize result;
20539 bool temp1 = false ;
20540 bool val2 ;
20541 int ecode2 = 0 ;
20542 PyObject * obj0 = 0 ;
20543 PyObject * obj1 = 0 ;
20544 char * kwnames[] = {
20545 (char *) "client",(char *) "platform_dependent", NULL
20546 };
20547
20548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ArtProvider_GetSizeHint",kwnames,&obj0,&obj1)) SWIG_fail;
20549 {
20550 arg1 = wxString_in_helper(obj0);
20551 if (arg1 == NULL) SWIG_fail;
20552 temp1 = true;
20553 }
20554 if (obj1) {
20555 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20556 if (!SWIG_IsOK(ecode2)) {
20557 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ArtProvider_GetSizeHint" "', expected argument " "2"" of type '" "bool""'");
20558 }
20559 arg2 = static_cast< bool >(val2);
20560 }
20561 {
20562 PyThreadState* __tstate = wxPyBeginAllowThreads();
20563 result = wxPyArtProvider::GetSizeHint((wxString const &)*arg1,arg2);
20564 wxPyEndAllowThreads(__tstate);
20565 if (PyErr_Occurred()) SWIG_fail;
20566 }
20567 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
20568 {
20569 if (temp1)
20570 delete arg1;
20571 }
20572 return resultobj;
20573 fail:
20574 {
20575 if (temp1)
20576 delete arg1;
20577 }
20578 return NULL;
20579 }
20580
20581
20582 SWIGINTERN PyObject *_wrap_ArtProvider_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20583 PyObject *resultobj = 0;
20584 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20585 void *argp1 = 0 ;
20586 int res1 = 0 ;
20587 PyObject *swig_obj[1] ;
20588
20589 if (!args) SWIG_fail;
20590 swig_obj[0] = args;
20591 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20592 if (!SWIG_IsOK(res1)) {
20593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Destroy" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20594 }
20595 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20596 {
20597 PyThreadState* __tstate = wxPyBeginAllowThreads();
20598 wxPyArtProvider_Destroy(arg1);
20599 wxPyEndAllowThreads(__tstate);
20600 if (PyErr_Occurred()) SWIG_fail;
20601 }
20602 resultobj = SWIG_Py_Void();
20603 return resultobj;
20604 fail:
20605 return NULL;
20606 }
20607
20608
20609 SWIGINTERN PyObject *ArtProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20610 PyObject *obj;
20611 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20612 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyArtProvider, SWIG_NewClientData(obj));
20613 return SWIG_Py_Void();
20614 }
20615
20616 SWIGINTERN PyObject *ArtProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20617 return SWIG_Python_InitShadowInstance(args);
20618 }
20619
20620 SWIGINTERN PyObject *_wrap_delete_ConfigBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20621 PyObject *resultobj = 0;
20622 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20623 void *argp1 = 0 ;
20624 int res1 = 0 ;
20625 PyObject *swig_obj[1] ;
20626
20627 if (!args) SWIG_fail;
20628 swig_obj[0] = args;
20629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
20630 if (!SWIG_IsOK(res1)) {
20631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigBase" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20632 }
20633 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20634 {
20635 PyThreadState* __tstate = wxPyBeginAllowThreads();
20636 delete arg1;
20637
20638 wxPyEndAllowThreads(__tstate);
20639 if (PyErr_Occurred()) SWIG_fail;
20640 }
20641 resultobj = SWIG_Py_Void();
20642 return resultobj;
20643 fail:
20644 return NULL;
20645 }
20646
20647
20648 SWIGINTERN PyObject *_wrap_ConfigBase_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20649 PyObject *resultobj = 0;
20650 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20651 wxConfigBase *result = 0 ;
20652 int res1 = 0 ;
20653 PyObject * obj0 = 0 ;
20654 char * kwnames[] = {
20655 (char *) "config", NULL
20656 };
20657
20658 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) SWIG_fail;
20659 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
20660 if (!SWIG_IsOK(res1)) {
20661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Set" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20662 }
20663 {
20664 PyThreadState* __tstate = wxPyBeginAllowThreads();
20665 result = (wxConfigBase *)wxConfigBase::Set(arg1);
20666 wxPyEndAllowThreads(__tstate);
20667 if (PyErr_Occurred()) SWIG_fail;
20668 }
20669 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
20670 return resultobj;
20671 fail:
20672 return NULL;
20673 }
20674
20675
20676 SWIGINTERN PyObject *_wrap_ConfigBase_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20677 PyObject *resultobj = 0;
20678 bool arg1 = (bool) true ;
20679 wxConfigBase *result = 0 ;
20680 bool val1 ;
20681 int ecode1 = 0 ;
20682 PyObject * obj0 = 0 ;
20683 char * kwnames[] = {
20684 (char *) "createOnDemand", NULL
20685 };
20686
20687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) SWIG_fail;
20688 if (obj0) {
20689 ecode1 = SWIG_AsVal_bool(obj0, &val1);
20690 if (!SWIG_IsOK(ecode1)) {
20691 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ConfigBase_Get" "', expected argument " "1"" of type '" "bool""'");
20692 }
20693 arg1 = static_cast< bool >(val1);
20694 }
20695 {
20696 PyThreadState* __tstate = wxPyBeginAllowThreads();
20697 result = (wxConfigBase *)wxConfigBase::Get(arg1);
20698 wxPyEndAllowThreads(__tstate);
20699 if (PyErr_Occurred()) SWIG_fail;
20700 }
20701 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
20702 return resultobj;
20703 fail:
20704 return NULL;
20705 }
20706
20707
20708 SWIGINTERN PyObject *_wrap_ConfigBase_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20709 PyObject *resultobj = 0;
20710 wxConfigBase *result = 0 ;
20711
20712 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_Create",0,0,0)) SWIG_fail;
20713 {
20714 PyThreadState* __tstate = wxPyBeginAllowThreads();
20715 result = (wxConfigBase *)wxConfigBase::Create();
20716 wxPyEndAllowThreads(__tstate);
20717 if (PyErr_Occurred()) SWIG_fail;
20718 }
20719 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
20720 return resultobj;
20721 fail:
20722 return NULL;
20723 }
20724
20725
20726 SWIGINTERN PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20727 PyObject *resultobj = 0;
20728
20729 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_DontCreateOnDemand",0,0,0)) SWIG_fail;
20730 {
20731 PyThreadState* __tstate = wxPyBeginAllowThreads();
20732 wxConfigBase::DontCreateOnDemand();
20733 wxPyEndAllowThreads(__tstate);
20734 if (PyErr_Occurred()) SWIG_fail;
20735 }
20736 resultobj = SWIG_Py_Void();
20737 return resultobj;
20738 fail:
20739 return NULL;
20740 }
20741
20742
20743 SWIGINTERN PyObject *_wrap_ConfigBase_SetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20744 PyObject *resultobj = 0;
20745 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20746 wxString *arg2 = 0 ;
20747 void *argp1 = 0 ;
20748 int res1 = 0 ;
20749 bool temp2 = false ;
20750 PyObject * obj0 = 0 ;
20751 PyObject * obj1 = 0 ;
20752 char * kwnames[] = {
20753 (char *) "self",(char *) "path", NULL
20754 };
20755
20756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) SWIG_fail;
20757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20758 if (!SWIG_IsOK(res1)) {
20759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetPath" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20760 }
20761 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20762 {
20763 arg2 = wxString_in_helper(obj1);
20764 if (arg2 == NULL) SWIG_fail;
20765 temp2 = true;
20766 }
20767 {
20768 PyThreadState* __tstate = wxPyBeginAllowThreads();
20769 (arg1)->SetPath((wxString const &)*arg2);
20770 wxPyEndAllowThreads(__tstate);
20771 if (PyErr_Occurred()) SWIG_fail;
20772 }
20773 resultobj = SWIG_Py_Void();
20774 {
20775 if (temp2)
20776 delete arg2;
20777 }
20778 return resultobj;
20779 fail:
20780 {
20781 if (temp2)
20782 delete arg2;
20783 }
20784 return NULL;
20785 }
20786
20787
20788 SWIGINTERN PyObject *_wrap_ConfigBase_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20789 PyObject *resultobj = 0;
20790 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20791 wxString *result = 0 ;
20792 void *argp1 = 0 ;
20793 int res1 = 0 ;
20794 PyObject *swig_obj[1] ;
20795
20796 if (!args) SWIG_fail;
20797 swig_obj[0] = args;
20798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20799 if (!SWIG_IsOK(res1)) {
20800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetPath" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20801 }
20802 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20803 {
20804 PyThreadState* __tstate = wxPyBeginAllowThreads();
20805 {
20806 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
20807 result = (wxString *) &_result_ref;
20808 }
20809 wxPyEndAllowThreads(__tstate);
20810 if (PyErr_Occurred()) SWIG_fail;
20811 }
20812 {
20813 #if wxUSE_UNICODE
20814 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
20815 #else
20816 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
20817 #endif
20818 }
20819 return resultobj;
20820 fail:
20821 return NULL;
20822 }
20823
20824
20825 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20826 PyObject *resultobj = 0;
20827 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20828 PyObject *result = 0 ;
20829 void *argp1 = 0 ;
20830 int res1 = 0 ;
20831 PyObject *swig_obj[1] ;
20832
20833 if (!args) SWIG_fail;
20834 swig_obj[0] = args;
20835 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20836 if (!SWIG_IsOK(res1)) {
20837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20838 }
20839 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20840 {
20841 PyThreadState* __tstate = wxPyBeginAllowThreads();
20842 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
20843 wxPyEndAllowThreads(__tstate);
20844 if (PyErr_Occurred()) SWIG_fail;
20845 }
20846 resultobj = result;
20847 return resultobj;
20848 fail:
20849 return NULL;
20850 }
20851
20852
20853 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20854 PyObject *resultobj = 0;
20855 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20856 long arg2 ;
20857 PyObject *result = 0 ;
20858 void *argp1 = 0 ;
20859 int res1 = 0 ;
20860 long val2 ;
20861 int ecode2 = 0 ;
20862 PyObject * obj0 = 0 ;
20863 PyObject * obj1 = 0 ;
20864 char * kwnames[] = {
20865 (char *) "self",(char *) "index", NULL
20866 };
20867
20868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) SWIG_fail;
20869 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20870 if (!SWIG_IsOK(res1)) {
20871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20872 }
20873 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20874 ecode2 = SWIG_AsVal_long(obj1, &val2);
20875 if (!SWIG_IsOK(ecode2)) {
20876 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "2"" of type '" "long""'");
20877 }
20878 arg2 = static_cast< long >(val2);
20879 {
20880 PyThreadState* __tstate = wxPyBeginAllowThreads();
20881 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
20882 wxPyEndAllowThreads(__tstate);
20883 if (PyErr_Occurred()) SWIG_fail;
20884 }
20885 resultobj = result;
20886 return resultobj;
20887 fail:
20888 return NULL;
20889 }
20890
20891
20892 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20893 PyObject *resultobj = 0;
20894 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20895 PyObject *result = 0 ;
20896 void *argp1 = 0 ;
20897 int res1 = 0 ;
20898 PyObject *swig_obj[1] ;
20899
20900 if (!args) SWIG_fail;
20901 swig_obj[0] = args;
20902 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20903 if (!SWIG_IsOK(res1)) {
20904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20905 }
20906 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20907 {
20908 PyThreadState* __tstate = wxPyBeginAllowThreads();
20909 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
20910 wxPyEndAllowThreads(__tstate);
20911 if (PyErr_Occurred()) SWIG_fail;
20912 }
20913 resultobj = result;
20914 return resultobj;
20915 fail:
20916 return NULL;
20917 }
20918
20919
20920 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20921 PyObject *resultobj = 0;
20922 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20923 long arg2 ;
20924 PyObject *result = 0 ;
20925 void *argp1 = 0 ;
20926 int res1 = 0 ;
20927 long val2 ;
20928 int ecode2 = 0 ;
20929 PyObject * obj0 = 0 ;
20930 PyObject * obj1 = 0 ;
20931 char * kwnames[] = {
20932 (char *) "self",(char *) "index", NULL
20933 };
20934
20935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) SWIG_fail;
20936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20937 if (!SWIG_IsOK(res1)) {
20938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20939 }
20940 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20941 ecode2 = SWIG_AsVal_long(obj1, &val2);
20942 if (!SWIG_IsOK(ecode2)) {
20943 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "2"" of type '" "long""'");
20944 }
20945 arg2 = static_cast< long >(val2);
20946 {
20947 PyThreadState* __tstate = wxPyBeginAllowThreads();
20948 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
20949 wxPyEndAllowThreads(__tstate);
20950 if (PyErr_Occurred()) SWIG_fail;
20951 }
20952 resultobj = result;
20953 return resultobj;
20954 fail:
20955 return NULL;
20956 }
20957
20958
20959 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20960 PyObject *resultobj = 0;
20961 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20962 bool arg2 = (bool) false ;
20963 size_t result;
20964 void *argp1 = 0 ;
20965 int res1 = 0 ;
20966 bool val2 ;
20967 int ecode2 = 0 ;
20968 PyObject * obj0 = 0 ;
20969 PyObject * obj1 = 0 ;
20970 char * kwnames[] = {
20971 (char *) "self",(char *) "recursive", NULL
20972 };
20973
20974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) SWIG_fail;
20975 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20976 if (!SWIG_IsOK(res1)) {
20977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20978 }
20979 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20980 if (obj1) {
20981 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20982 if (!SWIG_IsOK(ecode2)) {
20983 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "2"" of type '" "bool""'");
20984 }
20985 arg2 = static_cast< bool >(val2);
20986 }
20987 {
20988 PyThreadState* __tstate = wxPyBeginAllowThreads();
20989 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
20990 wxPyEndAllowThreads(__tstate);
20991 if (PyErr_Occurred()) SWIG_fail;
20992 }
20993 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
20994 return resultobj;
20995 fail:
20996 return NULL;
20997 }
20998
20999
21000 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21001 PyObject *resultobj = 0;
21002 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21003 bool arg2 = (bool) false ;
21004 size_t result;
21005 void *argp1 = 0 ;
21006 int res1 = 0 ;
21007 bool val2 ;
21008 int ecode2 = 0 ;
21009 PyObject * obj0 = 0 ;
21010 PyObject * obj1 = 0 ;
21011 char * kwnames[] = {
21012 (char *) "self",(char *) "recursive", NULL
21013 };
21014
21015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) SWIG_fail;
21016 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21017 if (!SWIG_IsOK(res1)) {
21018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21019 }
21020 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21021 if (obj1) {
21022 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21023 if (!SWIG_IsOK(ecode2)) {
21024 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "2"" of type '" "bool""'");
21025 }
21026 arg2 = static_cast< bool >(val2);
21027 }
21028 {
21029 PyThreadState* __tstate = wxPyBeginAllowThreads();
21030 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
21031 wxPyEndAllowThreads(__tstate);
21032 if (PyErr_Occurred()) SWIG_fail;
21033 }
21034 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
21035 return resultobj;
21036 fail:
21037 return NULL;
21038 }
21039
21040
21041 SWIGINTERN PyObject *_wrap_ConfigBase_HasGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21042 PyObject *resultobj = 0;
21043 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21044 wxString *arg2 = 0 ;
21045 bool result;
21046 void *argp1 = 0 ;
21047 int res1 = 0 ;
21048 bool temp2 = false ;
21049 PyObject * obj0 = 0 ;
21050 PyObject * obj1 = 0 ;
21051 char * kwnames[] = {
21052 (char *) "self",(char *) "name", NULL
21053 };
21054
21055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) SWIG_fail;
21056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21057 if (!SWIG_IsOK(res1)) {
21058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasGroup" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21059 }
21060 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21061 {
21062 arg2 = wxString_in_helper(obj1);
21063 if (arg2 == NULL) SWIG_fail;
21064 temp2 = true;
21065 }
21066 {
21067 PyThreadState* __tstate = wxPyBeginAllowThreads();
21068 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
21069 wxPyEndAllowThreads(__tstate);
21070 if (PyErr_Occurred()) SWIG_fail;
21071 }
21072 {
21073 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21074 }
21075 {
21076 if (temp2)
21077 delete arg2;
21078 }
21079 return resultobj;
21080 fail:
21081 {
21082 if (temp2)
21083 delete arg2;
21084 }
21085 return NULL;
21086 }
21087
21088
21089 SWIGINTERN PyObject *_wrap_ConfigBase_HasEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21090 PyObject *resultobj = 0;
21091 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21092 wxString *arg2 = 0 ;
21093 bool result;
21094 void *argp1 = 0 ;
21095 int res1 = 0 ;
21096 bool temp2 = false ;
21097 PyObject * obj0 = 0 ;
21098 PyObject * obj1 = 0 ;
21099 char * kwnames[] = {
21100 (char *) "self",(char *) "name", NULL
21101 };
21102
21103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) SWIG_fail;
21104 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21105 if (!SWIG_IsOK(res1)) {
21106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasEntry" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21107 }
21108 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21109 {
21110 arg2 = wxString_in_helper(obj1);
21111 if (arg2 == NULL) SWIG_fail;
21112 temp2 = true;
21113 }
21114 {
21115 PyThreadState* __tstate = wxPyBeginAllowThreads();
21116 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
21117 wxPyEndAllowThreads(__tstate);
21118 if (PyErr_Occurred()) SWIG_fail;
21119 }
21120 {
21121 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21122 }
21123 {
21124 if (temp2)
21125 delete arg2;
21126 }
21127 return resultobj;
21128 fail:
21129 {
21130 if (temp2)
21131 delete arg2;
21132 }
21133 return NULL;
21134 }
21135
21136
21137 SWIGINTERN PyObject *_wrap_ConfigBase_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21138 PyObject *resultobj = 0;
21139 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21140 wxString *arg2 = 0 ;
21141 bool result;
21142 void *argp1 = 0 ;
21143 int res1 = 0 ;
21144 bool temp2 = false ;
21145 PyObject * obj0 = 0 ;
21146 PyObject * obj1 = 0 ;
21147 char * kwnames[] = {
21148 (char *) "self",(char *) "name", NULL
21149 };
21150
21151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) SWIG_fail;
21152 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21153 if (!SWIG_IsOK(res1)) {
21154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Exists" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21155 }
21156 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21157 {
21158 arg2 = wxString_in_helper(obj1);
21159 if (arg2 == NULL) SWIG_fail;
21160 temp2 = true;
21161 }
21162 {
21163 PyThreadState* __tstate = wxPyBeginAllowThreads();
21164 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
21165 wxPyEndAllowThreads(__tstate);
21166 if (PyErr_Occurred()) SWIG_fail;
21167 }
21168 {
21169 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21170 }
21171 {
21172 if (temp2)
21173 delete arg2;
21174 }
21175 return resultobj;
21176 fail:
21177 {
21178 if (temp2)
21179 delete arg2;
21180 }
21181 return NULL;
21182 }
21183
21184
21185 SWIGINTERN PyObject *_wrap_ConfigBase_GetEntryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21186 PyObject *resultobj = 0;
21187 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21188 wxString *arg2 = 0 ;
21189 wxConfigBase::EntryType result;
21190 void *argp1 = 0 ;
21191 int res1 = 0 ;
21192 bool temp2 = false ;
21193 PyObject * obj0 = 0 ;
21194 PyObject * obj1 = 0 ;
21195 char * kwnames[] = {
21196 (char *) "self",(char *) "name", NULL
21197 };
21198
21199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) SWIG_fail;
21200 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21201 if (!SWIG_IsOK(res1)) {
21202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetEntryType" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21203 }
21204 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21205 {
21206 arg2 = wxString_in_helper(obj1);
21207 if (arg2 == NULL) SWIG_fail;
21208 temp2 = true;
21209 }
21210 {
21211 PyThreadState* __tstate = wxPyBeginAllowThreads();
21212 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
21213 wxPyEndAllowThreads(__tstate);
21214 if (PyErr_Occurred()) SWIG_fail;
21215 }
21216 resultobj = SWIG_From_int(static_cast< int >(result));
21217 {
21218 if (temp2)
21219 delete arg2;
21220 }
21221 return resultobj;
21222 fail:
21223 {
21224 if (temp2)
21225 delete arg2;
21226 }
21227 return NULL;
21228 }
21229
21230
21231 SWIGINTERN PyObject *_wrap_ConfigBase_Read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21232 PyObject *resultobj = 0;
21233 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21234 wxString *arg2 = 0 ;
21235 wxString const &arg3_defvalue = wxPyEmptyString ;
21236 wxString *arg3 = (wxString *) &arg3_defvalue ;
21237 wxString result;
21238 void *argp1 = 0 ;
21239 int res1 = 0 ;
21240 bool temp2 = false ;
21241 bool temp3 = false ;
21242 PyObject * obj0 = 0 ;
21243 PyObject * obj1 = 0 ;
21244 PyObject * obj2 = 0 ;
21245 char * kwnames[] = {
21246 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21247 };
21248
21249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21251 if (!SWIG_IsOK(res1)) {
21252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Read" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21253 }
21254 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21255 {
21256 arg2 = wxString_in_helper(obj1);
21257 if (arg2 == NULL) SWIG_fail;
21258 temp2 = true;
21259 }
21260 if (obj2) {
21261 {
21262 arg3 = wxString_in_helper(obj2);
21263 if (arg3 == NULL) SWIG_fail;
21264 temp3 = true;
21265 }
21266 }
21267 {
21268 PyThreadState* __tstate = wxPyBeginAllowThreads();
21269 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
21270 wxPyEndAllowThreads(__tstate);
21271 if (PyErr_Occurred()) SWIG_fail;
21272 }
21273 {
21274 #if wxUSE_UNICODE
21275 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21276 #else
21277 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21278 #endif
21279 }
21280 {
21281 if (temp2)
21282 delete arg2;
21283 }
21284 {
21285 if (temp3)
21286 delete arg3;
21287 }
21288 return resultobj;
21289 fail:
21290 {
21291 if (temp2)
21292 delete arg2;
21293 }
21294 {
21295 if (temp3)
21296 delete arg3;
21297 }
21298 return NULL;
21299 }
21300
21301
21302 SWIGINTERN PyObject *_wrap_ConfigBase_ReadInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21303 PyObject *resultobj = 0;
21304 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21305 wxString *arg2 = 0 ;
21306 long arg3 = (long) 0 ;
21307 long result;
21308 void *argp1 = 0 ;
21309 int res1 = 0 ;
21310 bool temp2 = false ;
21311 long val3 ;
21312 int ecode3 = 0 ;
21313 PyObject * obj0 = 0 ;
21314 PyObject * obj1 = 0 ;
21315 PyObject * obj2 = 0 ;
21316 char * kwnames[] = {
21317 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21318 };
21319
21320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21321 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21322 if (!SWIG_IsOK(res1)) {
21323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21324 }
21325 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21326 {
21327 arg2 = wxString_in_helper(obj1);
21328 if (arg2 == NULL) SWIG_fail;
21329 temp2 = true;
21330 }
21331 if (obj2) {
21332 ecode3 = SWIG_AsVal_long(obj2, &val3);
21333 if (!SWIG_IsOK(ecode3)) {
21334 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadInt" "', expected argument " "3"" of type '" "long""'");
21335 }
21336 arg3 = static_cast< long >(val3);
21337 }
21338 {
21339 PyThreadState* __tstate = wxPyBeginAllowThreads();
21340 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
21341 wxPyEndAllowThreads(__tstate);
21342 if (PyErr_Occurred()) SWIG_fail;
21343 }
21344 resultobj = SWIG_From_long(static_cast< long >(result));
21345 {
21346 if (temp2)
21347 delete arg2;
21348 }
21349 return resultobj;
21350 fail:
21351 {
21352 if (temp2)
21353 delete arg2;
21354 }
21355 return NULL;
21356 }
21357
21358
21359 SWIGINTERN PyObject *_wrap_ConfigBase_ReadFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21360 PyObject *resultobj = 0;
21361 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21362 wxString *arg2 = 0 ;
21363 double arg3 = (double) 0.0 ;
21364 double result;
21365 void *argp1 = 0 ;
21366 int res1 = 0 ;
21367 bool temp2 = false ;
21368 double val3 ;
21369 int ecode3 = 0 ;
21370 PyObject * obj0 = 0 ;
21371 PyObject * obj1 = 0 ;
21372 PyObject * obj2 = 0 ;
21373 char * kwnames[] = {
21374 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21375 };
21376
21377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21378 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21379 if (!SWIG_IsOK(res1)) {
21380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21381 }
21382 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21383 {
21384 arg2 = wxString_in_helper(obj1);
21385 if (arg2 == NULL) SWIG_fail;
21386 temp2 = true;
21387 }
21388 if (obj2) {
21389 ecode3 = SWIG_AsVal_double(obj2, &val3);
21390 if (!SWIG_IsOK(ecode3)) {
21391 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadFloat" "', expected argument " "3"" of type '" "double""'");
21392 }
21393 arg3 = static_cast< double >(val3);
21394 }
21395 {
21396 PyThreadState* __tstate = wxPyBeginAllowThreads();
21397 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
21398 wxPyEndAllowThreads(__tstate);
21399 if (PyErr_Occurred()) SWIG_fail;
21400 }
21401 resultobj = SWIG_From_double(static_cast< double >(result));
21402 {
21403 if (temp2)
21404 delete arg2;
21405 }
21406 return resultobj;
21407 fail:
21408 {
21409 if (temp2)
21410 delete arg2;
21411 }
21412 return NULL;
21413 }
21414
21415
21416 SWIGINTERN PyObject *_wrap_ConfigBase_ReadBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21417 PyObject *resultobj = 0;
21418 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21419 wxString *arg2 = 0 ;
21420 bool arg3 = (bool) false ;
21421 bool result;
21422 void *argp1 = 0 ;
21423 int res1 = 0 ;
21424 bool temp2 = false ;
21425 bool val3 ;
21426 int ecode3 = 0 ;
21427 PyObject * obj0 = 0 ;
21428 PyObject * obj1 = 0 ;
21429 PyObject * obj2 = 0 ;
21430 char * kwnames[] = {
21431 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21432 };
21433
21434 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21435 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21436 if (!SWIG_IsOK(res1)) {
21437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21438 }
21439 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21440 {
21441 arg2 = wxString_in_helper(obj1);
21442 if (arg2 == NULL) SWIG_fail;
21443 temp2 = true;
21444 }
21445 if (obj2) {
21446 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21447 if (!SWIG_IsOK(ecode3)) {
21448 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadBool" "', expected argument " "3"" of type '" "bool""'");
21449 }
21450 arg3 = static_cast< bool >(val3);
21451 }
21452 {
21453 PyThreadState* __tstate = wxPyBeginAllowThreads();
21454 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
21455 wxPyEndAllowThreads(__tstate);
21456 if (PyErr_Occurred()) SWIG_fail;
21457 }
21458 {
21459 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21460 }
21461 {
21462 if (temp2)
21463 delete arg2;
21464 }
21465 return resultobj;
21466 fail:
21467 {
21468 if (temp2)
21469 delete arg2;
21470 }
21471 return NULL;
21472 }
21473
21474
21475 SWIGINTERN PyObject *_wrap_ConfigBase_Write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21476 PyObject *resultobj = 0;
21477 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21478 wxString *arg2 = 0 ;
21479 wxString *arg3 = 0 ;
21480 bool result;
21481 void *argp1 = 0 ;
21482 int res1 = 0 ;
21483 bool temp2 = false ;
21484 bool temp3 = false ;
21485 PyObject * obj0 = 0 ;
21486 PyObject * obj1 = 0 ;
21487 PyObject * obj2 = 0 ;
21488 char * kwnames[] = {
21489 (char *) "self",(char *) "key",(char *) "value", NULL
21490 };
21491
21492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21493 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21494 if (!SWIG_IsOK(res1)) {
21495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Write" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21496 }
21497 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21498 {
21499 arg2 = wxString_in_helper(obj1);
21500 if (arg2 == NULL) SWIG_fail;
21501 temp2 = true;
21502 }
21503 {
21504 arg3 = wxString_in_helper(obj2);
21505 if (arg3 == NULL) SWIG_fail;
21506 temp3 = true;
21507 }
21508 {
21509 PyThreadState* __tstate = wxPyBeginAllowThreads();
21510 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
21511 wxPyEndAllowThreads(__tstate);
21512 if (PyErr_Occurred()) SWIG_fail;
21513 }
21514 {
21515 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21516 }
21517 {
21518 if (temp2)
21519 delete arg2;
21520 }
21521 {
21522 if (temp3)
21523 delete arg3;
21524 }
21525 return resultobj;
21526 fail:
21527 {
21528 if (temp2)
21529 delete arg2;
21530 }
21531 {
21532 if (temp3)
21533 delete arg3;
21534 }
21535 return NULL;
21536 }
21537
21538
21539 SWIGINTERN PyObject *_wrap_ConfigBase_WriteInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21540 PyObject *resultobj = 0;
21541 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21542 wxString *arg2 = 0 ;
21543 long arg3 ;
21544 bool result;
21545 void *argp1 = 0 ;
21546 int res1 = 0 ;
21547 bool temp2 = false ;
21548 long val3 ;
21549 int ecode3 = 0 ;
21550 PyObject * obj0 = 0 ;
21551 PyObject * obj1 = 0 ;
21552 PyObject * obj2 = 0 ;
21553 char * kwnames[] = {
21554 (char *) "self",(char *) "key",(char *) "value", NULL
21555 };
21556
21557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21558 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21559 if (!SWIG_IsOK(res1)) {
21560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21561 }
21562 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21563 {
21564 arg2 = wxString_in_helper(obj1);
21565 if (arg2 == NULL) SWIG_fail;
21566 temp2 = true;
21567 }
21568 ecode3 = SWIG_AsVal_long(obj2, &val3);
21569 if (!SWIG_IsOK(ecode3)) {
21570 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteInt" "', expected argument " "3"" of type '" "long""'");
21571 }
21572 arg3 = static_cast< long >(val3);
21573 {
21574 PyThreadState* __tstate = wxPyBeginAllowThreads();
21575 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21576 wxPyEndAllowThreads(__tstate);
21577 if (PyErr_Occurred()) SWIG_fail;
21578 }
21579 {
21580 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21581 }
21582 {
21583 if (temp2)
21584 delete arg2;
21585 }
21586 return resultobj;
21587 fail:
21588 {
21589 if (temp2)
21590 delete arg2;
21591 }
21592 return NULL;
21593 }
21594
21595
21596 SWIGINTERN PyObject *_wrap_ConfigBase_WriteFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21597 PyObject *resultobj = 0;
21598 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21599 wxString *arg2 = 0 ;
21600 double arg3 ;
21601 bool result;
21602 void *argp1 = 0 ;
21603 int res1 = 0 ;
21604 bool temp2 = false ;
21605 double val3 ;
21606 int ecode3 = 0 ;
21607 PyObject * obj0 = 0 ;
21608 PyObject * obj1 = 0 ;
21609 PyObject * obj2 = 0 ;
21610 char * kwnames[] = {
21611 (char *) "self",(char *) "key",(char *) "value", NULL
21612 };
21613
21614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21615 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21616 if (!SWIG_IsOK(res1)) {
21617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21618 }
21619 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21620 {
21621 arg2 = wxString_in_helper(obj1);
21622 if (arg2 == NULL) SWIG_fail;
21623 temp2 = true;
21624 }
21625 ecode3 = SWIG_AsVal_double(obj2, &val3);
21626 if (!SWIG_IsOK(ecode3)) {
21627 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteFloat" "', expected argument " "3"" of type '" "double""'");
21628 }
21629 arg3 = static_cast< double >(val3);
21630 {
21631 PyThreadState* __tstate = wxPyBeginAllowThreads();
21632 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21633 wxPyEndAllowThreads(__tstate);
21634 if (PyErr_Occurred()) SWIG_fail;
21635 }
21636 {
21637 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21638 }
21639 {
21640 if (temp2)
21641 delete arg2;
21642 }
21643 return resultobj;
21644 fail:
21645 {
21646 if (temp2)
21647 delete arg2;
21648 }
21649 return NULL;
21650 }
21651
21652
21653 SWIGINTERN PyObject *_wrap_ConfigBase_WriteBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21654 PyObject *resultobj = 0;
21655 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21656 wxString *arg2 = 0 ;
21657 bool arg3 ;
21658 bool result;
21659 void *argp1 = 0 ;
21660 int res1 = 0 ;
21661 bool temp2 = false ;
21662 bool val3 ;
21663 int ecode3 = 0 ;
21664 PyObject * obj0 = 0 ;
21665 PyObject * obj1 = 0 ;
21666 PyObject * obj2 = 0 ;
21667 char * kwnames[] = {
21668 (char *) "self",(char *) "key",(char *) "value", NULL
21669 };
21670
21671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21673 if (!SWIG_IsOK(res1)) {
21674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21675 }
21676 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21677 {
21678 arg2 = wxString_in_helper(obj1);
21679 if (arg2 == NULL) SWIG_fail;
21680 temp2 = true;
21681 }
21682 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21683 if (!SWIG_IsOK(ecode3)) {
21684 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteBool" "', expected argument " "3"" of type '" "bool""'");
21685 }
21686 arg3 = static_cast< bool >(val3);
21687 {
21688 PyThreadState* __tstate = wxPyBeginAllowThreads();
21689 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21690 wxPyEndAllowThreads(__tstate);
21691 if (PyErr_Occurred()) SWIG_fail;
21692 }
21693 {
21694 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21695 }
21696 {
21697 if (temp2)
21698 delete arg2;
21699 }
21700 return resultobj;
21701 fail:
21702 {
21703 if (temp2)
21704 delete arg2;
21705 }
21706 return NULL;
21707 }
21708
21709
21710 SWIGINTERN PyObject *_wrap_ConfigBase_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21711 PyObject *resultobj = 0;
21712 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21713 bool arg2 = (bool) false ;
21714 bool result;
21715 void *argp1 = 0 ;
21716 int res1 = 0 ;
21717 bool val2 ;
21718 int ecode2 = 0 ;
21719 PyObject * obj0 = 0 ;
21720 PyObject * obj1 = 0 ;
21721 char * kwnames[] = {
21722 (char *) "self",(char *) "currentOnly", NULL
21723 };
21724
21725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) SWIG_fail;
21726 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21727 if (!SWIG_IsOK(res1)) {
21728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Flush" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21729 }
21730 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21731 if (obj1) {
21732 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21733 if (!SWIG_IsOK(ecode2)) {
21734 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_Flush" "', expected argument " "2"" of type '" "bool""'");
21735 }
21736 arg2 = static_cast< bool >(val2);
21737 }
21738 {
21739 PyThreadState* __tstate = wxPyBeginAllowThreads();
21740 result = (bool)(arg1)->Flush(arg2);
21741 wxPyEndAllowThreads(__tstate);
21742 if (PyErr_Occurred()) SWIG_fail;
21743 }
21744 {
21745 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21746 }
21747 return resultobj;
21748 fail:
21749 return NULL;
21750 }
21751
21752
21753 SWIGINTERN PyObject *_wrap_ConfigBase_RenameEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21754 PyObject *resultobj = 0;
21755 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21756 wxString *arg2 = 0 ;
21757 wxString *arg3 = 0 ;
21758 bool result;
21759 void *argp1 = 0 ;
21760 int res1 = 0 ;
21761 bool temp2 = false ;
21762 bool temp3 = false ;
21763 PyObject * obj0 = 0 ;
21764 PyObject * obj1 = 0 ;
21765 PyObject * obj2 = 0 ;
21766 char * kwnames[] = {
21767 (char *) "self",(char *) "oldName",(char *) "newName", NULL
21768 };
21769
21770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21771 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21772 if (!SWIG_IsOK(res1)) {
21773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21774 }
21775 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21776 {
21777 arg2 = wxString_in_helper(obj1);
21778 if (arg2 == NULL) SWIG_fail;
21779 temp2 = true;
21780 }
21781 {
21782 arg3 = wxString_in_helper(obj2);
21783 if (arg3 == NULL) SWIG_fail;
21784 temp3 = true;
21785 }
21786 {
21787 PyThreadState* __tstate = wxPyBeginAllowThreads();
21788 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
21789 wxPyEndAllowThreads(__tstate);
21790 if (PyErr_Occurred()) SWIG_fail;
21791 }
21792 {
21793 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21794 }
21795 {
21796 if (temp2)
21797 delete arg2;
21798 }
21799 {
21800 if (temp3)
21801 delete arg3;
21802 }
21803 return resultobj;
21804 fail:
21805 {
21806 if (temp2)
21807 delete arg2;
21808 }
21809 {
21810 if (temp3)
21811 delete arg3;
21812 }
21813 return NULL;
21814 }
21815
21816
21817 SWIGINTERN PyObject *_wrap_ConfigBase_RenameGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21818 PyObject *resultobj = 0;
21819 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21820 wxString *arg2 = 0 ;
21821 wxString *arg3 = 0 ;
21822 bool result;
21823 void *argp1 = 0 ;
21824 int res1 = 0 ;
21825 bool temp2 = false ;
21826 bool temp3 = false ;
21827 PyObject * obj0 = 0 ;
21828 PyObject * obj1 = 0 ;
21829 PyObject * obj2 = 0 ;
21830 char * kwnames[] = {
21831 (char *) "self",(char *) "oldName",(char *) "newName", NULL
21832 };
21833
21834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21836 if (!SWIG_IsOK(res1)) {
21837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21838 }
21839 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21840 {
21841 arg2 = wxString_in_helper(obj1);
21842 if (arg2 == NULL) SWIG_fail;
21843 temp2 = true;
21844 }
21845 {
21846 arg3 = wxString_in_helper(obj2);
21847 if (arg3 == NULL) SWIG_fail;
21848 temp3 = true;
21849 }
21850 {
21851 PyThreadState* __tstate = wxPyBeginAllowThreads();
21852 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
21853 wxPyEndAllowThreads(__tstate);
21854 if (PyErr_Occurred()) SWIG_fail;
21855 }
21856 {
21857 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21858 }
21859 {
21860 if (temp2)
21861 delete arg2;
21862 }
21863 {
21864 if (temp3)
21865 delete arg3;
21866 }
21867 return resultobj;
21868 fail:
21869 {
21870 if (temp2)
21871 delete arg2;
21872 }
21873 {
21874 if (temp3)
21875 delete arg3;
21876 }
21877 return NULL;
21878 }
21879
21880
21881 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21882 PyObject *resultobj = 0;
21883 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21884 wxString *arg2 = 0 ;
21885 bool arg3 = (bool) true ;
21886 bool result;
21887 void *argp1 = 0 ;
21888 int res1 = 0 ;
21889 bool temp2 = false ;
21890 bool val3 ;
21891 int ecode3 = 0 ;
21892 PyObject * obj0 = 0 ;
21893 PyObject * obj1 = 0 ;
21894 PyObject * obj2 = 0 ;
21895 char * kwnames[] = {
21896 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
21897 };
21898
21899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21901 if (!SWIG_IsOK(res1)) {
21902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21903 }
21904 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21905 {
21906 arg2 = wxString_in_helper(obj1);
21907 if (arg2 == NULL) SWIG_fail;
21908 temp2 = true;
21909 }
21910 if (obj2) {
21911 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21912 if (!SWIG_IsOK(ecode3)) {
21913 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "3"" of type '" "bool""'");
21914 }
21915 arg3 = static_cast< bool >(val3);
21916 }
21917 {
21918 PyThreadState* __tstate = wxPyBeginAllowThreads();
21919 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
21920 wxPyEndAllowThreads(__tstate);
21921 if (PyErr_Occurred()) SWIG_fail;
21922 }
21923 {
21924 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21925 }
21926 {
21927 if (temp2)
21928 delete arg2;
21929 }
21930 return resultobj;
21931 fail:
21932 {
21933 if (temp2)
21934 delete arg2;
21935 }
21936 return NULL;
21937 }
21938
21939
21940 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21941 PyObject *resultobj = 0;
21942 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21943 wxString *arg2 = 0 ;
21944 bool result;
21945 void *argp1 = 0 ;
21946 int res1 = 0 ;
21947 bool temp2 = false ;
21948 PyObject * obj0 = 0 ;
21949 PyObject * obj1 = 0 ;
21950 char * kwnames[] = {
21951 (char *) "self",(char *) "key", NULL
21952 };
21953
21954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) SWIG_fail;
21955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21956 if (!SWIG_IsOK(res1)) {
21957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21958 }
21959 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21960 {
21961 arg2 = wxString_in_helper(obj1);
21962 if (arg2 == NULL) SWIG_fail;
21963 temp2 = true;
21964 }
21965 {
21966 PyThreadState* __tstate = wxPyBeginAllowThreads();
21967 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
21968 wxPyEndAllowThreads(__tstate);
21969 if (PyErr_Occurred()) SWIG_fail;
21970 }
21971 {
21972 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21973 }
21974 {
21975 if (temp2)
21976 delete arg2;
21977 }
21978 return resultobj;
21979 fail:
21980 {
21981 if (temp2)
21982 delete arg2;
21983 }
21984 return NULL;
21985 }
21986
21987
21988 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21989 PyObject *resultobj = 0;
21990 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21991 bool result;
21992 void *argp1 = 0 ;
21993 int res1 = 0 ;
21994 PyObject *swig_obj[1] ;
21995
21996 if (!args) SWIG_fail;
21997 swig_obj[0] = args;
21998 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21999 if (!SWIG_IsOK(res1)) {
22000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteAll" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22001 }
22002 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22003 {
22004 PyThreadState* __tstate = wxPyBeginAllowThreads();
22005 result = (bool)(arg1)->DeleteAll();
22006 wxPyEndAllowThreads(__tstate);
22007 if (PyErr_Occurred()) SWIG_fail;
22008 }
22009 {
22010 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22011 }
22012 return resultobj;
22013 fail:
22014 return NULL;
22015 }
22016
22017
22018 SWIGINTERN PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22019 PyObject *resultobj = 0;
22020 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22021 bool arg2 = (bool) true ;
22022 void *argp1 = 0 ;
22023 int res1 = 0 ;
22024 bool val2 ;
22025 int ecode2 = 0 ;
22026 PyObject * obj0 = 0 ;
22027 PyObject * obj1 = 0 ;
22028 char * kwnames[] = {
22029 (char *) "self",(char *) "doIt", NULL
22030 };
22031
22032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
22033 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22034 if (!SWIG_IsOK(res1)) {
22035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22036 }
22037 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22038 if (obj1) {
22039 ecode2 = SWIG_AsVal_bool(obj1, &val2);
22040 if (!SWIG_IsOK(ecode2)) {
22041 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "2"" of type '" "bool""'");
22042 }
22043 arg2 = static_cast< bool >(val2);
22044 }
22045 {
22046 PyThreadState* __tstate = wxPyBeginAllowThreads();
22047 (arg1)->SetExpandEnvVars(arg2);
22048 wxPyEndAllowThreads(__tstate);
22049 if (PyErr_Occurred()) SWIG_fail;
22050 }
22051 resultobj = SWIG_Py_Void();
22052 return resultobj;
22053 fail:
22054 return NULL;
22055 }
22056
22057
22058 SWIGINTERN PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22059 PyObject *resultobj = 0;
22060 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22061 bool result;
22062 void *argp1 = 0 ;
22063 int res1 = 0 ;
22064 PyObject *swig_obj[1] ;
22065
22066 if (!args) SWIG_fail;
22067 swig_obj[0] = args;
22068 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22069 if (!SWIG_IsOK(res1)) {
22070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsExpandingEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22071 }
22072 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22073 {
22074 PyThreadState* __tstate = wxPyBeginAllowThreads();
22075 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
22076 wxPyEndAllowThreads(__tstate);
22077 if (PyErr_Occurred()) SWIG_fail;
22078 }
22079 {
22080 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22081 }
22082 return resultobj;
22083 fail:
22084 return NULL;
22085 }
22086
22087
22088 SWIGINTERN PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22089 PyObject *resultobj = 0;
22090 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22091 bool arg2 = (bool) true ;
22092 void *argp1 = 0 ;
22093 int res1 = 0 ;
22094 bool val2 ;
22095 int ecode2 = 0 ;
22096 PyObject * obj0 = 0 ;
22097 PyObject * obj1 = 0 ;
22098 char * kwnames[] = {
22099 (char *) "self",(char *) "doIt", NULL
22100 };
22101
22102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
22103 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22104 if (!SWIG_IsOK(res1)) {
22105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22106 }
22107 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22108 if (obj1) {
22109 ecode2 = SWIG_AsVal_bool(obj1, &val2);
22110 if (!SWIG_IsOK(ecode2)) {
22111 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "2"" of type '" "bool""'");
22112 }
22113 arg2 = static_cast< bool >(val2);
22114 }
22115 {
22116 PyThreadState* __tstate = wxPyBeginAllowThreads();
22117 (arg1)->SetRecordDefaults(arg2);
22118 wxPyEndAllowThreads(__tstate);
22119 if (PyErr_Occurred()) SWIG_fail;
22120 }
22121 resultobj = SWIG_Py_Void();
22122 return resultobj;
22123 fail:
22124 return NULL;
22125 }
22126
22127
22128 SWIGINTERN PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22129 PyObject *resultobj = 0;
22130 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22131 bool result;
22132 void *argp1 = 0 ;
22133 int res1 = 0 ;
22134 PyObject *swig_obj[1] ;
22135
22136 if (!args) SWIG_fail;
22137 swig_obj[0] = args;
22138 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22139 if (!SWIG_IsOK(res1)) {
22140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsRecordingDefaults" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22141 }
22142 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22143 {
22144 PyThreadState* __tstate = wxPyBeginAllowThreads();
22145 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
22146 wxPyEndAllowThreads(__tstate);
22147 if (PyErr_Occurred()) SWIG_fail;
22148 }
22149 {
22150 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22151 }
22152 return resultobj;
22153 fail:
22154 return NULL;
22155 }
22156
22157
22158 SWIGINTERN PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22159 PyObject *resultobj = 0;
22160 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22161 wxString *arg2 = 0 ;
22162 wxString result;
22163 void *argp1 = 0 ;
22164 int res1 = 0 ;
22165 bool temp2 = false ;
22166 PyObject * obj0 = 0 ;
22167 PyObject * obj1 = 0 ;
22168 char * kwnames[] = {
22169 (char *) "self",(char *) "str", NULL
22170 };
22171
22172 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
22173 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22174 if (!SWIG_IsOK(res1)) {
22175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22176 }
22177 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22178 {
22179 arg2 = wxString_in_helper(obj1);
22180 if (arg2 == NULL) SWIG_fail;
22181 temp2 = true;
22182 }
22183 {
22184 PyThreadState* __tstate = wxPyBeginAllowThreads();
22185 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
22186 wxPyEndAllowThreads(__tstate);
22187 if (PyErr_Occurred()) SWIG_fail;
22188 }
22189 {
22190 #if wxUSE_UNICODE
22191 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22192 #else
22193 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22194 #endif
22195 }
22196 {
22197 if (temp2)
22198 delete arg2;
22199 }
22200 return resultobj;
22201 fail:
22202 {
22203 if (temp2)
22204 delete arg2;
22205 }
22206 return NULL;
22207 }
22208
22209
22210 SWIGINTERN PyObject *_wrap_ConfigBase_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22211 PyObject *resultobj = 0;
22212 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22213 wxString result;
22214 void *argp1 = 0 ;
22215 int res1 = 0 ;
22216 PyObject *swig_obj[1] ;
22217
22218 if (!args) SWIG_fail;
22219 swig_obj[0] = args;
22220 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22221 if (!SWIG_IsOK(res1)) {
22222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetAppName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22223 }
22224 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22225 {
22226 PyThreadState* __tstate = wxPyBeginAllowThreads();
22227 result = ((wxConfigBase const *)arg1)->GetAppName();
22228 wxPyEndAllowThreads(__tstate);
22229 if (PyErr_Occurred()) SWIG_fail;
22230 }
22231 {
22232 #if wxUSE_UNICODE
22233 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22234 #else
22235 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22236 #endif
22237 }
22238 return resultobj;
22239 fail:
22240 return NULL;
22241 }
22242
22243
22244 SWIGINTERN PyObject *_wrap_ConfigBase_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22245 PyObject *resultobj = 0;
22246 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22247 wxString result;
22248 void *argp1 = 0 ;
22249 int res1 = 0 ;
22250 PyObject *swig_obj[1] ;
22251
22252 if (!args) SWIG_fail;
22253 swig_obj[0] = args;
22254 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22255 if (!SWIG_IsOK(res1)) {
22256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetVendorName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22257 }
22258 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22259 {
22260 PyThreadState* __tstate = wxPyBeginAllowThreads();
22261 result = ((wxConfigBase const *)arg1)->GetVendorName();
22262 wxPyEndAllowThreads(__tstate);
22263 if (PyErr_Occurred()) SWIG_fail;
22264 }
22265 {
22266 #if wxUSE_UNICODE
22267 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22268 #else
22269 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22270 #endif
22271 }
22272 return resultobj;
22273 fail:
22274 return NULL;
22275 }
22276
22277
22278 SWIGINTERN PyObject *_wrap_ConfigBase_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22279 PyObject *resultobj = 0;
22280 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22281 wxString *arg2 = 0 ;
22282 void *argp1 = 0 ;
22283 int res1 = 0 ;
22284 bool temp2 = false ;
22285 PyObject * obj0 = 0 ;
22286 PyObject * obj1 = 0 ;
22287 char * kwnames[] = {
22288 (char *) "self",(char *) "appName", NULL
22289 };
22290
22291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
22292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22293 if (!SWIG_IsOK(res1)) {
22294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetAppName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22295 }
22296 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22297 {
22298 arg2 = wxString_in_helper(obj1);
22299 if (arg2 == NULL) SWIG_fail;
22300 temp2 = true;
22301 }
22302 {
22303 PyThreadState* __tstate = wxPyBeginAllowThreads();
22304 (arg1)->SetAppName((wxString const &)*arg2);
22305 wxPyEndAllowThreads(__tstate);
22306 if (PyErr_Occurred()) SWIG_fail;
22307 }
22308 resultobj = SWIG_Py_Void();
22309 {
22310 if (temp2)
22311 delete arg2;
22312 }
22313 return resultobj;
22314 fail:
22315 {
22316 if (temp2)
22317 delete arg2;
22318 }
22319 return NULL;
22320 }
22321
22322
22323 SWIGINTERN PyObject *_wrap_ConfigBase_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22324 PyObject *resultobj = 0;
22325 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22326 wxString *arg2 = 0 ;
22327 void *argp1 = 0 ;
22328 int res1 = 0 ;
22329 bool temp2 = false ;
22330 PyObject * obj0 = 0 ;
22331 PyObject * obj1 = 0 ;
22332 char * kwnames[] = {
22333 (char *) "self",(char *) "vendorName", NULL
22334 };
22335
22336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
22337 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22338 if (!SWIG_IsOK(res1)) {
22339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetVendorName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22340 }
22341 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22342 {
22343 arg2 = wxString_in_helper(obj1);
22344 if (arg2 == NULL) SWIG_fail;
22345 temp2 = true;
22346 }
22347 {
22348 PyThreadState* __tstate = wxPyBeginAllowThreads();
22349 (arg1)->SetVendorName((wxString const &)*arg2);
22350 wxPyEndAllowThreads(__tstate);
22351 if (PyErr_Occurred()) SWIG_fail;
22352 }
22353 resultobj = SWIG_Py_Void();
22354 {
22355 if (temp2)
22356 delete arg2;
22357 }
22358 return resultobj;
22359 fail:
22360 {
22361 if (temp2)
22362 delete arg2;
22363 }
22364 return NULL;
22365 }
22366
22367
22368 SWIGINTERN PyObject *_wrap_ConfigBase_SetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22369 PyObject *resultobj = 0;
22370 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22371 long arg2 ;
22372 void *argp1 = 0 ;
22373 int res1 = 0 ;
22374 long val2 ;
22375 int ecode2 = 0 ;
22376 PyObject * obj0 = 0 ;
22377 PyObject * obj1 = 0 ;
22378 char * kwnames[] = {
22379 (char *) "self",(char *) "style", NULL
22380 };
22381
22382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) SWIG_fail;
22383 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22384 if (!SWIG_IsOK(res1)) {
22385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetStyle" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22386 }
22387 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22388 ecode2 = SWIG_AsVal_long(obj1, &val2);
22389 if (!SWIG_IsOK(ecode2)) {
22390 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetStyle" "', expected argument " "2"" of type '" "long""'");
22391 }
22392 arg2 = static_cast< long >(val2);
22393 {
22394 PyThreadState* __tstate = wxPyBeginAllowThreads();
22395 (arg1)->SetStyle(arg2);
22396 wxPyEndAllowThreads(__tstate);
22397 if (PyErr_Occurred()) SWIG_fail;
22398 }
22399 resultobj = SWIG_Py_Void();
22400 return resultobj;
22401 fail:
22402 return NULL;
22403 }
22404
22405
22406 SWIGINTERN PyObject *_wrap_ConfigBase_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22407 PyObject *resultobj = 0;
22408 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22409 long result;
22410 void *argp1 = 0 ;
22411 int res1 = 0 ;
22412 PyObject *swig_obj[1] ;
22413
22414 if (!args) SWIG_fail;
22415 swig_obj[0] = args;
22416 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22417 if (!SWIG_IsOK(res1)) {
22418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetStyle" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22419 }
22420 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22421 {
22422 PyThreadState* __tstate = wxPyBeginAllowThreads();
22423 result = (long)((wxConfigBase const *)arg1)->GetStyle();
22424 wxPyEndAllowThreads(__tstate);
22425 if (PyErr_Occurred()) SWIG_fail;
22426 }
22427 resultobj = SWIG_From_long(static_cast< long >(result));
22428 return resultobj;
22429 fail:
22430 return NULL;
22431 }
22432
22433
22434 SWIGINTERN PyObject *ConfigBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22435 PyObject *obj;
22436 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22437 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigBase, SWIG_NewClientData(obj));
22438 return SWIG_Py_Void();
22439 }
22440
22441 SWIGINTERN PyObject *_wrap_new_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22442 PyObject *resultobj = 0;
22443 wxString const &arg1_defvalue = wxPyEmptyString ;
22444 wxString *arg1 = (wxString *) &arg1_defvalue ;
22445 wxString const &arg2_defvalue = wxPyEmptyString ;
22446 wxString *arg2 = (wxString *) &arg2_defvalue ;
22447 wxString const &arg3_defvalue = wxPyEmptyString ;
22448 wxString *arg3 = (wxString *) &arg3_defvalue ;
22449 wxString const &arg4_defvalue = wxPyEmptyString ;
22450 wxString *arg4 = (wxString *) &arg4_defvalue ;
22451 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
22452 wxConfig *result = 0 ;
22453 bool temp1 = false ;
22454 bool temp2 = false ;
22455 bool temp3 = false ;
22456 bool temp4 = false ;
22457 long val5 ;
22458 int ecode5 = 0 ;
22459 PyObject * obj0 = 0 ;
22460 PyObject * obj1 = 0 ;
22461 PyObject * obj2 = 0 ;
22462 PyObject * obj3 = 0 ;
22463 PyObject * obj4 = 0 ;
22464 char * kwnames[] = {
22465 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
22466 };
22467
22468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
22469 if (obj0) {
22470 {
22471 arg1 = wxString_in_helper(obj0);
22472 if (arg1 == NULL) SWIG_fail;
22473 temp1 = true;
22474 }
22475 }
22476 if (obj1) {
22477 {
22478 arg2 = wxString_in_helper(obj1);
22479 if (arg2 == NULL) SWIG_fail;
22480 temp2 = true;
22481 }
22482 }
22483 if (obj2) {
22484 {
22485 arg3 = wxString_in_helper(obj2);
22486 if (arg3 == NULL) SWIG_fail;
22487 temp3 = true;
22488 }
22489 }
22490 if (obj3) {
22491 {
22492 arg4 = wxString_in_helper(obj3);
22493 if (arg4 == NULL) SWIG_fail;
22494 temp4 = true;
22495 }
22496 }
22497 if (obj4) {
22498 ecode5 = SWIG_AsVal_long(obj4, &val5);
22499 if (!SWIG_IsOK(ecode5)) {
22500 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Config" "', expected argument " "5"" of type '" "long""'");
22501 }
22502 arg5 = static_cast< long >(val5);
22503 }
22504 {
22505 PyThreadState* __tstate = wxPyBeginAllowThreads();
22506 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
22507 wxPyEndAllowThreads(__tstate);
22508 if (PyErr_Occurred()) SWIG_fail;
22509 }
22510 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfig, SWIG_POINTER_NEW | 0 );
22511 {
22512 if (temp1)
22513 delete arg1;
22514 }
22515 {
22516 if (temp2)
22517 delete arg2;
22518 }
22519 {
22520 if (temp3)
22521 delete arg3;
22522 }
22523 {
22524 if (temp4)
22525 delete arg4;
22526 }
22527 return resultobj;
22528 fail:
22529 {
22530 if (temp1)
22531 delete arg1;
22532 }
22533 {
22534 if (temp2)
22535 delete arg2;
22536 }
22537 {
22538 if (temp3)
22539 delete arg3;
22540 }
22541 {
22542 if (temp4)
22543 delete arg4;
22544 }
22545 return NULL;
22546 }
22547
22548
22549 SWIGINTERN PyObject *_wrap_delete_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22550 PyObject *resultobj = 0;
22551 wxConfig *arg1 = (wxConfig *) 0 ;
22552 void *argp1 = 0 ;
22553 int res1 = 0 ;
22554 PyObject *swig_obj[1] ;
22555
22556 if (!args) SWIG_fail;
22557 swig_obj[0] = args;
22558 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfig, SWIG_POINTER_DISOWN | 0 );
22559 if (!SWIG_IsOK(res1)) {
22560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Config" "', expected argument " "1"" of type '" "wxConfig *""'");
22561 }
22562 arg1 = reinterpret_cast< wxConfig * >(argp1);
22563 {
22564 PyThreadState* __tstate = wxPyBeginAllowThreads();
22565 delete arg1;
22566
22567 wxPyEndAllowThreads(__tstate);
22568 if (PyErr_Occurred()) SWIG_fail;
22569 }
22570 resultobj = SWIG_Py_Void();
22571 return resultobj;
22572 fail:
22573 return NULL;
22574 }
22575
22576
22577 SWIGINTERN PyObject *Config_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22578 PyObject *obj;
22579 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22580 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfig, SWIG_NewClientData(obj));
22581 return SWIG_Py_Void();
22582 }
22583
22584 SWIGINTERN PyObject *Config_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22585 return SWIG_Python_InitShadowInstance(args);
22586 }
22587
22588 SWIGINTERN PyObject *_wrap_new_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22589 PyObject *resultobj = 0;
22590 wxString const &arg1_defvalue = wxPyEmptyString ;
22591 wxString *arg1 = (wxString *) &arg1_defvalue ;
22592 wxString const &arg2_defvalue = wxPyEmptyString ;
22593 wxString *arg2 = (wxString *) &arg2_defvalue ;
22594 wxString const &arg3_defvalue = wxPyEmptyString ;
22595 wxString *arg3 = (wxString *) &arg3_defvalue ;
22596 wxString const &arg4_defvalue = wxPyEmptyString ;
22597 wxString *arg4 = (wxString *) &arg4_defvalue ;
22598 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
22599 wxFileConfig *result = 0 ;
22600 bool temp1 = false ;
22601 bool temp2 = false ;
22602 bool temp3 = false ;
22603 bool temp4 = false ;
22604 long val5 ;
22605 int ecode5 = 0 ;
22606 PyObject * obj0 = 0 ;
22607 PyObject * obj1 = 0 ;
22608 PyObject * obj2 = 0 ;
22609 PyObject * obj3 = 0 ;
22610 PyObject * obj4 = 0 ;
22611 char * kwnames[] = {
22612 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
22613 };
22614
22615 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
22616 if (obj0) {
22617 {
22618 arg1 = wxString_in_helper(obj0);
22619 if (arg1 == NULL) SWIG_fail;
22620 temp1 = true;
22621 }
22622 }
22623 if (obj1) {
22624 {
22625 arg2 = wxString_in_helper(obj1);
22626 if (arg2 == NULL) SWIG_fail;
22627 temp2 = true;
22628 }
22629 }
22630 if (obj2) {
22631 {
22632 arg3 = wxString_in_helper(obj2);
22633 if (arg3 == NULL) SWIG_fail;
22634 temp3 = true;
22635 }
22636 }
22637 if (obj3) {
22638 {
22639 arg4 = wxString_in_helper(obj3);
22640 if (arg4 == NULL) SWIG_fail;
22641 temp4 = true;
22642 }
22643 }
22644 if (obj4) {
22645 ecode5 = SWIG_AsVal_long(obj4, &val5);
22646 if (!SWIG_IsOK(ecode5)) {
22647 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FileConfig" "', expected argument " "5"" of type '" "long""'");
22648 }
22649 arg5 = static_cast< long >(val5);
22650 }
22651 {
22652 PyThreadState* __tstate = wxPyBeginAllowThreads();
22653 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
22654 wxPyEndAllowThreads(__tstate);
22655 if (PyErr_Occurred()) SWIG_fail;
22656 }
22657 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileConfig, SWIG_POINTER_NEW | 0 );
22658 {
22659 if (temp1)
22660 delete arg1;
22661 }
22662 {
22663 if (temp2)
22664 delete arg2;
22665 }
22666 {
22667 if (temp3)
22668 delete arg3;
22669 }
22670 {
22671 if (temp4)
22672 delete arg4;
22673 }
22674 return resultobj;
22675 fail:
22676 {
22677 if (temp1)
22678 delete arg1;
22679 }
22680 {
22681 if (temp2)
22682 delete arg2;
22683 }
22684 {
22685 if (temp3)
22686 delete arg3;
22687 }
22688 {
22689 if (temp4)
22690 delete arg4;
22691 }
22692 return NULL;
22693 }
22694
22695
22696 SWIGINTERN PyObject *_wrap_delete_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22697 PyObject *resultobj = 0;
22698 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
22699 void *argp1 = 0 ;
22700 int res1 = 0 ;
22701 PyObject *swig_obj[1] ;
22702
22703 if (!args) SWIG_fail;
22704 swig_obj[0] = args;
22705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileConfig, SWIG_POINTER_DISOWN | 0 );
22706 if (!SWIG_IsOK(res1)) {
22707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileConfig" "', expected argument " "1"" of type '" "wxFileConfig *""'");
22708 }
22709 arg1 = reinterpret_cast< wxFileConfig * >(argp1);
22710 {
22711 PyThreadState* __tstate = wxPyBeginAllowThreads();
22712 delete arg1;
22713
22714 wxPyEndAllowThreads(__tstate);
22715 if (PyErr_Occurred()) SWIG_fail;
22716 }
22717 resultobj = SWIG_Py_Void();
22718 return resultobj;
22719 fail:
22720 return NULL;
22721 }
22722
22723
22724 SWIGINTERN PyObject *FileConfig_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22725 PyObject *obj;
22726 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22727 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileConfig, SWIG_NewClientData(obj));
22728 return SWIG_Py_Void();
22729 }
22730
22731 SWIGINTERN PyObject *FileConfig_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22732 return SWIG_Python_InitShadowInstance(args);
22733 }
22734
22735 SWIGINTERN PyObject *_wrap_new_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22736 PyObject *resultobj = 0;
22737 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22738 wxString *arg2 = 0 ;
22739 wxConfigPathChanger *result = 0 ;
22740 void *argp1 = 0 ;
22741 int res1 = 0 ;
22742 bool temp2 = false ;
22743 PyObject * obj0 = 0 ;
22744 PyObject * obj1 = 0 ;
22745 char * kwnames[] = {
22746 (char *) "config",(char *) "entry", NULL
22747 };
22748
22749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) SWIG_fail;
22750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22751 if (!SWIG_IsOK(res1)) {
22752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22753 }
22754 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22755 {
22756 arg2 = wxString_in_helper(obj1);
22757 if (arg2 == NULL) SWIG_fail;
22758 temp2 = true;
22759 }
22760 {
22761 PyThreadState* __tstate = wxPyBeginAllowThreads();
22762 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
22763 wxPyEndAllowThreads(__tstate);
22764 if (PyErr_Occurred()) SWIG_fail;
22765 }
22766 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_NEW | 0 );
22767 {
22768 if (temp2)
22769 delete arg2;
22770 }
22771 return resultobj;
22772 fail:
22773 {
22774 if (temp2)
22775 delete arg2;
22776 }
22777 return NULL;
22778 }
22779
22780
22781 SWIGINTERN PyObject *_wrap_delete_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22782 PyObject *resultobj = 0;
22783 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
22784 void *argp1 = 0 ;
22785 int res1 = 0 ;
22786 PyObject *swig_obj[1] ;
22787
22788 if (!args) SWIG_fail;
22789 swig_obj[0] = args;
22790 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_DISOWN | 0 );
22791 if (!SWIG_IsOK(res1)) {
22792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigPathChanger *""'");
22793 }
22794 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
22795 {
22796 PyThreadState* __tstate = wxPyBeginAllowThreads();
22797 delete arg1;
22798
22799 wxPyEndAllowThreads(__tstate);
22800 if (PyErr_Occurred()) SWIG_fail;
22801 }
22802 resultobj = SWIG_Py_Void();
22803 return resultobj;
22804 fail:
22805 return NULL;
22806 }
22807
22808
22809 SWIGINTERN PyObject *_wrap_ConfigPathChanger_Name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22810 PyObject *resultobj = 0;
22811 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
22812 wxString *result = 0 ;
22813 void *argp1 = 0 ;
22814 int res1 = 0 ;
22815 PyObject *swig_obj[1] ;
22816
22817 if (!args) SWIG_fail;
22818 swig_obj[0] = args;
22819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, 0 | 0 );
22820 if (!SWIG_IsOK(res1)) {
22821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigPathChanger_Name" "', expected argument " "1"" of type '" "wxConfigPathChanger const *""'");
22822 }
22823 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
22824 {
22825 PyThreadState* __tstate = wxPyBeginAllowThreads();
22826 {
22827 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
22828 result = (wxString *) &_result_ref;
22829 }
22830 wxPyEndAllowThreads(__tstate);
22831 if (PyErr_Occurred()) SWIG_fail;
22832 }
22833 {
22834 #if wxUSE_UNICODE
22835 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
22836 #else
22837 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
22838 #endif
22839 }
22840 return resultobj;
22841 fail:
22842 return NULL;
22843 }
22844
22845
22846 SWIGINTERN PyObject *ConfigPathChanger_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22847 PyObject *obj;
22848 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22849 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigPathChanger, SWIG_NewClientData(obj));
22850 return SWIG_Py_Void();
22851 }
22852
22853 SWIGINTERN PyObject *ConfigPathChanger_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22854 return SWIG_Python_InitShadowInstance(args);
22855 }
22856
22857 SWIGINTERN PyObject *_wrap_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22858 PyObject *resultobj = 0;
22859 wxString *arg1 = 0 ;
22860 wxString result;
22861 bool temp1 = false ;
22862 PyObject * obj0 = 0 ;
22863 char * kwnames[] = {
22864 (char *) "sz", NULL
22865 };
22866
22867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) SWIG_fail;
22868 {
22869 arg1 = wxString_in_helper(obj0);
22870 if (arg1 == NULL) SWIG_fail;
22871 temp1 = true;
22872 }
22873 {
22874 PyThreadState* __tstate = wxPyBeginAllowThreads();
22875 result = wxExpandEnvVars((wxString const &)*arg1);
22876 wxPyEndAllowThreads(__tstate);
22877 if (PyErr_Occurred()) SWIG_fail;
22878 }
22879 {
22880 #if wxUSE_UNICODE
22881 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22882 #else
22883 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22884 #endif
22885 }
22886 {
22887 if (temp1)
22888 delete arg1;
22889 }
22890 return resultobj;
22891 fail:
22892 {
22893 if (temp1)
22894 delete arg1;
22895 }
22896 return NULL;
22897 }
22898
22899
22900 SWIGINTERN int DefaultDateTimeFormat_set(PyObject *) {
22901 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTimeFormat is read-only.");
22902 return 1;
22903 }
22904
22905
22906 SWIGINTERN PyObject *DefaultDateTimeFormat_get(void) {
22907 PyObject *pyobj = 0;
22908
22909 {
22910 #if wxUSE_UNICODE
22911 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
22912 #else
22913 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
22914 #endif
22915 }
22916 return pyobj;
22917 }
22918
22919
22920 SWIGINTERN int DefaultTimeSpanFormat_set(PyObject *) {
22921 SWIG_Error(SWIG_AttributeError,"Variable DefaultTimeSpanFormat is read-only.");
22922 return 1;
22923 }
22924
22925
22926 SWIGINTERN PyObject *DefaultTimeSpanFormat_get(void) {
22927 PyObject *pyobj = 0;
22928
22929 {
22930 #if wxUSE_UNICODE
22931 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
22932 #else
22933 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
22934 #endif
22935 }
22936 return pyobj;
22937 }
22938
22939
22940 SWIGINTERN PyObject *_wrap_DateTime_SetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22941 PyObject *resultobj = 0;
22942 wxDateTime::Country arg1 ;
22943 int val1 ;
22944 int ecode1 = 0 ;
22945 PyObject * obj0 = 0 ;
22946 char * kwnames[] = {
22947 (char *) "country", NULL
22948 };
22949
22950 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) SWIG_fail;
22951 ecode1 = SWIG_AsVal_int(obj0, &val1);
22952 if (!SWIG_IsOK(ecode1)) {
22953 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
22954 }
22955 arg1 = static_cast< wxDateTime::Country >(val1);
22956 {
22957 PyThreadState* __tstate = wxPyBeginAllowThreads();
22958 wxDateTime::SetCountry(arg1);
22959 wxPyEndAllowThreads(__tstate);
22960 if (PyErr_Occurred()) SWIG_fail;
22961 }
22962 resultobj = SWIG_Py_Void();
22963 return resultobj;
22964 fail:
22965 return NULL;
22966 }
22967
22968
22969 SWIGINTERN PyObject *_wrap_DateTime_GetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22970 PyObject *resultobj = 0;
22971 wxDateTime::Country result;
22972
22973 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetCountry",0,0,0)) SWIG_fail;
22974 {
22975 PyThreadState* __tstate = wxPyBeginAllowThreads();
22976 result = (wxDateTime::Country)wxDateTime::GetCountry();
22977 wxPyEndAllowThreads(__tstate);
22978 if (PyErr_Occurred()) SWIG_fail;
22979 }
22980 resultobj = SWIG_From_int(static_cast< int >(result));
22981 return resultobj;
22982 fail:
22983 return NULL;
22984 }
22985
22986
22987 SWIGINTERN PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22988 PyObject *resultobj = 0;
22989 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
22990 bool result;
22991 int val1 ;
22992 int ecode1 = 0 ;
22993 PyObject * obj0 = 0 ;
22994 char * kwnames[] = {
22995 (char *) "country", NULL
22996 };
22997
22998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) SWIG_fail;
22999 if (obj0) {
23000 ecode1 = SWIG_AsVal_int(obj0, &val1);
23001 if (!SWIG_IsOK(ecode1)) {
23002 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsWestEuropeanCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
23003 }
23004 arg1 = static_cast< wxDateTime::Country >(val1);
23005 }
23006 {
23007 PyThreadState* __tstate = wxPyBeginAllowThreads();
23008 result = (bool)wxDateTime::IsWestEuropeanCountry(arg1);
23009 wxPyEndAllowThreads(__tstate);
23010 if (PyErr_Occurred()) SWIG_fail;
23011 }
23012 {
23013 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23014 }
23015 return resultobj;
23016 fail:
23017 return NULL;
23018 }
23019
23020
23021 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23022 PyObject *resultobj = 0;
23023 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23024 int result;
23025 int val1 ;
23026 int ecode1 = 0 ;
23027 PyObject * obj0 = 0 ;
23028 char * kwnames[] = {
23029 (char *) "cal", NULL
23030 };
23031
23032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) SWIG_fail;
23033 if (obj0) {
23034 ecode1 = SWIG_AsVal_int(obj0, &val1);
23035 if (!SWIG_IsOK(ecode1)) {
23036 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentYear" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
23037 }
23038 arg1 = static_cast< wxDateTime::Calendar >(val1);
23039 }
23040 {
23041 PyThreadState* __tstate = wxPyBeginAllowThreads();
23042 result = (int)wxDateTime::GetCurrentYear(arg1);
23043 wxPyEndAllowThreads(__tstate);
23044 if (PyErr_Occurred()) SWIG_fail;
23045 }
23046 resultobj = SWIG_From_int(static_cast< int >(result));
23047 return resultobj;
23048 fail:
23049 return NULL;
23050 }
23051
23052
23053 SWIGINTERN PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23054 PyObject *resultobj = 0;
23055 int arg1 ;
23056 int result;
23057 int val1 ;
23058 int ecode1 = 0 ;
23059 PyObject * obj0 = 0 ;
23060 char * kwnames[] = {
23061 (char *) "year", NULL
23062 };
23063
23064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) SWIG_fail;
23065 ecode1 = SWIG_AsVal_int(obj0, &val1);
23066 if (!SWIG_IsOK(ecode1)) {
23067 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_ConvertYearToBC" "', expected argument " "1"" of type '" "int""'");
23068 }
23069 arg1 = static_cast< int >(val1);
23070 {
23071 PyThreadState* __tstate = wxPyBeginAllowThreads();
23072 result = (int)wxDateTime::ConvertYearToBC(arg1);
23073 wxPyEndAllowThreads(__tstate);
23074 if (PyErr_Occurred()) SWIG_fail;
23075 }
23076 resultobj = SWIG_From_int(static_cast< int >(result));
23077 return resultobj;
23078 fail:
23079 return NULL;
23080 }
23081
23082
23083 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23084 PyObject *resultobj = 0;
23085 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23086 wxDateTime::Month result;
23087 int val1 ;
23088 int ecode1 = 0 ;
23089 PyObject * obj0 = 0 ;
23090 char * kwnames[] = {
23091 (char *) "cal", NULL
23092 };
23093
23094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) SWIG_fail;
23095 if (obj0) {
23096 ecode1 = SWIG_AsVal_int(obj0, &val1);
23097 if (!SWIG_IsOK(ecode1)) {
23098 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentMonth" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
23099 }
23100 arg1 = static_cast< wxDateTime::Calendar >(val1);
23101 }
23102 {
23103 PyThreadState* __tstate = wxPyBeginAllowThreads();
23104 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth(arg1);
23105 wxPyEndAllowThreads(__tstate);
23106 if (PyErr_Occurred()) SWIG_fail;
23107 }
23108 resultobj = SWIG_From_int(static_cast< int >(result));
23109 return resultobj;
23110 fail:
23111 return NULL;
23112 }
23113
23114
23115 SWIGINTERN PyObject *_wrap_DateTime_IsLeapYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23116 PyObject *resultobj = 0;
23117 int arg1 = (int) wxDateTime::Inv_Year ;
23118 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23119 bool result;
23120 int val1 ;
23121 int ecode1 = 0 ;
23122 int val2 ;
23123 int ecode2 = 0 ;
23124 PyObject * obj0 = 0 ;
23125 PyObject * obj1 = 0 ;
23126 char * kwnames[] = {
23127 (char *) "year",(char *) "cal", NULL
23128 };
23129
23130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) SWIG_fail;
23131 if (obj0) {
23132 ecode1 = SWIG_AsVal_int(obj0, &val1);
23133 if (!SWIG_IsOK(ecode1)) {
23134 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsLeapYear" "', expected argument " "1"" of type '" "int""'");
23135 }
23136 arg1 = static_cast< int >(val1);
23137 }
23138 if (obj1) {
23139 ecode2 = SWIG_AsVal_int(obj1, &val2);
23140 if (!SWIG_IsOK(ecode2)) {
23141 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsLeapYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
23142 }
23143 arg2 = static_cast< wxDateTime::Calendar >(val2);
23144 }
23145 {
23146 PyThreadState* __tstate = wxPyBeginAllowThreads();
23147 result = (bool)wxDateTime::IsLeapYear(arg1,arg2);
23148 wxPyEndAllowThreads(__tstate);
23149 if (PyErr_Occurred()) SWIG_fail;
23150 }
23151 {
23152 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23153 }
23154 return resultobj;
23155 fail:
23156 return NULL;
23157 }
23158
23159
23160 SWIGINTERN PyObject *_wrap_DateTime_GetCentury(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23161 PyObject *resultobj = 0;
23162 int arg1 = (int) wxDateTime::Inv_Year ;
23163 int result;
23164 int val1 ;
23165 int ecode1 = 0 ;
23166 PyObject * obj0 = 0 ;
23167 char * kwnames[] = {
23168 (char *) "year", NULL
23169 };
23170
23171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) SWIG_fail;
23172 if (obj0) {
23173 ecode1 = SWIG_AsVal_int(obj0, &val1);
23174 if (!SWIG_IsOK(ecode1)) {
23175 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCentury" "', expected argument " "1"" of type '" "int""'");
23176 }
23177 arg1 = static_cast< int >(val1);
23178 }
23179 {
23180 PyThreadState* __tstate = wxPyBeginAllowThreads();
23181 result = (int)wxDateTime::GetCentury(arg1);
23182 wxPyEndAllowThreads(__tstate);
23183 if (PyErr_Occurred()) SWIG_fail;
23184 }
23185 resultobj = SWIG_From_int(static_cast< int >(result));
23186 return resultobj;
23187 fail:
23188 return NULL;
23189 }
23190
23191
23192 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23193 PyObject *resultobj = 0;
23194 int arg1 ;
23195 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23196 int result;
23197 int val1 ;
23198 int ecode1 = 0 ;
23199 int val2 ;
23200 int ecode2 = 0 ;
23201 PyObject * obj0 = 0 ;
23202 PyObject * obj1 = 0 ;
23203 char * kwnames[] = {
23204 (char *) "year",(char *) "cal", NULL
23205 };
23206
23207 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) SWIG_fail;
23208 ecode1 = SWIG_AsVal_int(obj0, &val1);
23209 if (!SWIG_IsOK(ecode1)) {
23210 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "1"" of type '" "int""'");
23211 }
23212 arg1 = static_cast< int >(val1);
23213 if (obj1) {
23214 ecode2 = SWIG_AsVal_int(obj1, &val2);
23215 if (!SWIG_IsOK(ecode2)) {
23216 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
23217 }
23218 arg2 = static_cast< wxDateTime::Calendar >(val2);
23219 }
23220 {
23221 PyThreadState* __tstate = wxPyBeginAllowThreads();
23222 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2);
23223 wxPyEndAllowThreads(__tstate);
23224 if (PyErr_Occurred()) SWIG_fail;
23225 }
23226 resultobj = SWIG_From_int(static_cast< int >(result));
23227 return resultobj;
23228 fail:
23229 return NULL;
23230 }
23231
23232
23233 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23234 PyObject *resultobj = 0;
23235 wxDateTime::Month arg1 ;
23236 int arg2 = (int) wxDateTime::Inv_Year ;
23237 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23238 int result;
23239 int val1 ;
23240 int ecode1 = 0 ;
23241 int val2 ;
23242 int ecode2 = 0 ;
23243 int val3 ;
23244 int ecode3 = 0 ;
23245 PyObject * obj0 = 0 ;
23246 PyObject * obj1 = 0 ;
23247 PyObject * obj2 = 0 ;
23248 char * kwnames[] = {
23249 (char *) "month",(char *) "year",(char *) "cal", NULL
23250 };
23251
23252 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23253 ecode1 = SWIG_AsVal_int(obj0, &val1);
23254 if (!SWIG_IsOK(ecode1)) {
23255 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
23256 }
23257 arg1 = static_cast< wxDateTime::Month >(val1);
23258 if (obj1) {
23259 ecode2 = SWIG_AsVal_int(obj1, &val2);
23260 if (!SWIG_IsOK(ecode2)) {
23261 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "2"" of type '" "int""'");
23262 }
23263 arg2 = static_cast< int >(val2);
23264 }
23265 if (obj2) {
23266 ecode3 = SWIG_AsVal_int(obj2, &val3);
23267 if (!SWIG_IsOK(ecode3)) {
23268 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "3"" of type '" "wxDateTime::Calendar""'");
23269 }
23270 arg3 = static_cast< wxDateTime::Calendar >(val3);
23271 }
23272 {
23273 PyThreadState* __tstate = wxPyBeginAllowThreads();
23274 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2,arg3);
23275 wxPyEndAllowThreads(__tstate);
23276 if (PyErr_Occurred()) SWIG_fail;
23277 }
23278 resultobj = SWIG_From_int(static_cast< int >(result));
23279 return resultobj;
23280 fail:
23281 return NULL;
23282 }
23283
23284
23285 SWIGINTERN PyObject *_wrap_DateTime_GetMonthName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23286 PyObject *resultobj = 0;
23287 wxDateTime::Month arg1 ;
23288 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
23289 wxString result;
23290 int val1 ;
23291 int ecode1 = 0 ;
23292 int val2 ;
23293 int ecode2 = 0 ;
23294 PyObject * obj0 = 0 ;
23295 PyObject * obj1 = 0 ;
23296 char * kwnames[] = {
23297 (char *) "month",(char *) "flags", NULL
23298 };
23299
23300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) SWIG_fail;
23301 ecode1 = SWIG_AsVal_int(obj0, &val1);
23302 if (!SWIG_IsOK(ecode1)) {
23303 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetMonthName" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
23304 }
23305 arg1 = static_cast< wxDateTime::Month >(val1);
23306 if (obj1) {
23307 ecode2 = SWIG_AsVal_int(obj1, &val2);
23308 if (!SWIG_IsOK(ecode2)) {
23309 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetMonthName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
23310 }
23311 arg2 = static_cast< wxDateTime::NameFlags >(val2);
23312 }
23313 {
23314 PyThreadState* __tstate = wxPyBeginAllowThreads();
23315 result = wxDateTime::GetMonthName(arg1,arg2);
23316 wxPyEndAllowThreads(__tstate);
23317 if (PyErr_Occurred()) SWIG_fail;
23318 }
23319 {
23320 #if wxUSE_UNICODE
23321 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23322 #else
23323 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23324 #endif
23325 }
23326 return resultobj;
23327 fail:
23328 return NULL;
23329 }
23330
23331
23332 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23333 PyObject *resultobj = 0;
23334 wxDateTime::WeekDay arg1 ;
23335 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
23336 wxString result;
23337 int val1 ;
23338 int ecode1 = 0 ;
23339 int val2 ;
23340 int ecode2 = 0 ;
23341 PyObject * obj0 = 0 ;
23342 PyObject * obj1 = 0 ;
23343 char * kwnames[] = {
23344 (char *) "weekday",(char *) "flags", NULL
23345 };
23346
23347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) SWIG_fail;
23348 ecode1 = SWIG_AsVal_int(obj0, &val1);
23349 if (!SWIG_IsOK(ecode1)) {
23350 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetWeekDayName" "', expected argument " "1"" of type '" "wxDateTime::WeekDay""'");
23351 }
23352 arg1 = static_cast< wxDateTime::WeekDay >(val1);
23353 if (obj1) {
23354 ecode2 = SWIG_AsVal_int(obj1, &val2);
23355 if (!SWIG_IsOK(ecode2)) {
23356 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
23357 }
23358 arg2 = static_cast< wxDateTime::NameFlags >(val2);
23359 }
23360 {
23361 PyThreadState* __tstate = wxPyBeginAllowThreads();
23362 result = wxDateTime::GetWeekDayName(arg1,arg2);
23363 wxPyEndAllowThreads(__tstate);
23364 if (PyErr_Occurred()) SWIG_fail;
23365 }
23366 {
23367 #if wxUSE_UNICODE
23368 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23369 #else
23370 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23371 #endif
23372 }
23373 return resultobj;
23374 fail:
23375 return NULL;
23376 }
23377
23378
23379 SWIGINTERN PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23380 PyObject *resultobj = 0;
23381 PyObject *result = 0 ;
23382
23383 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetAmPmStrings",0,0,0)) SWIG_fail;
23384 {
23385 PyThreadState* __tstate = wxPyBeginAllowThreads();
23386 result = (PyObject *)wxDateTime_GetAmPmStrings();
23387 wxPyEndAllowThreads(__tstate);
23388 if (PyErr_Occurred()) SWIG_fail;
23389 }
23390 resultobj = result;
23391 return resultobj;
23392 fail:
23393 return NULL;
23394 }
23395
23396
23397 SWIGINTERN PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23398 PyObject *resultobj = 0;
23399 int arg1 = (int) wxDateTime::Inv_Year ;
23400 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23401 bool result;
23402 int val1 ;
23403 int ecode1 = 0 ;
23404 int val2 ;
23405 int ecode2 = 0 ;
23406 PyObject * obj0 = 0 ;
23407 PyObject * obj1 = 0 ;
23408 char * kwnames[] = {
23409 (char *) "year",(char *) "country", NULL
23410 };
23411
23412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) SWIG_fail;
23413 if (obj0) {
23414 ecode1 = SWIG_AsVal_int(obj0, &val1);
23415 if (!SWIG_IsOK(ecode1)) {
23416 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "1"" of type '" "int""'");
23417 }
23418 arg1 = static_cast< int >(val1);
23419 }
23420 if (obj1) {
23421 ecode2 = SWIG_AsVal_int(obj1, &val2);
23422 if (!SWIG_IsOK(ecode2)) {
23423 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23424 }
23425 arg2 = static_cast< wxDateTime::Country >(val2);
23426 }
23427 {
23428 PyThreadState* __tstate = wxPyBeginAllowThreads();
23429 result = (bool)wxDateTime::IsDSTApplicable(arg1,arg2);
23430 wxPyEndAllowThreads(__tstate);
23431 if (PyErr_Occurred()) SWIG_fail;
23432 }
23433 {
23434 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23435 }
23436 return resultobj;
23437 fail:
23438 return NULL;
23439 }
23440
23441
23442 SWIGINTERN PyObject *_wrap_DateTime_GetBeginDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23443 PyObject *resultobj = 0;
23444 int arg1 = (int) wxDateTime::Inv_Year ;
23445 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23446 wxDateTime result;
23447 int val1 ;
23448 int ecode1 = 0 ;
23449 int val2 ;
23450 int ecode2 = 0 ;
23451 PyObject * obj0 = 0 ;
23452 PyObject * obj1 = 0 ;
23453 char * kwnames[] = {
23454 (char *) "year",(char *) "country", NULL
23455 };
23456
23457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) SWIG_fail;
23458 if (obj0) {
23459 ecode1 = SWIG_AsVal_int(obj0, &val1);
23460 if (!SWIG_IsOK(ecode1)) {
23461 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetBeginDST" "', expected argument " "1"" of type '" "int""'");
23462 }
23463 arg1 = static_cast< int >(val1);
23464 }
23465 if (obj1) {
23466 ecode2 = SWIG_AsVal_int(obj1, &val2);
23467 if (!SWIG_IsOK(ecode2)) {
23468 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetBeginDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23469 }
23470 arg2 = static_cast< wxDateTime::Country >(val2);
23471 }
23472 {
23473 PyThreadState* __tstate = wxPyBeginAllowThreads();
23474 result = wxDateTime::GetBeginDST(arg1,arg2);
23475 wxPyEndAllowThreads(__tstate);
23476 if (PyErr_Occurred()) SWIG_fail;
23477 }
23478 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23479 return resultobj;
23480 fail:
23481 return NULL;
23482 }
23483
23484
23485 SWIGINTERN PyObject *_wrap_DateTime_GetEndDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23486 PyObject *resultobj = 0;
23487 int arg1 = (int) wxDateTime::Inv_Year ;
23488 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23489 wxDateTime result;
23490 int val1 ;
23491 int ecode1 = 0 ;
23492 int val2 ;
23493 int ecode2 = 0 ;
23494 PyObject * obj0 = 0 ;
23495 PyObject * obj1 = 0 ;
23496 char * kwnames[] = {
23497 (char *) "year",(char *) "country", NULL
23498 };
23499
23500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) SWIG_fail;
23501 if (obj0) {
23502 ecode1 = SWIG_AsVal_int(obj0, &val1);
23503 if (!SWIG_IsOK(ecode1)) {
23504 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetEndDST" "', expected argument " "1"" of type '" "int""'");
23505 }
23506 arg1 = static_cast< int >(val1);
23507 }
23508 if (obj1) {
23509 ecode2 = SWIG_AsVal_int(obj1, &val2);
23510 if (!SWIG_IsOK(ecode2)) {
23511 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetEndDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23512 }
23513 arg2 = static_cast< wxDateTime::Country >(val2);
23514 }
23515 {
23516 PyThreadState* __tstate = wxPyBeginAllowThreads();
23517 result = wxDateTime::GetEndDST(arg1,arg2);
23518 wxPyEndAllowThreads(__tstate);
23519 if (PyErr_Occurred()) SWIG_fail;
23520 }
23521 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23522 return resultobj;
23523 fail:
23524 return NULL;
23525 }
23526
23527
23528 SWIGINTERN PyObject *_wrap_DateTime_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23529 PyObject *resultobj = 0;
23530 wxDateTime result;
23531
23532 if (!SWIG_Python_UnpackTuple(args,"DateTime_Now",0,0,0)) SWIG_fail;
23533 {
23534 PyThreadState* __tstate = wxPyBeginAllowThreads();
23535 result = wxDateTime::Now();
23536 wxPyEndAllowThreads(__tstate);
23537 if (PyErr_Occurred()) SWIG_fail;
23538 }
23539 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23540 return resultobj;
23541 fail:
23542 return NULL;
23543 }
23544
23545
23546 SWIGINTERN PyObject *_wrap_DateTime_UNow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23547 PyObject *resultobj = 0;
23548 wxDateTime result;
23549
23550 if (!SWIG_Python_UnpackTuple(args,"DateTime_UNow",0,0,0)) SWIG_fail;
23551 {
23552 PyThreadState* __tstate = wxPyBeginAllowThreads();
23553 result = wxDateTime::UNow();
23554 wxPyEndAllowThreads(__tstate);
23555 if (PyErr_Occurred()) SWIG_fail;
23556 }
23557 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23558 return resultobj;
23559 fail:
23560 return NULL;
23561 }
23562
23563
23564 SWIGINTERN PyObject *_wrap_DateTime_Today(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23565 PyObject *resultobj = 0;
23566 wxDateTime result;
23567
23568 if (!SWIG_Python_UnpackTuple(args,"DateTime_Today",0,0,0)) SWIG_fail;
23569 {
23570 PyThreadState* __tstate = wxPyBeginAllowThreads();
23571 result = wxDateTime::Today();
23572 wxPyEndAllowThreads(__tstate);
23573 if (PyErr_Occurred()) SWIG_fail;
23574 }
23575 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23576 return resultobj;
23577 fail:
23578 return NULL;
23579 }
23580
23581
23582 SWIGINTERN PyObject *_wrap_new_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23583 PyObject *resultobj = 0;
23584 wxDateTime *result = 0 ;
23585
23586 if (!SWIG_Python_UnpackTuple(args,"new_DateTime",0,0,0)) SWIG_fail;
23587 {
23588 PyThreadState* __tstate = wxPyBeginAllowThreads();
23589 result = (wxDateTime *)new wxDateTime();
23590 wxPyEndAllowThreads(__tstate);
23591 if (PyErr_Occurred()) SWIG_fail;
23592 }
23593 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_NEW | 0 );
23594 return resultobj;
23595 fail:
23596 return NULL;
23597 }
23598
23599
23600 SWIGINTERN PyObject *_wrap_new_DateTimeFromTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23601 PyObject *resultobj = 0;
23602 time_t arg1 ;
23603 wxDateTime *result = 0 ;
23604 unsigned int val1 ;
23605 int ecode1 = 0 ;
23606 PyObject * obj0 = 0 ;
23607 char * kwnames[] = {
23608 (char *) "timet", NULL
23609 };
23610
23611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) SWIG_fail;
23612 ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
23613 if (!SWIG_IsOK(ecode1)) {
23614 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromTimeT" "', expected argument " "1"" of type '" "time_t""'");
23615 }
23616 arg1 = static_cast< time_t >(val1);
23617 {
23618 PyThreadState* __tstate = wxPyBeginAllowThreads();
23619 result = (wxDateTime *)new wxDateTime(arg1);
23620 wxPyEndAllowThreads(__tstate);
23621 if (PyErr_Occurred()) SWIG_fail;
23622 }
23623 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23624 return resultobj;
23625 fail:
23626 return NULL;
23627 }
23628
23629
23630 SWIGINTERN PyObject *_wrap_new_DateTimeFromJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23631 PyObject *resultobj = 0;
23632 double arg1 ;
23633 wxDateTime *result = 0 ;
23634 double val1 ;
23635 int ecode1 = 0 ;
23636 PyObject * obj0 = 0 ;
23637 char * kwnames[] = {
23638 (char *) "jdn", NULL
23639 };
23640
23641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) SWIG_fail;
23642 ecode1 = SWIG_AsVal_double(obj0, &val1);
23643 if (!SWIG_IsOK(ecode1)) {
23644 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromJDN" "', expected argument " "1"" of type '" "double""'");
23645 }
23646 arg1 = static_cast< double >(val1);
23647 {
23648 PyThreadState* __tstate = wxPyBeginAllowThreads();
23649 result = (wxDateTime *)new wxDateTime(arg1);
23650 wxPyEndAllowThreads(__tstate);
23651 if (PyErr_Occurred()) SWIG_fail;
23652 }
23653 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23654 return resultobj;
23655 fail:
23656 return NULL;
23657 }
23658
23659
23660 SWIGINTERN PyObject *_wrap_new_DateTimeFromHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23661 PyObject *resultobj = 0;
23662 int arg1 ;
23663 int arg2 = (int) 0 ;
23664 int arg3 = (int) 0 ;
23665 int arg4 = (int) 0 ;
23666 wxDateTime *result = 0 ;
23667 int val1 ;
23668 int ecode1 = 0 ;
23669 int val2 ;
23670 int ecode2 = 0 ;
23671 int val3 ;
23672 int ecode3 = 0 ;
23673 int val4 ;
23674 int ecode4 = 0 ;
23675 PyObject * obj0 = 0 ;
23676 PyObject * obj1 = 0 ;
23677 PyObject * obj2 = 0 ;
23678 PyObject * obj3 = 0 ;
23679 char * kwnames[] = {
23680 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
23681 };
23682
23683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23684 ecode1 = SWIG_AsVal_int(obj0, &val1);
23685 if (!SWIG_IsOK(ecode1)) {
23686 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromHMS" "', expected argument " "1"" of type '" "int""'");
23687 }
23688 arg1 = static_cast< int >(val1);
23689 if (obj1) {
23690 ecode2 = SWIG_AsVal_int(obj1, &val2);
23691 if (!SWIG_IsOK(ecode2)) {
23692 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromHMS" "', expected argument " "2"" of type '" "int""'");
23693 }
23694 arg2 = static_cast< int >(val2);
23695 }
23696 if (obj2) {
23697 ecode3 = SWIG_AsVal_int(obj2, &val3);
23698 if (!SWIG_IsOK(ecode3)) {
23699 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromHMS" "', expected argument " "3"" of type '" "int""'");
23700 }
23701 arg3 = static_cast< int >(val3);
23702 }
23703 if (obj3) {
23704 ecode4 = SWIG_AsVal_int(obj3, &val4);
23705 if (!SWIG_IsOK(ecode4)) {
23706 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromHMS" "', expected argument " "4"" of type '" "int""'");
23707 }
23708 arg4 = static_cast< int >(val4);
23709 }
23710 {
23711 PyThreadState* __tstate = wxPyBeginAllowThreads();
23712 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
23713 wxPyEndAllowThreads(__tstate);
23714 if (PyErr_Occurred()) SWIG_fail;
23715 }
23716 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23717 return resultobj;
23718 fail:
23719 return NULL;
23720 }
23721
23722
23723 SWIGINTERN PyObject *_wrap_new_DateTimeFromDMY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23724 PyObject *resultobj = 0;
23725 int arg1 ;
23726 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23727 int arg3 = (int) wxDateTime::Inv_Year ;
23728 int arg4 = (int) 0 ;
23729 int arg5 = (int) 0 ;
23730 int arg6 = (int) 0 ;
23731 int arg7 = (int) 0 ;
23732 wxDateTime *result = 0 ;
23733 int val1 ;
23734 int ecode1 = 0 ;
23735 int val2 ;
23736 int ecode2 = 0 ;
23737 int val3 ;
23738 int ecode3 = 0 ;
23739 int val4 ;
23740 int ecode4 = 0 ;
23741 int val5 ;
23742 int ecode5 = 0 ;
23743 int val6 ;
23744 int ecode6 = 0 ;
23745 int val7 ;
23746 int ecode7 = 0 ;
23747 PyObject * obj0 = 0 ;
23748 PyObject * obj1 = 0 ;
23749 PyObject * obj2 = 0 ;
23750 PyObject * obj3 = 0 ;
23751 PyObject * obj4 = 0 ;
23752 PyObject * obj5 = 0 ;
23753 PyObject * obj6 = 0 ;
23754 char * kwnames[] = {
23755 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
23756 };
23757
23758 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
23759 ecode1 = SWIG_AsVal_int(obj0, &val1);
23760 if (!SWIG_IsOK(ecode1)) {
23761 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromDMY" "', expected argument " "1"" of type '" "int""'");
23762 }
23763 arg1 = static_cast< int >(val1);
23764 if (obj1) {
23765 ecode2 = SWIG_AsVal_int(obj1, &val2);
23766 if (!SWIG_IsOK(ecode2)) {
23767 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromDMY" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
23768 }
23769 arg2 = static_cast< wxDateTime::Month >(val2);
23770 }
23771 if (obj2) {
23772 ecode3 = SWIG_AsVal_int(obj2, &val3);
23773 if (!SWIG_IsOK(ecode3)) {
23774 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromDMY" "', expected argument " "3"" of type '" "int""'");
23775 }
23776 arg3 = static_cast< int >(val3);
23777 }
23778 if (obj3) {
23779 ecode4 = SWIG_AsVal_int(obj3, &val4);
23780 if (!SWIG_IsOK(ecode4)) {
23781 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromDMY" "', expected argument " "4"" of type '" "int""'");
23782 }
23783 arg4 = static_cast< int >(val4);
23784 }
23785 if (obj4) {
23786 ecode5 = SWIG_AsVal_int(obj4, &val5);
23787 if (!SWIG_IsOK(ecode5)) {
23788 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DateTimeFromDMY" "', expected argument " "5"" of type '" "int""'");
23789 }
23790 arg5 = static_cast< int >(val5);
23791 }
23792 if (obj5) {
23793 ecode6 = SWIG_AsVal_int(obj5, &val6);
23794 if (!SWIG_IsOK(ecode6)) {
23795 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DateTimeFromDMY" "', expected argument " "6"" of type '" "int""'");
23796 }
23797 arg6 = static_cast< int >(val6);
23798 }
23799 if (obj6) {
23800 ecode7 = SWIG_AsVal_int(obj6, &val7);
23801 if (!SWIG_IsOK(ecode7)) {
23802 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_DateTimeFromDMY" "', expected argument " "7"" of type '" "int""'");
23803 }
23804 arg7 = static_cast< int >(val7);
23805 }
23806 {
23807 PyThreadState* __tstate = wxPyBeginAllowThreads();
23808 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
23809 wxPyEndAllowThreads(__tstate);
23810 if (PyErr_Occurred()) SWIG_fail;
23811 }
23812 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23813 return resultobj;
23814 fail:
23815 return NULL;
23816 }
23817
23818
23819 SWIGINTERN PyObject *_wrap_new_DateTimeFromDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23820 PyObject *resultobj = 0;
23821 wxDateTime *arg1 = 0 ;
23822 wxDateTime *result = 0 ;
23823 void *argp1 = 0 ;
23824 int res1 = 0 ;
23825 PyObject * obj0 = 0 ;
23826 char * kwnames[] = {
23827 (char *) "date", NULL
23828 };
23829
23830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromDateTime",kwnames,&obj0)) SWIG_fail;
23831 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDateTime, 0 | 0);
23832 if (!SWIG_IsOK(res1)) {
23833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
23834 }
23835 if (!argp1) {
23836 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
23837 }
23838 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23839 {
23840 PyThreadState* __tstate = wxPyBeginAllowThreads();
23841 result = (wxDateTime *)new wxDateTime((wxDateTime const &)*arg1);
23842 wxPyEndAllowThreads(__tstate);
23843 if (PyErr_Occurred()) SWIG_fail;
23844 }
23845 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23846 return resultobj;
23847 fail:
23848 return NULL;
23849 }
23850
23851
23852 SWIGINTERN PyObject *_wrap_delete_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23853 PyObject *resultobj = 0;
23854 wxDateTime *arg1 = (wxDateTime *) 0 ;
23855 void *argp1 = 0 ;
23856 int res1 = 0 ;
23857 PyObject *swig_obj[1] ;
23858
23859 if (!args) SWIG_fail;
23860 swig_obj[0] = args;
23861 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
23862 if (!SWIG_IsOK(res1)) {
23863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
23864 }
23865 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23866 {
23867 PyThreadState* __tstate = wxPyBeginAllowThreads();
23868 delete arg1;
23869
23870 wxPyEndAllowThreads(__tstate);
23871 if (PyErr_Occurred()) SWIG_fail;
23872 }
23873 resultobj = SWIG_Py_Void();
23874 return resultobj;
23875 fail:
23876 return NULL;
23877 }
23878
23879
23880 SWIGINTERN PyObject *_wrap_DateTime_SetToCurrent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23881 PyObject *resultobj = 0;
23882 wxDateTime *arg1 = (wxDateTime *) 0 ;
23883 wxDateTime *result = 0 ;
23884 void *argp1 = 0 ;
23885 int res1 = 0 ;
23886 PyObject *swig_obj[1] ;
23887
23888 if (!args) SWIG_fail;
23889 swig_obj[0] = args;
23890 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23891 if (!SWIG_IsOK(res1)) {
23892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToCurrent" "', expected argument " "1"" of type '" "wxDateTime *""'");
23893 }
23894 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23895 {
23896 PyThreadState* __tstate = wxPyBeginAllowThreads();
23897 {
23898 wxDateTime &_result_ref = (arg1)->SetToCurrent();
23899 result = (wxDateTime *) &_result_ref;
23900 }
23901 wxPyEndAllowThreads(__tstate);
23902 if (PyErr_Occurred()) SWIG_fail;
23903 }
23904 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23905 return resultobj;
23906 fail:
23907 return NULL;
23908 }
23909
23910
23911 SWIGINTERN PyObject *_wrap_DateTime_SetTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23912 PyObject *resultobj = 0;
23913 wxDateTime *arg1 = (wxDateTime *) 0 ;
23914 time_t arg2 ;
23915 wxDateTime *result = 0 ;
23916 void *argp1 = 0 ;
23917 int res1 = 0 ;
23918 unsigned int val2 ;
23919 int ecode2 = 0 ;
23920 PyObject * obj0 = 0 ;
23921 PyObject * obj1 = 0 ;
23922 char * kwnames[] = {
23923 (char *) "self",(char *) "timet", NULL
23924 };
23925
23926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) SWIG_fail;
23927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23928 if (!SWIG_IsOK(res1)) {
23929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetTimeT" "', expected argument " "1"" of type '" "wxDateTime *""'");
23930 }
23931 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23932 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
23933 if (!SWIG_IsOK(ecode2)) {
23934 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetTimeT" "', expected argument " "2"" of type '" "time_t""'");
23935 }
23936 arg2 = static_cast< time_t >(val2);
23937 {
23938 PyThreadState* __tstate = wxPyBeginAllowThreads();
23939 {
23940 wxDateTime &_result_ref = (arg1)->Set(arg2);
23941 result = (wxDateTime *) &_result_ref;
23942 }
23943 wxPyEndAllowThreads(__tstate);
23944 if (PyErr_Occurred()) SWIG_fail;
23945 }
23946 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23947 return resultobj;
23948 fail:
23949 return NULL;
23950 }
23951
23952
23953 SWIGINTERN PyObject *_wrap_DateTime_SetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23954 PyObject *resultobj = 0;
23955 wxDateTime *arg1 = (wxDateTime *) 0 ;
23956 double arg2 ;
23957 wxDateTime *result = 0 ;
23958 void *argp1 = 0 ;
23959 int res1 = 0 ;
23960 double val2 ;
23961 int ecode2 = 0 ;
23962 PyObject * obj0 = 0 ;
23963 PyObject * obj1 = 0 ;
23964 char * kwnames[] = {
23965 (char *) "self",(char *) "jdn", NULL
23966 };
23967
23968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) SWIG_fail;
23969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23970 if (!SWIG_IsOK(res1)) {
23971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
23972 }
23973 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23974 ecode2 = SWIG_AsVal_double(obj1, &val2);
23975 if (!SWIG_IsOK(ecode2)) {
23976 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetJDN" "', expected argument " "2"" of type '" "double""'");
23977 }
23978 arg2 = static_cast< double >(val2);
23979 {
23980 PyThreadState* __tstate = wxPyBeginAllowThreads();
23981 {
23982 wxDateTime &_result_ref = (arg1)->Set(arg2);
23983 result = (wxDateTime *) &_result_ref;
23984 }
23985 wxPyEndAllowThreads(__tstate);
23986 if (PyErr_Occurred()) SWIG_fail;
23987 }
23988 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23989 return resultobj;
23990 fail:
23991 return NULL;
23992 }
23993
23994
23995 SWIGINTERN PyObject *_wrap_DateTime_SetHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23996 PyObject *resultobj = 0;
23997 wxDateTime *arg1 = (wxDateTime *) 0 ;
23998 int arg2 ;
23999 int arg3 = (int) 0 ;
24000 int arg4 = (int) 0 ;
24001 int arg5 = (int) 0 ;
24002 wxDateTime *result = 0 ;
24003 void *argp1 = 0 ;
24004 int res1 = 0 ;
24005 int val2 ;
24006 int ecode2 = 0 ;
24007 int val3 ;
24008 int ecode3 = 0 ;
24009 int val4 ;
24010 int ecode4 = 0 ;
24011 int val5 ;
24012 int ecode5 = 0 ;
24013 PyObject * obj0 = 0 ;
24014 PyObject * obj1 = 0 ;
24015 PyObject * obj2 = 0 ;
24016 PyObject * obj3 = 0 ;
24017 PyObject * obj4 = 0 ;
24018 char * kwnames[] = {
24019 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
24020 };
24021
24022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
24023 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24024 if (!SWIG_IsOK(res1)) {
24025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHMS" "', expected argument " "1"" of type '" "wxDateTime *""'");
24026 }
24027 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24028 ecode2 = SWIG_AsVal_int(obj1, &val2);
24029 if (!SWIG_IsOK(ecode2)) {
24030 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHMS" "', expected argument " "2"" of type '" "int""'");
24031 }
24032 arg2 = static_cast< int >(val2);
24033 if (obj2) {
24034 ecode3 = SWIG_AsVal_int(obj2, &val3);
24035 if (!SWIG_IsOK(ecode3)) {
24036 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetHMS" "', expected argument " "3"" of type '" "int""'");
24037 }
24038 arg3 = static_cast< int >(val3);
24039 }
24040 if (obj3) {
24041 ecode4 = SWIG_AsVal_int(obj3, &val4);
24042 if (!SWIG_IsOK(ecode4)) {
24043 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetHMS" "', expected argument " "4"" of type '" "int""'");
24044 }
24045 arg4 = static_cast< int >(val4);
24046 }
24047 if (obj4) {
24048 ecode5 = SWIG_AsVal_int(obj4, &val5);
24049 if (!SWIG_IsOK(ecode5)) {
24050 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetHMS" "', expected argument " "5"" of type '" "int""'");
24051 }
24052 arg5 = static_cast< int >(val5);
24053 }
24054 {
24055 PyThreadState* __tstate = wxPyBeginAllowThreads();
24056 {
24057 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
24058 result = (wxDateTime *) &_result_ref;
24059 }
24060 wxPyEndAllowThreads(__tstate);
24061 if (PyErr_Occurred()) SWIG_fail;
24062 }
24063 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24064 return resultobj;
24065 fail:
24066 return NULL;
24067 }
24068
24069
24070 SWIGINTERN PyObject *_wrap_DateTime_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24071 PyObject *resultobj = 0;
24072 wxDateTime *arg1 = (wxDateTime *) 0 ;
24073 int arg2 ;
24074 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24075 int arg4 = (int) wxDateTime::Inv_Year ;
24076 int arg5 = (int) 0 ;
24077 int arg6 = (int) 0 ;
24078 int arg7 = (int) 0 ;
24079 int arg8 = (int) 0 ;
24080 wxDateTime *result = 0 ;
24081 void *argp1 = 0 ;
24082 int res1 = 0 ;
24083 int val2 ;
24084 int ecode2 = 0 ;
24085 int val3 ;
24086 int ecode3 = 0 ;
24087 int val4 ;
24088 int ecode4 = 0 ;
24089 int val5 ;
24090 int ecode5 = 0 ;
24091 int val6 ;
24092 int ecode6 = 0 ;
24093 int val7 ;
24094 int ecode7 = 0 ;
24095 int val8 ;
24096 int ecode8 = 0 ;
24097 PyObject * obj0 = 0 ;
24098 PyObject * obj1 = 0 ;
24099 PyObject * obj2 = 0 ;
24100 PyObject * obj3 = 0 ;
24101 PyObject * obj4 = 0 ;
24102 PyObject * obj5 = 0 ;
24103 PyObject * obj6 = 0 ;
24104 PyObject * obj7 = 0 ;
24105 char * kwnames[] = {
24106 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
24107 };
24108
24109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
24110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24111 if (!SWIG_IsOK(res1)) {
24112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Set" "', expected argument " "1"" of type '" "wxDateTime *""'");
24113 }
24114 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24115 ecode2 = SWIG_AsVal_int(obj1, &val2);
24116 if (!SWIG_IsOK(ecode2)) {
24117 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_Set" "', expected argument " "2"" of type '" "int""'");
24118 }
24119 arg2 = static_cast< int >(val2);
24120 if (obj2) {
24121 ecode3 = SWIG_AsVal_int(obj2, &val3);
24122 if (!SWIG_IsOK(ecode3)) {
24123 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_Set" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
24124 }
24125 arg3 = static_cast< wxDateTime::Month >(val3);
24126 }
24127 if (obj3) {
24128 ecode4 = SWIG_AsVal_int(obj3, &val4);
24129 if (!SWIG_IsOK(ecode4)) {
24130 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_Set" "', expected argument " "4"" of type '" "int""'");
24131 }
24132 arg4 = static_cast< int >(val4);
24133 }
24134 if (obj4) {
24135 ecode5 = SWIG_AsVal_int(obj4, &val5);
24136 if (!SWIG_IsOK(ecode5)) {
24137 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_Set" "', expected argument " "5"" of type '" "int""'");
24138 }
24139 arg5 = static_cast< int >(val5);
24140 }
24141 if (obj5) {
24142 ecode6 = SWIG_AsVal_int(obj5, &val6);
24143 if (!SWIG_IsOK(ecode6)) {
24144 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DateTime_Set" "', expected argument " "6"" of type '" "int""'");
24145 }
24146 arg6 = static_cast< int >(val6);
24147 }
24148 if (obj6) {
24149 ecode7 = SWIG_AsVal_int(obj6, &val7);
24150 if (!SWIG_IsOK(ecode7)) {
24151 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "DateTime_Set" "', expected argument " "7"" of type '" "int""'");
24152 }
24153 arg7 = static_cast< int >(val7);
24154 }
24155 if (obj7) {
24156 ecode8 = SWIG_AsVal_int(obj7, &val8);
24157 if (!SWIG_IsOK(ecode8)) {
24158 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "DateTime_Set" "', expected argument " "8"" of type '" "int""'");
24159 }
24160 arg8 = static_cast< int >(val8);
24161 }
24162 {
24163 PyThreadState* __tstate = wxPyBeginAllowThreads();
24164 {
24165 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
24166 result = (wxDateTime *) &_result_ref;
24167 }
24168 wxPyEndAllowThreads(__tstate);
24169 if (PyErr_Occurred()) SWIG_fail;
24170 }
24171 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24172 return resultobj;
24173 fail:
24174 return NULL;
24175 }
24176
24177
24178 SWIGINTERN PyObject *_wrap_DateTime_ResetTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24179 PyObject *resultobj = 0;
24180 wxDateTime *arg1 = (wxDateTime *) 0 ;
24181 wxDateTime *result = 0 ;
24182 void *argp1 = 0 ;
24183 int res1 = 0 ;
24184 PyObject *swig_obj[1] ;
24185
24186 if (!args) SWIG_fail;
24187 swig_obj[0] = args;
24188 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24189 if (!SWIG_IsOK(res1)) {
24190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ResetTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
24191 }
24192 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24193 {
24194 PyThreadState* __tstate = wxPyBeginAllowThreads();
24195 {
24196 wxDateTime &_result_ref = (arg1)->ResetTime();
24197 result = (wxDateTime *) &_result_ref;
24198 }
24199 wxPyEndAllowThreads(__tstate);
24200 if (PyErr_Occurred()) SWIG_fail;
24201 }
24202 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24203 return resultobj;
24204 fail:
24205 return NULL;
24206 }
24207
24208
24209 SWIGINTERN PyObject *_wrap_DateTime_SetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24210 PyObject *resultobj = 0;
24211 wxDateTime *arg1 = (wxDateTime *) 0 ;
24212 int arg2 ;
24213 wxDateTime *result = 0 ;
24214 void *argp1 = 0 ;
24215 int res1 = 0 ;
24216 int val2 ;
24217 int ecode2 = 0 ;
24218 PyObject * obj0 = 0 ;
24219 PyObject * obj1 = 0 ;
24220 char * kwnames[] = {
24221 (char *) "self",(char *) "year", NULL
24222 };
24223
24224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) SWIG_fail;
24225 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24226 if (!SWIG_IsOK(res1)) {
24227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetYear" "', expected argument " "1"" of type '" "wxDateTime *""'");
24228 }
24229 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24230 ecode2 = SWIG_AsVal_int(obj1, &val2);
24231 if (!SWIG_IsOK(ecode2)) {
24232 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetYear" "', expected argument " "2"" of type '" "int""'");
24233 }
24234 arg2 = static_cast< int >(val2);
24235 {
24236 PyThreadState* __tstate = wxPyBeginAllowThreads();
24237 {
24238 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
24239 result = (wxDateTime *) &_result_ref;
24240 }
24241 wxPyEndAllowThreads(__tstate);
24242 if (PyErr_Occurred()) SWIG_fail;
24243 }
24244 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24245 return resultobj;
24246 fail:
24247 return NULL;
24248 }
24249
24250
24251 SWIGINTERN PyObject *_wrap_DateTime_SetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24252 PyObject *resultobj = 0;
24253 wxDateTime *arg1 = (wxDateTime *) 0 ;
24254 wxDateTime::Month arg2 ;
24255 wxDateTime *result = 0 ;
24256 void *argp1 = 0 ;
24257 int res1 = 0 ;
24258 int val2 ;
24259 int ecode2 = 0 ;
24260 PyObject * obj0 = 0 ;
24261 PyObject * obj1 = 0 ;
24262 char * kwnames[] = {
24263 (char *) "self",(char *) "month", NULL
24264 };
24265
24266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
24267 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24268 if (!SWIG_IsOK(res1)) {
24269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMonth" "', expected argument " "1"" of type '" "wxDateTime *""'");
24270 }
24271 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24272 ecode2 = SWIG_AsVal_int(obj1, &val2);
24273 if (!SWIG_IsOK(ecode2)) {
24274 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMonth" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24275 }
24276 arg2 = static_cast< wxDateTime::Month >(val2);
24277 {
24278 PyThreadState* __tstate = wxPyBeginAllowThreads();
24279 {
24280 wxDateTime &_result_ref = (arg1)->SetMonth(arg2);
24281 result = (wxDateTime *) &_result_ref;
24282 }
24283 wxPyEndAllowThreads(__tstate);
24284 if (PyErr_Occurred()) SWIG_fail;
24285 }
24286 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24287 return resultobj;
24288 fail:
24289 return NULL;
24290 }
24291
24292
24293 SWIGINTERN PyObject *_wrap_DateTime_SetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24294 PyObject *resultobj = 0;
24295 wxDateTime *arg1 = (wxDateTime *) 0 ;
24296 int arg2 ;
24297 wxDateTime *result = 0 ;
24298 void *argp1 = 0 ;
24299 int res1 = 0 ;
24300 int val2 ;
24301 int ecode2 = 0 ;
24302 PyObject * obj0 = 0 ;
24303 PyObject * obj1 = 0 ;
24304 char * kwnames[] = {
24305 (char *) "self",(char *) "day", NULL
24306 };
24307
24308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) SWIG_fail;
24309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24310 if (!SWIG_IsOK(res1)) {
24311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24312 }
24313 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24314 ecode2 = SWIG_AsVal_int(obj1, &val2);
24315 if (!SWIG_IsOK(ecode2)) {
24316 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetDay" "', expected argument " "2"" of type '" "int""'");
24317 }
24318 arg2 = static_cast< int >(val2);
24319 {
24320 PyThreadState* __tstate = wxPyBeginAllowThreads();
24321 {
24322 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
24323 result = (wxDateTime *) &_result_ref;
24324 }
24325 wxPyEndAllowThreads(__tstate);
24326 if (PyErr_Occurred()) SWIG_fail;
24327 }
24328 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24329 return resultobj;
24330 fail:
24331 return NULL;
24332 }
24333
24334
24335 SWIGINTERN PyObject *_wrap_DateTime_SetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24336 PyObject *resultobj = 0;
24337 wxDateTime *arg1 = (wxDateTime *) 0 ;
24338 int arg2 ;
24339 wxDateTime *result = 0 ;
24340 void *argp1 = 0 ;
24341 int res1 = 0 ;
24342 int val2 ;
24343 int ecode2 = 0 ;
24344 PyObject * obj0 = 0 ;
24345 PyObject * obj1 = 0 ;
24346 char * kwnames[] = {
24347 (char *) "self",(char *) "hour", NULL
24348 };
24349
24350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) SWIG_fail;
24351 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24352 if (!SWIG_IsOK(res1)) {
24353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHour" "', expected argument " "1"" of type '" "wxDateTime *""'");
24354 }
24355 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24356 ecode2 = SWIG_AsVal_int(obj1, &val2);
24357 if (!SWIG_IsOK(ecode2)) {
24358 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHour" "', expected argument " "2"" of type '" "int""'");
24359 }
24360 arg2 = static_cast< int >(val2);
24361 {
24362 PyThreadState* __tstate = wxPyBeginAllowThreads();
24363 {
24364 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
24365 result = (wxDateTime *) &_result_ref;
24366 }
24367 wxPyEndAllowThreads(__tstate);
24368 if (PyErr_Occurred()) SWIG_fail;
24369 }
24370 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24371 return resultobj;
24372 fail:
24373 return NULL;
24374 }
24375
24376
24377 SWIGINTERN PyObject *_wrap_DateTime_SetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24378 PyObject *resultobj = 0;
24379 wxDateTime *arg1 = (wxDateTime *) 0 ;
24380 int arg2 ;
24381 wxDateTime *result = 0 ;
24382 void *argp1 = 0 ;
24383 int res1 = 0 ;
24384 int val2 ;
24385 int ecode2 = 0 ;
24386 PyObject * obj0 = 0 ;
24387 PyObject * obj1 = 0 ;
24388 char * kwnames[] = {
24389 (char *) "self",(char *) "minute", NULL
24390 };
24391
24392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
24393 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24394 if (!SWIG_IsOK(res1)) {
24395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMinute" "', expected argument " "1"" of type '" "wxDateTime *""'");
24396 }
24397 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24398 ecode2 = SWIG_AsVal_int(obj1, &val2);
24399 if (!SWIG_IsOK(ecode2)) {
24400 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMinute" "', expected argument " "2"" of type '" "int""'");
24401 }
24402 arg2 = static_cast< int >(val2);
24403 {
24404 PyThreadState* __tstate = wxPyBeginAllowThreads();
24405 {
24406 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
24407 result = (wxDateTime *) &_result_ref;
24408 }
24409 wxPyEndAllowThreads(__tstate);
24410 if (PyErr_Occurred()) SWIG_fail;
24411 }
24412 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24413 return resultobj;
24414 fail:
24415 return NULL;
24416 }
24417
24418
24419 SWIGINTERN PyObject *_wrap_DateTime_SetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24420 PyObject *resultobj = 0;
24421 wxDateTime *arg1 = (wxDateTime *) 0 ;
24422 int arg2 ;
24423 wxDateTime *result = 0 ;
24424 void *argp1 = 0 ;
24425 int res1 = 0 ;
24426 int val2 ;
24427 int ecode2 = 0 ;
24428 PyObject * obj0 = 0 ;
24429 PyObject * obj1 = 0 ;
24430 char * kwnames[] = {
24431 (char *) "self",(char *) "second", NULL
24432 };
24433
24434 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
24435 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24436 if (!SWIG_IsOK(res1)) {
24437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetSecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
24438 }
24439 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24440 ecode2 = SWIG_AsVal_int(obj1, &val2);
24441 if (!SWIG_IsOK(ecode2)) {
24442 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetSecond" "', expected argument " "2"" of type '" "int""'");
24443 }
24444 arg2 = static_cast< int >(val2);
24445 {
24446 PyThreadState* __tstate = wxPyBeginAllowThreads();
24447 {
24448 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
24449 result = (wxDateTime *) &_result_ref;
24450 }
24451 wxPyEndAllowThreads(__tstate);
24452 if (PyErr_Occurred()) SWIG_fail;
24453 }
24454 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24455 return resultobj;
24456 fail:
24457 return NULL;
24458 }
24459
24460
24461 SWIGINTERN PyObject *_wrap_DateTime_SetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24462 PyObject *resultobj = 0;
24463 wxDateTime *arg1 = (wxDateTime *) 0 ;
24464 int arg2 ;
24465 wxDateTime *result = 0 ;
24466 void *argp1 = 0 ;
24467 int res1 = 0 ;
24468 int val2 ;
24469 int ecode2 = 0 ;
24470 PyObject * obj0 = 0 ;
24471 PyObject * obj1 = 0 ;
24472 char * kwnames[] = {
24473 (char *) "self",(char *) "millisecond", NULL
24474 };
24475
24476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
24477 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24478 if (!SWIG_IsOK(res1)) {
24479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMillisecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
24480 }
24481 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24482 ecode2 = SWIG_AsVal_int(obj1, &val2);
24483 if (!SWIG_IsOK(ecode2)) {
24484 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMillisecond" "', expected argument " "2"" of type '" "int""'");
24485 }
24486 arg2 = static_cast< int >(val2);
24487 {
24488 PyThreadState* __tstate = wxPyBeginAllowThreads();
24489 {
24490 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
24491 result = (wxDateTime *) &_result_ref;
24492 }
24493 wxPyEndAllowThreads(__tstate);
24494 if (PyErr_Occurred()) SWIG_fail;
24495 }
24496 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24497 return resultobj;
24498 fail:
24499 return NULL;
24500 }
24501
24502
24503 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24504 PyObject *resultobj = 0;
24505 wxDateTime *arg1 = (wxDateTime *) 0 ;
24506 wxDateTime::WeekDay arg2 ;
24507 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
24508 wxDateTime *result = 0 ;
24509 void *argp1 = 0 ;
24510 int res1 = 0 ;
24511 int val2 ;
24512 int ecode2 = 0 ;
24513 int val3 ;
24514 int ecode3 = 0 ;
24515 PyObject * obj0 = 0 ;
24516 PyObject * obj1 = 0 ;
24517 PyObject * obj2 = 0 ;
24518 char * kwnames[] = {
24519 (char *) "self",(char *) "weekday",(char *) "flags", NULL
24520 };
24521
24522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24523 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24524 if (!SWIG_IsOK(res1)) {
24525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
24526 }
24527 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24528 ecode2 = SWIG_AsVal_int(obj1, &val2);
24529 if (!SWIG_IsOK(ecode2)) {
24530 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24531 }
24532 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24533 if (obj2) {
24534 ecode3 = SWIG_AsVal_int(obj2, &val3);
24535 if (!SWIG_IsOK(ecode3)) {
24536 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
24537 }
24538 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
24539 }
24540 {
24541 PyThreadState* __tstate = wxPyBeginAllowThreads();
24542 {
24543 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek(arg2,arg3);
24544 result = (wxDateTime *) &_result_ref;
24545 }
24546 wxPyEndAllowThreads(__tstate);
24547 if (PyErr_Occurred()) SWIG_fail;
24548 }
24549 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24550 return resultobj;
24551 fail:
24552 return NULL;
24553 }
24554
24555
24556 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24557 PyObject *resultobj = 0;
24558 wxDateTime *arg1 = (wxDateTime *) 0 ;
24559 wxDateTime::WeekDay arg2 ;
24560 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
24561 wxDateTime result;
24562 void *argp1 = 0 ;
24563 int res1 = 0 ;
24564 int val2 ;
24565 int ecode2 = 0 ;
24566 int val3 ;
24567 int ecode3 = 0 ;
24568 PyObject * obj0 = 0 ;
24569 PyObject * obj1 = 0 ;
24570 PyObject * obj2 = 0 ;
24571 char * kwnames[] = {
24572 (char *) "self",(char *) "weekday",(char *) "flags", NULL
24573 };
24574
24575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24576 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24577 if (!SWIG_IsOK(res1)) {
24578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
24579 }
24580 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24581 ecode2 = SWIG_AsVal_int(obj1, &val2);
24582 if (!SWIG_IsOK(ecode2)) {
24583 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24584 }
24585 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24586 if (obj2) {
24587 ecode3 = SWIG_AsVal_int(obj2, &val3);
24588 if (!SWIG_IsOK(ecode3)) {
24589 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
24590 }
24591 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
24592 }
24593 {
24594 PyThreadState* __tstate = wxPyBeginAllowThreads();
24595 result = (arg1)->GetWeekDayInSameWeek(arg2,arg3);
24596 wxPyEndAllowThreads(__tstate);
24597 if (PyErr_Occurred()) SWIG_fail;
24598 }
24599 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24600 return resultobj;
24601 fail:
24602 return NULL;
24603 }
24604
24605
24606 SWIGINTERN PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24607 PyObject *resultobj = 0;
24608 wxDateTime *arg1 = (wxDateTime *) 0 ;
24609 wxDateTime::WeekDay arg2 ;
24610 wxDateTime *result = 0 ;
24611 void *argp1 = 0 ;
24612 int res1 = 0 ;
24613 int val2 ;
24614 int ecode2 = 0 ;
24615 PyObject * obj0 = 0 ;
24616 PyObject * obj1 = 0 ;
24617 char * kwnames[] = {
24618 (char *) "self",(char *) "weekday", NULL
24619 };
24620
24621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24623 if (!SWIG_IsOK(res1)) {
24624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24625 }
24626 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24627 ecode2 = SWIG_AsVal_int(obj1, &val2);
24628 if (!SWIG_IsOK(ecode2)) {
24629 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24630 }
24631 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24632 {
24633 PyThreadState* __tstate = wxPyBeginAllowThreads();
24634 {
24635 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay(arg2);
24636 result = (wxDateTime *) &_result_ref;
24637 }
24638 wxPyEndAllowThreads(__tstate);
24639 if (PyErr_Occurred()) SWIG_fail;
24640 }
24641 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24642 return resultobj;
24643 fail:
24644 return NULL;
24645 }
24646
24647
24648 SWIGINTERN PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24649 PyObject *resultobj = 0;
24650 wxDateTime *arg1 = (wxDateTime *) 0 ;
24651 wxDateTime::WeekDay arg2 ;
24652 wxDateTime result;
24653 void *argp1 = 0 ;
24654 int res1 = 0 ;
24655 int val2 ;
24656 int ecode2 = 0 ;
24657 PyObject * obj0 = 0 ;
24658 PyObject * obj1 = 0 ;
24659 char * kwnames[] = {
24660 (char *) "self",(char *) "weekday", NULL
24661 };
24662
24663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24665 if (!SWIG_IsOK(res1)) {
24666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24667 }
24668 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24669 ecode2 = SWIG_AsVal_int(obj1, &val2);
24670 if (!SWIG_IsOK(ecode2)) {
24671 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24672 }
24673 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24674 {
24675 PyThreadState* __tstate = wxPyBeginAllowThreads();
24676 result = (arg1)->GetNextWeekDay(arg2);
24677 wxPyEndAllowThreads(__tstate);
24678 if (PyErr_Occurred()) SWIG_fail;
24679 }
24680 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24681 return resultobj;
24682 fail:
24683 return NULL;
24684 }
24685
24686
24687 SWIGINTERN PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24688 PyObject *resultobj = 0;
24689 wxDateTime *arg1 = (wxDateTime *) 0 ;
24690 wxDateTime::WeekDay arg2 ;
24691 wxDateTime *result = 0 ;
24692 void *argp1 = 0 ;
24693 int res1 = 0 ;
24694 int val2 ;
24695 int ecode2 = 0 ;
24696 PyObject * obj0 = 0 ;
24697 PyObject * obj1 = 0 ;
24698 char * kwnames[] = {
24699 (char *) "self",(char *) "weekday", NULL
24700 };
24701
24702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24703 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24704 if (!SWIG_IsOK(res1)) {
24705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24706 }
24707 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24708 ecode2 = SWIG_AsVal_int(obj1, &val2);
24709 if (!SWIG_IsOK(ecode2)) {
24710 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24711 }
24712 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24713 {
24714 PyThreadState* __tstate = wxPyBeginAllowThreads();
24715 {
24716 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay(arg2);
24717 result = (wxDateTime *) &_result_ref;
24718 }
24719 wxPyEndAllowThreads(__tstate);
24720 if (PyErr_Occurred()) SWIG_fail;
24721 }
24722 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24723 return resultobj;
24724 fail:
24725 return NULL;
24726 }
24727
24728
24729 SWIGINTERN PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24730 PyObject *resultobj = 0;
24731 wxDateTime *arg1 = (wxDateTime *) 0 ;
24732 wxDateTime::WeekDay arg2 ;
24733 wxDateTime result;
24734 void *argp1 = 0 ;
24735 int res1 = 0 ;
24736 int val2 ;
24737 int ecode2 = 0 ;
24738 PyObject * obj0 = 0 ;
24739 PyObject * obj1 = 0 ;
24740 char * kwnames[] = {
24741 (char *) "self",(char *) "weekday", NULL
24742 };
24743
24744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24745 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24746 if (!SWIG_IsOK(res1)) {
24747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24748 }
24749 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24750 ecode2 = SWIG_AsVal_int(obj1, &val2);
24751 if (!SWIG_IsOK(ecode2)) {
24752 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24753 }
24754 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24755 {
24756 PyThreadState* __tstate = wxPyBeginAllowThreads();
24757 result = (arg1)->GetPrevWeekDay(arg2);
24758 wxPyEndAllowThreads(__tstate);
24759 if (PyErr_Occurred()) SWIG_fail;
24760 }
24761 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24762 return resultobj;
24763 fail:
24764 return NULL;
24765 }
24766
24767
24768 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24769 PyObject *resultobj = 0;
24770 wxDateTime *arg1 = (wxDateTime *) 0 ;
24771 wxDateTime::WeekDay arg2 ;
24772 int arg3 = (int) 1 ;
24773 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24774 int arg5 = (int) wxDateTime::Inv_Year ;
24775 bool result;
24776 void *argp1 = 0 ;
24777 int res1 = 0 ;
24778 int val2 ;
24779 int ecode2 = 0 ;
24780 int val3 ;
24781 int ecode3 = 0 ;
24782 int val4 ;
24783 int ecode4 = 0 ;
24784 int val5 ;
24785 int ecode5 = 0 ;
24786 PyObject * obj0 = 0 ;
24787 PyObject * obj1 = 0 ;
24788 PyObject * obj2 = 0 ;
24789 PyObject * obj3 = 0 ;
24790 PyObject * obj4 = 0 ;
24791 char * kwnames[] = {
24792 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
24793 };
24794
24795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
24796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24797 if (!SWIG_IsOK(res1)) {
24798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24799 }
24800 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24801 ecode2 = SWIG_AsVal_int(obj1, &val2);
24802 if (!SWIG_IsOK(ecode2)) {
24803 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24804 }
24805 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24806 if (obj2) {
24807 ecode3 = SWIG_AsVal_int(obj2, &val3);
24808 if (!SWIG_IsOK(ecode3)) {
24809 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDay" "', expected argument " "3"" of type '" "int""'");
24810 }
24811 arg3 = static_cast< int >(val3);
24812 }
24813 if (obj3) {
24814 ecode4 = SWIG_AsVal_int(obj3, &val4);
24815 if (!SWIG_IsOK(ecode4)) {
24816 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToWeekDay" "', expected argument " "4"" of type '" "wxDateTime::Month""'");
24817 }
24818 arg4 = static_cast< wxDateTime::Month >(val4);
24819 }
24820 if (obj4) {
24821 ecode5 = SWIG_AsVal_int(obj4, &val5);
24822 if (!SWIG_IsOK(ecode5)) {
24823 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetToWeekDay" "', expected argument " "5"" of type '" "int""'");
24824 }
24825 arg5 = static_cast< int >(val5);
24826 }
24827 {
24828 PyThreadState* __tstate = wxPyBeginAllowThreads();
24829 result = (bool)(arg1)->SetToWeekDay(arg2,arg3,arg4,arg5);
24830 wxPyEndAllowThreads(__tstate);
24831 if (PyErr_Occurred()) SWIG_fail;
24832 }
24833 {
24834 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24835 }
24836 return resultobj;
24837 fail:
24838 return NULL;
24839 }
24840
24841
24842 SWIGINTERN PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24843 PyObject *resultobj = 0;
24844 wxDateTime *arg1 = (wxDateTime *) 0 ;
24845 wxDateTime::WeekDay arg2 ;
24846 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24847 int arg4 = (int) wxDateTime::Inv_Year ;
24848 bool result;
24849 void *argp1 = 0 ;
24850 int res1 = 0 ;
24851 int val2 ;
24852 int ecode2 = 0 ;
24853 int val3 ;
24854 int ecode3 = 0 ;
24855 int val4 ;
24856 int ecode4 = 0 ;
24857 PyObject * obj0 = 0 ;
24858 PyObject * obj1 = 0 ;
24859 PyObject * obj2 = 0 ;
24860 PyObject * obj3 = 0 ;
24861 char * kwnames[] = {
24862 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
24863 };
24864
24865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
24866 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24867 if (!SWIG_IsOK(res1)) {
24868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24869 }
24870 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24871 ecode2 = SWIG_AsVal_int(obj1, &val2);
24872 if (!SWIG_IsOK(ecode2)) {
24873 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24874 }
24875 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24876 if (obj2) {
24877 ecode3 = SWIG_AsVal_int(obj2, &val3);
24878 if (!SWIG_IsOK(ecode3)) {
24879 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
24880 }
24881 arg3 = static_cast< wxDateTime::Month >(val3);
24882 }
24883 if (obj3) {
24884 ecode4 = SWIG_AsVal_int(obj3, &val4);
24885 if (!SWIG_IsOK(ecode4)) {
24886 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "4"" of type '" "int""'");
24887 }
24888 arg4 = static_cast< int >(val4);
24889 }
24890 {
24891 PyThreadState* __tstate = wxPyBeginAllowThreads();
24892 result = (bool)(arg1)->SetToLastWeekDay(arg2,arg3,arg4);
24893 wxPyEndAllowThreads(__tstate);
24894 if (PyErr_Occurred()) SWIG_fail;
24895 }
24896 {
24897 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24898 }
24899 return resultobj;
24900 fail:
24901 return NULL;
24902 }
24903
24904
24905 SWIGINTERN PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24906 PyObject *resultobj = 0;
24907 wxDateTime *arg1 = (wxDateTime *) 0 ;
24908 wxDateTime::WeekDay arg2 ;
24909 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24910 int arg4 = (int) wxDateTime::Inv_Year ;
24911 wxDateTime result;
24912 void *argp1 = 0 ;
24913 int res1 = 0 ;
24914 int val2 ;
24915 int ecode2 = 0 ;
24916 int val3 ;
24917 int ecode3 = 0 ;
24918 int val4 ;
24919 int ecode4 = 0 ;
24920 PyObject * obj0 = 0 ;
24921 PyObject * obj1 = 0 ;
24922 PyObject * obj2 = 0 ;
24923 PyObject * obj3 = 0 ;
24924 char * kwnames[] = {
24925 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
24926 };
24927
24928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
24929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24930 if (!SWIG_IsOK(res1)) {
24931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24932 }
24933 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24934 ecode2 = SWIG_AsVal_int(obj1, &val2);
24935 if (!SWIG_IsOK(ecode2)) {
24936 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24937 }
24938 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24939 if (obj2) {
24940 ecode3 = SWIG_AsVal_int(obj2, &val3);
24941 if (!SWIG_IsOK(ecode3)) {
24942 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
24943 }
24944 arg3 = static_cast< wxDateTime::Month >(val3);
24945 }
24946 if (obj3) {
24947 ecode4 = SWIG_AsVal_int(obj3, &val4);
24948 if (!SWIG_IsOK(ecode4)) {
24949 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "4"" of type '" "int""'");
24950 }
24951 arg4 = static_cast< int >(val4);
24952 }
24953 {
24954 PyThreadState* __tstate = wxPyBeginAllowThreads();
24955 result = (arg1)->GetLastWeekDay(arg2,arg3,arg4);
24956 wxPyEndAllowThreads(__tstate);
24957 if (PyErr_Occurred()) SWIG_fail;
24958 }
24959 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24960 return resultobj;
24961 fail:
24962 return NULL;
24963 }
24964
24965
24966 SWIGINTERN PyObject *_wrap_DateTime_SetToTheWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24967 PyObject *resultobj = 0;
24968 wxDateTime *arg1 = (wxDateTime *) 0 ;
24969 int arg2 ;
24970 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
24971 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
24972 bool result;
24973 void *argp1 = 0 ;
24974 int res1 = 0 ;
24975 int val2 ;
24976 int ecode2 = 0 ;
24977 int val3 ;
24978 int ecode3 = 0 ;
24979 int val4 ;
24980 int ecode4 = 0 ;
24981 PyObject * obj0 = 0 ;
24982 PyObject * obj1 = 0 ;
24983 PyObject * obj2 = 0 ;
24984 PyObject * obj3 = 0 ;
24985 char * kwnames[] = {
24986 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
24987 };
24988
24989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
24990 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24991 if (!SWIG_IsOK(res1)) {
24992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToTheWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
24993 }
24994 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24995 ecode2 = SWIG_AsVal_int(obj1, &val2);
24996 if (!SWIG_IsOK(ecode2)) {
24997 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToTheWeek" "', expected argument " "2"" of type '" "int""'");
24998 }
24999 arg2 = static_cast< int >(val2);
25000 if (obj2) {
25001 ecode3 = SWIG_AsVal_int(obj2, &val3);
25002 if (!SWIG_IsOK(ecode3)) {
25003 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToTheWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
25004 }
25005 arg3 = static_cast< wxDateTime::WeekDay >(val3);
25006 }
25007 if (obj3) {
25008 ecode4 = SWIG_AsVal_int(obj3, &val4);
25009 if (!SWIG_IsOK(ecode4)) {
25010 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToTheWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
25011 }
25012 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
25013 }
25014 {
25015 PyThreadState* __tstate = wxPyBeginAllowThreads();
25016 result = (bool)(arg1)->SetToTheWeek(arg2,arg3,arg4);
25017 wxPyEndAllowThreads(__tstate);
25018 if (PyErr_Occurred()) SWIG_fail;
25019 }
25020 {
25021 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25022 }
25023 return resultobj;
25024 fail:
25025 return NULL;
25026 }
25027
25028
25029 SWIGINTERN PyObject *_wrap_DateTime_GetWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25030 PyObject *resultobj = 0;
25031 wxDateTime *arg1 = (wxDateTime *) 0 ;
25032 int arg2 ;
25033 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
25034 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25035 wxDateTime result;
25036 void *argp1 = 0 ;
25037 int res1 = 0 ;
25038 int val2 ;
25039 int ecode2 = 0 ;
25040 int val3 ;
25041 int ecode3 = 0 ;
25042 int val4 ;
25043 int ecode4 = 0 ;
25044 PyObject * obj0 = 0 ;
25045 PyObject * obj1 = 0 ;
25046 PyObject * obj2 = 0 ;
25047 PyObject * obj3 = 0 ;
25048 char * kwnames[] = {
25049 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
25050 };
25051
25052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25053 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25054 if (!SWIG_IsOK(res1)) {
25055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
25056 }
25057 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25058 ecode2 = SWIG_AsVal_int(obj1, &val2);
25059 if (!SWIG_IsOK(ecode2)) {
25060 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeek" "', expected argument " "2"" of type '" "int""'");
25061 }
25062 arg2 = static_cast< int >(val2);
25063 if (obj2) {
25064 ecode3 = SWIG_AsVal_int(obj2, &val3);
25065 if (!SWIG_IsOK(ecode3)) {
25066 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
25067 }
25068 arg3 = static_cast< wxDateTime::WeekDay >(val3);
25069 }
25070 if (obj3) {
25071 ecode4 = SWIG_AsVal_int(obj3, &val4);
25072 if (!SWIG_IsOK(ecode4)) {
25073 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
25074 }
25075 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
25076 }
25077 {
25078 PyThreadState* __tstate = wxPyBeginAllowThreads();
25079 result = (arg1)->GetWeek(arg2,arg3,arg4);
25080 wxPyEndAllowThreads(__tstate);
25081 if (PyErr_Occurred()) SWIG_fail;
25082 }
25083 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25084 return resultobj;
25085 fail:
25086 return NULL;
25087 }
25088
25089
25090 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25091 PyObject *resultobj = 0;
25092 int arg1 ;
25093 int arg2 ;
25094 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
25095 wxDateTime result;
25096 int val1 ;
25097 int ecode1 = 0 ;
25098 int val2 ;
25099 int ecode2 = 0 ;
25100 int val3 ;
25101 int ecode3 = 0 ;
25102 PyObject * obj0 = 0 ;
25103 PyObject * obj1 = 0 ;
25104 PyObject * obj2 = 0 ;
25105 char * kwnames[] = {
25106 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
25107 };
25108
25109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25110 ecode1 = SWIG_AsVal_int(obj0, &val1);
25111 if (!SWIG_IsOK(ecode1)) {
25112 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "1"" of type '" "int""'");
25113 }
25114 arg1 = static_cast< int >(val1);
25115 ecode2 = SWIG_AsVal_int(obj1, &val2);
25116 if (!SWIG_IsOK(ecode2)) {
25117 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "2"" of type '" "int""'");
25118 }
25119 arg2 = static_cast< int >(val2);
25120 if (obj2) {
25121 ecode3 = SWIG_AsVal_int(obj2, &val3);
25122 if (!SWIG_IsOK(ecode3)) {
25123 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
25124 }
25125 arg3 = static_cast< wxDateTime::WeekDay >(val3);
25126 }
25127 {
25128 PyThreadState* __tstate = wxPyBeginAllowThreads();
25129 result = wxDateTime::SetToWeekOfYear(arg1,arg2,arg3);
25130 wxPyEndAllowThreads(__tstate);
25131 if (PyErr_Occurred()) SWIG_fail;
25132 }
25133 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25134 return resultobj;
25135 fail:
25136 return NULL;
25137 }
25138
25139
25140 SWIGINTERN PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25141 PyObject *resultobj = 0;
25142 wxDateTime *arg1 = (wxDateTime *) 0 ;
25143 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25144 int arg3 = (int) wxDateTime::Inv_Year ;
25145 wxDateTime *result = 0 ;
25146 void *argp1 = 0 ;
25147 int res1 = 0 ;
25148 int val2 ;
25149 int ecode2 = 0 ;
25150 int val3 ;
25151 int ecode3 = 0 ;
25152 PyObject * obj0 = 0 ;
25153 PyObject * obj1 = 0 ;
25154 PyObject * obj2 = 0 ;
25155 char * kwnames[] = {
25156 (char *) "self",(char *) "month",(char *) "year", NULL
25157 };
25158
25159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25161 if (!SWIG_IsOK(res1)) {
25162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25163 }
25164 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25165 if (obj1) {
25166 ecode2 = SWIG_AsVal_int(obj1, &val2);
25167 if (!SWIG_IsOK(ecode2)) {
25168 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
25169 }
25170 arg2 = static_cast< wxDateTime::Month >(val2);
25171 }
25172 if (obj2) {
25173 ecode3 = SWIG_AsVal_int(obj2, &val3);
25174 if (!SWIG_IsOK(ecode3)) {
25175 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "3"" of type '" "int""'");
25176 }
25177 arg3 = static_cast< int >(val3);
25178 }
25179 {
25180 PyThreadState* __tstate = wxPyBeginAllowThreads();
25181 {
25182 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay(arg2,arg3);
25183 result = (wxDateTime *) &_result_ref;
25184 }
25185 wxPyEndAllowThreads(__tstate);
25186 if (PyErr_Occurred()) SWIG_fail;
25187 }
25188 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25189 return resultobj;
25190 fail:
25191 return NULL;
25192 }
25193
25194
25195 SWIGINTERN PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25196 PyObject *resultobj = 0;
25197 wxDateTime *arg1 = (wxDateTime *) 0 ;
25198 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25199 int arg3 = (int) wxDateTime::Inv_Year ;
25200 wxDateTime result;
25201 void *argp1 = 0 ;
25202 int res1 = 0 ;
25203 int val2 ;
25204 int ecode2 = 0 ;
25205 int val3 ;
25206 int ecode3 = 0 ;
25207 PyObject * obj0 = 0 ;
25208 PyObject * obj1 = 0 ;
25209 PyObject * obj2 = 0 ;
25210 char * kwnames[] = {
25211 (char *) "self",(char *) "month",(char *) "year", NULL
25212 };
25213
25214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25216 if (!SWIG_IsOK(res1)) {
25217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25218 }
25219 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25220 if (obj1) {
25221 ecode2 = SWIG_AsVal_int(obj1, &val2);
25222 if (!SWIG_IsOK(ecode2)) {
25223 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
25224 }
25225 arg2 = static_cast< wxDateTime::Month >(val2);
25226 }
25227 if (obj2) {
25228 ecode3 = SWIG_AsVal_int(obj2, &val3);
25229 if (!SWIG_IsOK(ecode3)) {
25230 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "3"" of type '" "int""'");
25231 }
25232 arg3 = static_cast< int >(val3);
25233 }
25234 {
25235 PyThreadState* __tstate = wxPyBeginAllowThreads();
25236 result = (arg1)->GetLastMonthDay(arg2,arg3);
25237 wxPyEndAllowThreads(__tstate);
25238 if (PyErr_Occurred()) SWIG_fail;
25239 }
25240 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25241 return resultobj;
25242 fail:
25243 return NULL;
25244 }
25245
25246
25247 SWIGINTERN PyObject *_wrap_DateTime_SetToYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25248 PyObject *resultobj = 0;
25249 wxDateTime *arg1 = (wxDateTime *) 0 ;
25250 int arg2 ;
25251 wxDateTime *result = 0 ;
25252 void *argp1 = 0 ;
25253 int res1 = 0 ;
25254 int val2 ;
25255 int ecode2 = 0 ;
25256 PyObject * obj0 = 0 ;
25257 PyObject * obj1 = 0 ;
25258 char * kwnames[] = {
25259 (char *) "self",(char *) "yday", NULL
25260 };
25261
25262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
25263 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25264 if (!SWIG_IsOK(res1)) {
25265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25266 }
25267 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25268 ecode2 = SWIG_AsVal_int(obj1, &val2);
25269 if (!SWIG_IsOK(ecode2)) {
25270 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToYearDay" "', expected argument " "2"" of type '" "int""'");
25271 }
25272 arg2 = static_cast< int >(val2);
25273 {
25274 PyThreadState* __tstate = wxPyBeginAllowThreads();
25275 {
25276 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
25277 result = (wxDateTime *) &_result_ref;
25278 }
25279 wxPyEndAllowThreads(__tstate);
25280 if (PyErr_Occurred()) SWIG_fail;
25281 }
25282 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25283 return resultobj;
25284 fail:
25285 return NULL;
25286 }
25287
25288
25289 SWIGINTERN PyObject *_wrap_DateTime_GetYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25290 PyObject *resultobj = 0;
25291 wxDateTime *arg1 = (wxDateTime *) 0 ;
25292 int arg2 ;
25293 wxDateTime result;
25294 void *argp1 = 0 ;
25295 int res1 = 0 ;
25296 int val2 ;
25297 int ecode2 = 0 ;
25298 PyObject * obj0 = 0 ;
25299 PyObject * obj1 = 0 ;
25300 char * kwnames[] = {
25301 (char *) "self",(char *) "yday", NULL
25302 };
25303
25304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
25305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25306 if (!SWIG_IsOK(res1)) {
25307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25308 }
25309 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25310 ecode2 = SWIG_AsVal_int(obj1, &val2);
25311 if (!SWIG_IsOK(ecode2)) {
25312 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetYearDay" "', expected argument " "2"" of type '" "int""'");
25313 }
25314 arg2 = static_cast< int >(val2);
25315 {
25316 PyThreadState* __tstate = wxPyBeginAllowThreads();
25317 result = (arg1)->GetYearDay(arg2);
25318 wxPyEndAllowThreads(__tstate);
25319 if (PyErr_Occurred()) SWIG_fail;
25320 }
25321 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25322 return resultobj;
25323 fail:
25324 return NULL;
25325 }
25326
25327
25328 SWIGINTERN PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25329 PyObject *resultobj = 0;
25330 wxDateTime *arg1 = (wxDateTime *) 0 ;
25331 double result;
25332 void *argp1 = 0 ;
25333 int res1 = 0 ;
25334 PyObject *swig_obj[1] ;
25335
25336 if (!args) SWIG_fail;
25337 swig_obj[0] = args;
25338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25339 if (!SWIG_IsOK(res1)) {
25340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime *""'");
25341 }
25342 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25343 {
25344 PyThreadState* __tstate = wxPyBeginAllowThreads();
25345 result = (double)(arg1)->GetJulianDayNumber();
25346 wxPyEndAllowThreads(__tstate);
25347 if (PyErr_Occurred()) SWIG_fail;
25348 }
25349 resultobj = SWIG_From_double(static_cast< double >(result));
25350 return resultobj;
25351 fail:
25352 return NULL;
25353 }
25354
25355
25356 SWIGINTERN PyObject *_wrap_DateTime_GetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25357 PyObject *resultobj = 0;
25358 wxDateTime *arg1 = (wxDateTime *) 0 ;
25359 double result;
25360 void *argp1 = 0 ;
25361 int res1 = 0 ;
25362 PyObject *swig_obj[1] ;
25363
25364 if (!args) SWIG_fail;
25365 swig_obj[0] = args;
25366 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25367 if (!SWIG_IsOK(res1)) {
25368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
25369 }
25370 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25371 {
25372 PyThreadState* __tstate = wxPyBeginAllowThreads();
25373 result = (double)(arg1)->GetJDN();
25374 wxPyEndAllowThreads(__tstate);
25375 if (PyErr_Occurred()) SWIG_fail;
25376 }
25377 resultobj = SWIG_From_double(static_cast< double >(result));
25378 return resultobj;
25379 fail:
25380 return NULL;
25381 }
25382
25383
25384 SWIGINTERN PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25385 PyObject *resultobj = 0;
25386 wxDateTime *arg1 = (wxDateTime *) 0 ;
25387 double result;
25388 void *argp1 = 0 ;
25389 int res1 = 0 ;
25390 PyObject *swig_obj[1] ;
25391
25392 if (!args) SWIG_fail;
25393 swig_obj[0] = args;
25394 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25395 if (!SWIG_IsOK(res1)) {
25396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetModifiedJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25397 }
25398 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25399 {
25400 PyThreadState* __tstate = wxPyBeginAllowThreads();
25401 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
25402 wxPyEndAllowThreads(__tstate);
25403 if (PyErr_Occurred()) SWIG_fail;
25404 }
25405 resultobj = SWIG_From_double(static_cast< double >(result));
25406 return resultobj;
25407 fail:
25408 return NULL;
25409 }
25410
25411
25412 SWIGINTERN PyObject *_wrap_DateTime_GetMJD(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25413 PyObject *resultobj = 0;
25414 wxDateTime *arg1 = (wxDateTime *) 0 ;
25415 double result;
25416 void *argp1 = 0 ;
25417 int res1 = 0 ;
25418 PyObject *swig_obj[1] ;
25419
25420 if (!args) SWIG_fail;
25421 swig_obj[0] = args;
25422 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25423 if (!SWIG_IsOK(res1)) {
25424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMJD" "', expected argument " "1"" of type '" "wxDateTime *""'");
25425 }
25426 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25427 {
25428 PyThreadState* __tstate = wxPyBeginAllowThreads();
25429 result = (double)(arg1)->GetMJD();
25430 wxPyEndAllowThreads(__tstate);
25431 if (PyErr_Occurred()) SWIG_fail;
25432 }
25433 resultobj = SWIG_From_double(static_cast< double >(result));
25434 return resultobj;
25435 fail:
25436 return NULL;
25437 }
25438
25439
25440 SWIGINTERN PyObject *_wrap_DateTime_GetRataDie(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25441 PyObject *resultobj = 0;
25442 wxDateTime *arg1 = (wxDateTime *) 0 ;
25443 double result;
25444 void *argp1 = 0 ;
25445 int res1 = 0 ;
25446 PyObject *swig_obj[1] ;
25447
25448 if (!args) SWIG_fail;
25449 swig_obj[0] = args;
25450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25451 if (!SWIG_IsOK(res1)) {
25452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetRataDie" "', expected argument " "1"" of type '" "wxDateTime *""'");
25453 }
25454 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25455 {
25456 PyThreadState* __tstate = wxPyBeginAllowThreads();
25457 result = (double)(arg1)->GetRataDie();
25458 wxPyEndAllowThreads(__tstate);
25459 if (PyErr_Occurred()) SWIG_fail;
25460 }
25461 resultobj = SWIG_From_double(static_cast< double >(result));
25462 return resultobj;
25463 fail:
25464 return NULL;
25465 }
25466
25467
25468 SWIGINTERN PyObject *_wrap_DateTime_ToTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25469 PyObject *resultobj = 0;
25470 wxDateTime *arg1 = (wxDateTime *) 0 ;
25471 wxDateTime::TimeZone *arg2 = 0 ;
25472 bool arg3 = (bool) false ;
25473 wxDateTime result;
25474 void *argp1 = 0 ;
25475 int res1 = 0 ;
25476 bool temp2 = false ;
25477 bool val3 ;
25478 int ecode3 = 0 ;
25479 PyObject * obj0 = 0 ;
25480 PyObject * obj1 = 0 ;
25481 PyObject * obj2 = 0 ;
25482 char * kwnames[] = {
25483 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25484 };
25485
25486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25487 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25488 if (!SWIG_IsOK(res1)) {
25489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25490 }
25491 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25492 {
25493 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25494 temp2 = true;
25495 }
25496 if (obj2) {
25497 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25498 if (!SWIG_IsOK(ecode3)) {
25499 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_ToTimezone" "', expected argument " "3"" of type '" "bool""'");
25500 }
25501 arg3 = static_cast< bool >(val3);
25502 }
25503 {
25504 PyThreadState* __tstate = wxPyBeginAllowThreads();
25505 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25506 wxPyEndAllowThreads(__tstate);
25507 if (PyErr_Occurred()) SWIG_fail;
25508 }
25509 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25510 {
25511 if (temp2) delete arg2;
25512 }
25513 return resultobj;
25514 fail:
25515 {
25516 if (temp2) delete arg2;
25517 }
25518 return NULL;
25519 }
25520
25521
25522 SWIGINTERN PyObject *_wrap_DateTime_MakeTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25523 PyObject *resultobj = 0;
25524 wxDateTime *arg1 = (wxDateTime *) 0 ;
25525 wxDateTime::TimeZone *arg2 = 0 ;
25526 bool arg3 = (bool) false ;
25527 wxDateTime *result = 0 ;
25528 void *argp1 = 0 ;
25529 int res1 = 0 ;
25530 bool temp2 = false ;
25531 bool val3 ;
25532 int ecode3 = 0 ;
25533 PyObject * obj0 = 0 ;
25534 PyObject * obj1 = 0 ;
25535 PyObject * obj2 = 0 ;
25536 char * kwnames[] = {
25537 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25538 };
25539
25540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25541 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25542 if (!SWIG_IsOK(res1)) {
25543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25544 }
25545 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25546 {
25547 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25548 temp2 = true;
25549 }
25550 if (obj2) {
25551 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25552 if (!SWIG_IsOK(ecode3)) {
25553 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeTimezone" "', expected argument " "3"" of type '" "bool""'");
25554 }
25555 arg3 = static_cast< bool >(val3);
25556 }
25557 {
25558 PyThreadState* __tstate = wxPyBeginAllowThreads();
25559 {
25560 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25561 result = (wxDateTime *) &_result_ref;
25562 }
25563 wxPyEndAllowThreads(__tstate);
25564 if (PyErr_Occurred()) SWIG_fail;
25565 }
25566 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25567 {
25568 if (temp2) delete arg2;
25569 }
25570 return resultobj;
25571 fail:
25572 {
25573 if (temp2) delete arg2;
25574 }
25575 return NULL;
25576 }
25577
25578
25579 SWIGINTERN PyObject *_wrap_DateTime_FromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25580 PyObject *resultobj = 0;
25581 wxDateTime *arg1 = (wxDateTime *) 0 ;
25582 wxDateTime::TimeZone *arg2 = 0 ;
25583 bool arg3 = (bool) false ;
25584 wxDateTime result;
25585 void *argp1 = 0 ;
25586 int res1 = 0 ;
25587 bool temp2 = false ;
25588 bool val3 ;
25589 int ecode3 = 0 ;
25590 PyObject * obj0 = 0 ;
25591 PyObject * obj1 = 0 ;
25592 PyObject * obj2 = 0 ;
25593 char * kwnames[] = {
25594 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25595 };
25596
25597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_FromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25598 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25599 if (!SWIG_IsOK(res1)) {
25600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromTimezone" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25601 }
25602 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25603 {
25604 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25605 temp2 = true;
25606 }
25607 if (obj2) {
25608 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25609 if (!SWIG_IsOK(ecode3)) {
25610 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_FromTimezone" "', expected argument " "3"" of type '" "bool""'");
25611 }
25612 arg3 = static_cast< bool >(val3);
25613 }
25614 {
25615 PyThreadState* __tstate = wxPyBeginAllowThreads();
25616 result = ((wxDateTime const *)arg1)->FromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25617 wxPyEndAllowThreads(__tstate);
25618 if (PyErr_Occurred()) SWIG_fail;
25619 }
25620 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25621 {
25622 if (temp2) delete arg2;
25623 }
25624 return resultobj;
25625 fail:
25626 {
25627 if (temp2) delete arg2;
25628 }
25629 return NULL;
25630 }
25631
25632
25633 SWIGINTERN PyObject *_wrap_DateTime_MakeFromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25634 PyObject *resultobj = 0;
25635 wxDateTime *arg1 = (wxDateTime *) 0 ;
25636 wxDateTime::TimeZone *arg2 = 0 ;
25637 bool arg3 = (bool) false ;
25638 wxDateTime *result = 0 ;
25639 void *argp1 = 0 ;
25640 int res1 = 0 ;
25641 bool temp2 = false ;
25642 bool val3 ;
25643 int ecode3 = 0 ;
25644 PyObject * obj0 = 0 ;
25645 PyObject * obj1 = 0 ;
25646 PyObject * obj2 = 0 ;
25647 char * kwnames[] = {
25648 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25649 };
25650
25651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeFromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25652 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25653 if (!SWIG_IsOK(res1)) {
25654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25655 }
25656 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25657 {
25658 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25659 temp2 = true;
25660 }
25661 if (obj2) {
25662 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25663 if (!SWIG_IsOK(ecode3)) {
25664 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "3"" of type '" "bool""'");
25665 }
25666 arg3 = static_cast< bool >(val3);
25667 }
25668 {
25669 PyThreadState* __tstate = wxPyBeginAllowThreads();
25670 {
25671 wxDateTime &_result_ref = (arg1)->MakeFromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25672 result = (wxDateTime *) &_result_ref;
25673 }
25674 wxPyEndAllowThreads(__tstate);
25675 if (PyErr_Occurred()) SWIG_fail;
25676 }
25677 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25678 {
25679 if (temp2) delete arg2;
25680 }
25681 return resultobj;
25682 fail:
25683 {
25684 if (temp2) delete arg2;
25685 }
25686 return NULL;
25687 }
25688
25689
25690 SWIGINTERN PyObject *_wrap_DateTime_ToUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25691 PyObject *resultobj = 0;
25692 wxDateTime *arg1 = (wxDateTime *) 0 ;
25693 bool arg2 = (bool) false ;
25694 wxDateTime result;
25695 void *argp1 = 0 ;
25696 int res1 = 0 ;
25697 bool val2 ;
25698 int ecode2 = 0 ;
25699 PyObject * obj0 = 0 ;
25700 PyObject * obj1 = 0 ;
25701 char * kwnames[] = {
25702 (char *) "self",(char *) "noDST", NULL
25703 };
25704
25705 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToUTC",kwnames,&obj0,&obj1)) SWIG_fail;
25706 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25707 if (!SWIG_IsOK(res1)) {
25708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25709 }
25710 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25711 if (obj1) {
25712 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25713 if (!SWIG_IsOK(ecode2)) {
25714 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToUTC" "', expected argument " "2"" of type '" "bool""'");
25715 }
25716 arg2 = static_cast< bool >(val2);
25717 }
25718 {
25719 PyThreadState* __tstate = wxPyBeginAllowThreads();
25720 result = ((wxDateTime const *)arg1)->ToUTC(arg2);
25721 wxPyEndAllowThreads(__tstate);
25722 if (PyErr_Occurred()) SWIG_fail;
25723 }
25724 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25725 return resultobj;
25726 fail:
25727 return NULL;
25728 }
25729
25730
25731 SWIGINTERN PyObject *_wrap_DateTime_MakeUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25732 PyObject *resultobj = 0;
25733 wxDateTime *arg1 = (wxDateTime *) 0 ;
25734 bool arg2 = (bool) false ;
25735 wxDateTime *result = 0 ;
25736 void *argp1 = 0 ;
25737 int res1 = 0 ;
25738 bool val2 ;
25739 int ecode2 = 0 ;
25740 PyObject * obj0 = 0 ;
25741 PyObject * obj1 = 0 ;
25742 char * kwnames[] = {
25743 (char *) "self",(char *) "noDST", NULL
25744 };
25745
25746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeUTC",kwnames,&obj0,&obj1)) SWIG_fail;
25747 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25748 if (!SWIG_IsOK(res1)) {
25749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
25750 }
25751 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25752 if (obj1) {
25753 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25754 if (!SWIG_IsOK(ecode2)) {
25755 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeUTC" "', expected argument " "2"" of type '" "bool""'");
25756 }
25757 arg2 = static_cast< bool >(val2);
25758 }
25759 {
25760 PyThreadState* __tstate = wxPyBeginAllowThreads();
25761 {
25762 wxDateTime &_result_ref = (arg1)->MakeUTC(arg2);
25763 result = (wxDateTime *) &_result_ref;
25764 }
25765 wxPyEndAllowThreads(__tstate);
25766 if (PyErr_Occurred()) SWIG_fail;
25767 }
25768 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25769 return resultobj;
25770 fail:
25771 return NULL;
25772 }
25773
25774
25775 SWIGINTERN PyObject *_wrap_DateTime_ToGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25776 PyObject *resultobj = 0;
25777 wxDateTime *arg1 = (wxDateTime *) 0 ;
25778 bool arg2 = (bool) false ;
25779 wxDateTime result;
25780 void *argp1 = 0 ;
25781 int res1 = 0 ;
25782 bool val2 ;
25783 int ecode2 = 0 ;
25784 PyObject * obj0 = 0 ;
25785 PyObject * obj1 = 0 ;
25786 char * kwnames[] = {
25787 (char *) "self",(char *) "noDST", NULL
25788 };
25789
25790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) SWIG_fail;
25791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25792 if (!SWIG_IsOK(res1)) {
25793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToGMT" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25794 }
25795 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25796 if (obj1) {
25797 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25798 if (!SWIG_IsOK(ecode2)) {
25799 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToGMT" "', expected argument " "2"" of type '" "bool""'");
25800 }
25801 arg2 = static_cast< bool >(val2);
25802 }
25803 {
25804 PyThreadState* __tstate = wxPyBeginAllowThreads();
25805 result = ((wxDateTime const *)arg1)->ToGMT(arg2);
25806 wxPyEndAllowThreads(__tstate);
25807 if (PyErr_Occurred()) SWIG_fail;
25808 }
25809 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25810 return resultobj;
25811 fail:
25812 return NULL;
25813 }
25814
25815
25816 SWIGINTERN PyObject *_wrap_DateTime_MakeGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25817 PyObject *resultobj = 0;
25818 wxDateTime *arg1 = (wxDateTime *) 0 ;
25819 bool arg2 = (bool) false ;
25820 wxDateTime *result = 0 ;
25821 void *argp1 = 0 ;
25822 int res1 = 0 ;
25823 bool val2 ;
25824 int ecode2 = 0 ;
25825 PyObject * obj0 = 0 ;
25826 PyObject * obj1 = 0 ;
25827 char * kwnames[] = {
25828 (char *) "self",(char *) "noDST", NULL
25829 };
25830
25831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) SWIG_fail;
25832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25833 if (!SWIG_IsOK(res1)) {
25834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeGMT" "', expected argument " "1"" of type '" "wxDateTime *""'");
25835 }
25836 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25837 if (obj1) {
25838 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25839 if (!SWIG_IsOK(ecode2)) {
25840 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeGMT" "', expected argument " "2"" of type '" "bool""'");
25841 }
25842 arg2 = static_cast< bool >(val2);
25843 }
25844 {
25845 PyThreadState* __tstate = wxPyBeginAllowThreads();
25846 {
25847 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
25848 result = (wxDateTime *) &_result_ref;
25849 }
25850 wxPyEndAllowThreads(__tstate);
25851 if (PyErr_Occurred()) SWIG_fail;
25852 }
25853 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25854 return resultobj;
25855 fail:
25856 return NULL;
25857 }
25858
25859
25860 SWIGINTERN PyObject *_wrap_DateTime_FromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25861 PyObject *resultobj = 0;
25862 wxDateTime *arg1 = (wxDateTime *) 0 ;
25863 bool arg2 = (bool) false ;
25864 wxDateTime result;
25865 void *argp1 = 0 ;
25866 int res1 = 0 ;
25867 bool val2 ;
25868 int ecode2 = 0 ;
25869 PyObject * obj0 = 0 ;
25870 PyObject * obj1 = 0 ;
25871 char * kwnames[] = {
25872 (char *) "self",(char *) "noDST", NULL
25873 };
25874
25875 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_FromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
25876 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25877 if (!SWIG_IsOK(res1)) {
25878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25879 }
25880 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25881 if (obj1) {
25882 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25883 if (!SWIG_IsOK(ecode2)) {
25884 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_FromUTC" "', expected argument " "2"" of type '" "bool""'");
25885 }
25886 arg2 = static_cast< bool >(val2);
25887 }
25888 {
25889 PyThreadState* __tstate = wxPyBeginAllowThreads();
25890 result = ((wxDateTime const *)arg1)->FromUTC(arg2);
25891 wxPyEndAllowThreads(__tstate);
25892 if (PyErr_Occurred()) SWIG_fail;
25893 }
25894 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25895 return resultobj;
25896 fail:
25897 return NULL;
25898 }
25899
25900
25901 SWIGINTERN PyObject *_wrap_DateTime_MakeFromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25902 PyObject *resultobj = 0;
25903 wxDateTime *arg1 = (wxDateTime *) 0 ;
25904 bool arg2 = (bool) false ;
25905 wxDateTime *result = 0 ;
25906 void *argp1 = 0 ;
25907 int res1 = 0 ;
25908 bool val2 ;
25909 int ecode2 = 0 ;
25910 PyObject * obj0 = 0 ;
25911 PyObject * obj1 = 0 ;
25912 char * kwnames[] = {
25913 (char *) "self",(char *) "noDST", NULL
25914 };
25915
25916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeFromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
25917 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25918 if (!SWIG_IsOK(res1)) {
25919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
25920 }
25921 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25922 if (obj1) {
25923 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25924 if (!SWIG_IsOK(ecode2)) {
25925 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeFromUTC" "', expected argument " "2"" of type '" "bool""'");
25926 }
25927 arg2 = static_cast< bool >(val2);
25928 }
25929 {
25930 PyThreadState* __tstate = wxPyBeginAllowThreads();
25931 {
25932 wxDateTime &_result_ref = (arg1)->MakeFromUTC(arg2);
25933 result = (wxDateTime *) &_result_ref;
25934 }
25935 wxPyEndAllowThreads(__tstate);
25936 if (PyErr_Occurred()) SWIG_fail;
25937 }
25938 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25939 return resultobj;
25940 fail:
25941 return NULL;
25942 }
25943
25944
25945 SWIGINTERN PyObject *_wrap_DateTime_IsDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25946 PyObject *resultobj = 0;
25947 wxDateTime *arg1 = (wxDateTime *) 0 ;
25948 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
25949 int result;
25950 void *argp1 = 0 ;
25951 int res1 = 0 ;
25952 int val2 ;
25953 int ecode2 = 0 ;
25954 PyObject * obj0 = 0 ;
25955 PyObject * obj1 = 0 ;
25956 char * kwnames[] = {
25957 (char *) "self",(char *) "country", NULL
25958 };
25959
25960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) SWIG_fail;
25961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25962 if (!SWIG_IsOK(res1)) {
25963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsDST" "', expected argument " "1"" of type '" "wxDateTime *""'");
25964 }
25965 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25966 if (obj1) {
25967 ecode2 = SWIG_AsVal_int(obj1, &val2);
25968 if (!SWIG_IsOK(ecode2)) {
25969 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
25970 }
25971 arg2 = static_cast< wxDateTime::Country >(val2);
25972 }
25973 {
25974 PyThreadState* __tstate = wxPyBeginAllowThreads();
25975 result = (int)(arg1)->IsDST(arg2);
25976 wxPyEndAllowThreads(__tstate);
25977 if (PyErr_Occurred()) SWIG_fail;
25978 }
25979 resultobj = SWIG_From_int(static_cast< int >(result));
25980 return resultobj;
25981 fail:
25982 return NULL;
25983 }
25984
25985
25986 SWIGINTERN PyObject *_wrap_DateTime_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25987 PyObject *resultobj = 0;
25988 wxDateTime *arg1 = (wxDateTime *) 0 ;
25989 bool result;
25990 void *argp1 = 0 ;
25991 int res1 = 0 ;
25992 PyObject *swig_obj[1] ;
25993
25994 if (!args) SWIG_fail;
25995 swig_obj[0] = args;
25996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25997 if (!SWIG_IsOK(res1)) {
25998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsValid" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25999 }
26000 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26001 {
26002 PyThreadState* __tstate = wxPyBeginAllowThreads();
26003 result = (bool)((wxDateTime const *)arg1)->IsValid();
26004 wxPyEndAllowThreads(__tstate);
26005 if (PyErr_Occurred()) SWIG_fail;
26006 }
26007 {
26008 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26009 }
26010 return resultobj;
26011 fail:
26012 return NULL;
26013 }
26014
26015
26016 SWIGINTERN PyObject *_wrap_DateTime_GetTicks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26017 PyObject *resultobj = 0;
26018 wxDateTime *arg1 = (wxDateTime *) 0 ;
26019 time_t result;
26020 void *argp1 = 0 ;
26021 int res1 = 0 ;
26022 PyObject *swig_obj[1] ;
26023
26024 if (!args) SWIG_fail;
26025 swig_obj[0] = args;
26026 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26027 if (!SWIG_IsOK(res1)) {
26028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetTicks" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26029 }
26030 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26031 {
26032 PyThreadState* __tstate = wxPyBeginAllowThreads();
26033 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
26034 wxPyEndAllowThreads(__tstate);
26035 if (PyErr_Occurred()) SWIG_fail;
26036 }
26037 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
26038 return resultobj;
26039 fail:
26040 return NULL;
26041 }
26042
26043
26044 SWIGINTERN PyObject *_wrap_DateTime_GetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26045 PyObject *resultobj = 0;
26046 wxDateTime *arg1 = (wxDateTime *) 0 ;
26047 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26048 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26049 int result;
26050 void *argp1 = 0 ;
26051 int res1 = 0 ;
26052 bool temp2 = false ;
26053 PyObject * obj0 = 0 ;
26054 PyObject * obj1 = 0 ;
26055 char * kwnames[] = {
26056 (char *) "self",(char *) "tz", NULL
26057 };
26058
26059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) SWIG_fail;
26060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26061 if (!SWIG_IsOK(res1)) {
26062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26063 }
26064 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26065 if (obj1) {
26066 {
26067 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26068 temp2 = true;
26069 }
26070 }
26071 {
26072 PyThreadState* __tstate = wxPyBeginAllowThreads();
26073 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
26074 wxPyEndAllowThreads(__tstate);
26075 if (PyErr_Occurred()) SWIG_fail;
26076 }
26077 resultobj = SWIG_From_int(static_cast< int >(result));
26078 {
26079 if (temp2) delete arg2;
26080 }
26081 return resultobj;
26082 fail:
26083 {
26084 if (temp2) delete arg2;
26085 }
26086 return NULL;
26087 }
26088
26089
26090 SWIGINTERN PyObject *_wrap_DateTime_GetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26091 PyObject *resultobj = 0;
26092 wxDateTime *arg1 = (wxDateTime *) 0 ;
26093 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26094 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26095 wxDateTime::Month result;
26096 void *argp1 = 0 ;
26097 int res1 = 0 ;
26098 bool temp2 = false ;
26099 PyObject * obj0 = 0 ;
26100 PyObject * obj1 = 0 ;
26101 char * kwnames[] = {
26102 (char *) "self",(char *) "tz", NULL
26103 };
26104
26105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
26106 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26107 if (!SWIG_IsOK(res1)) {
26108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26109 }
26110 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26111 if (obj1) {
26112 {
26113 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26114 temp2 = true;
26115 }
26116 }
26117 {
26118 PyThreadState* __tstate = wxPyBeginAllowThreads();
26119 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
26120 wxPyEndAllowThreads(__tstate);
26121 if (PyErr_Occurred()) SWIG_fail;
26122 }
26123 resultobj = SWIG_From_int(static_cast< int >(result));
26124 {
26125 if (temp2) delete arg2;
26126 }
26127 return resultobj;
26128 fail:
26129 {
26130 if (temp2) delete arg2;
26131 }
26132 return NULL;
26133 }
26134
26135
26136 SWIGINTERN PyObject *_wrap_DateTime_GetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26137 PyObject *resultobj = 0;
26138 wxDateTime *arg1 = (wxDateTime *) 0 ;
26139 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26140 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26141 int result;
26142 void *argp1 = 0 ;
26143 int res1 = 0 ;
26144 bool temp2 = false ;
26145 PyObject * obj0 = 0 ;
26146 PyObject * obj1 = 0 ;
26147 char * kwnames[] = {
26148 (char *) "self",(char *) "tz", NULL
26149 };
26150
26151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) SWIG_fail;
26152 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26153 if (!SWIG_IsOK(res1)) {
26154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26155 }
26156 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26157 if (obj1) {
26158 {
26159 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26160 temp2 = true;
26161 }
26162 }
26163 {
26164 PyThreadState* __tstate = wxPyBeginAllowThreads();
26165 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
26166 wxPyEndAllowThreads(__tstate);
26167 if (PyErr_Occurred()) SWIG_fail;
26168 }
26169 resultobj = SWIG_From_int(static_cast< int >(result));
26170 {
26171 if (temp2) delete arg2;
26172 }
26173 return resultobj;
26174 fail:
26175 {
26176 if (temp2) delete arg2;
26177 }
26178 return NULL;
26179 }
26180
26181
26182 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26183 PyObject *resultobj = 0;
26184 wxDateTime *arg1 = (wxDateTime *) 0 ;
26185 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26186 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26187 wxDateTime::WeekDay result;
26188 void *argp1 = 0 ;
26189 int res1 = 0 ;
26190 bool temp2 = false ;
26191 PyObject * obj0 = 0 ;
26192 PyObject * obj1 = 0 ;
26193 char * kwnames[] = {
26194 (char *) "self",(char *) "tz", NULL
26195 };
26196
26197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
26198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26199 if (!SWIG_IsOK(res1)) {
26200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26201 }
26202 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26203 if (obj1) {
26204 {
26205 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26206 temp2 = true;
26207 }
26208 }
26209 {
26210 PyThreadState* __tstate = wxPyBeginAllowThreads();
26211 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
26212 wxPyEndAllowThreads(__tstate);
26213 if (PyErr_Occurred()) SWIG_fail;
26214 }
26215 resultobj = SWIG_From_int(static_cast< int >(result));
26216 {
26217 if (temp2) delete arg2;
26218 }
26219 return resultobj;
26220 fail:
26221 {
26222 if (temp2) delete arg2;
26223 }
26224 return NULL;
26225 }
26226
26227
26228 SWIGINTERN PyObject *_wrap_DateTime_GetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26229 PyObject *resultobj = 0;
26230 wxDateTime *arg1 = (wxDateTime *) 0 ;
26231 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26232 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26233 int result;
26234 void *argp1 = 0 ;
26235 int res1 = 0 ;
26236 bool temp2 = false ;
26237 PyObject * obj0 = 0 ;
26238 PyObject * obj1 = 0 ;
26239 char * kwnames[] = {
26240 (char *) "self",(char *) "tz", NULL
26241 };
26242
26243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) SWIG_fail;
26244 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26245 if (!SWIG_IsOK(res1)) {
26246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetHour" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26247 }
26248 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26249 if (obj1) {
26250 {
26251 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26252 temp2 = true;
26253 }
26254 }
26255 {
26256 PyThreadState* __tstate = wxPyBeginAllowThreads();
26257 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
26258 wxPyEndAllowThreads(__tstate);
26259 if (PyErr_Occurred()) SWIG_fail;
26260 }
26261 resultobj = SWIG_From_int(static_cast< int >(result));
26262 {
26263 if (temp2) delete arg2;
26264 }
26265 return resultobj;
26266 fail:
26267 {
26268 if (temp2) delete arg2;
26269 }
26270 return NULL;
26271 }
26272
26273
26274 SWIGINTERN PyObject *_wrap_DateTime_GetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26275 PyObject *resultobj = 0;
26276 wxDateTime *arg1 = (wxDateTime *) 0 ;
26277 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26278 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26279 int result;
26280 void *argp1 = 0 ;
26281 int res1 = 0 ;
26282 bool temp2 = false ;
26283 PyObject * obj0 = 0 ;
26284 PyObject * obj1 = 0 ;
26285 char * kwnames[] = {
26286 (char *) "self",(char *) "tz", NULL
26287 };
26288
26289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
26290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26291 if (!SWIG_IsOK(res1)) {
26292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMinute" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26293 }
26294 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26295 if (obj1) {
26296 {
26297 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26298 temp2 = true;
26299 }
26300 }
26301 {
26302 PyThreadState* __tstate = wxPyBeginAllowThreads();
26303 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
26304 wxPyEndAllowThreads(__tstate);
26305 if (PyErr_Occurred()) SWIG_fail;
26306 }
26307 resultobj = SWIG_From_int(static_cast< int >(result));
26308 {
26309 if (temp2) delete arg2;
26310 }
26311 return resultobj;
26312 fail:
26313 {
26314 if (temp2) delete arg2;
26315 }
26316 return NULL;
26317 }
26318
26319
26320 SWIGINTERN PyObject *_wrap_DateTime_GetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26321 PyObject *resultobj = 0;
26322 wxDateTime *arg1 = (wxDateTime *) 0 ;
26323 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26324 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26325 int result;
26326 void *argp1 = 0 ;
26327 int res1 = 0 ;
26328 bool temp2 = false ;
26329 PyObject * obj0 = 0 ;
26330 PyObject * obj1 = 0 ;
26331 char * kwnames[] = {
26332 (char *) "self",(char *) "tz", NULL
26333 };
26334
26335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
26336 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26337 if (!SWIG_IsOK(res1)) {
26338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetSecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26339 }
26340 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26341 if (obj1) {
26342 {
26343 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26344 temp2 = true;
26345 }
26346 }
26347 {
26348 PyThreadState* __tstate = wxPyBeginAllowThreads();
26349 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
26350 wxPyEndAllowThreads(__tstate);
26351 if (PyErr_Occurred()) SWIG_fail;
26352 }
26353 resultobj = SWIG_From_int(static_cast< int >(result));
26354 {
26355 if (temp2) delete arg2;
26356 }
26357 return resultobj;
26358 fail:
26359 {
26360 if (temp2) delete arg2;
26361 }
26362 return NULL;
26363 }
26364
26365
26366 SWIGINTERN PyObject *_wrap_DateTime_GetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26367 PyObject *resultobj = 0;
26368 wxDateTime *arg1 = (wxDateTime *) 0 ;
26369 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26370 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26371 int result;
26372 void *argp1 = 0 ;
26373 int res1 = 0 ;
26374 bool temp2 = false ;
26375 PyObject * obj0 = 0 ;
26376 PyObject * obj1 = 0 ;
26377 char * kwnames[] = {
26378 (char *) "self",(char *) "tz", NULL
26379 };
26380
26381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
26382 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26383 if (!SWIG_IsOK(res1)) {
26384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMillisecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26385 }
26386 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26387 if (obj1) {
26388 {
26389 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26390 temp2 = true;
26391 }
26392 }
26393 {
26394 PyThreadState* __tstate = wxPyBeginAllowThreads();
26395 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
26396 wxPyEndAllowThreads(__tstate);
26397 if (PyErr_Occurred()) SWIG_fail;
26398 }
26399 resultobj = SWIG_From_int(static_cast< int >(result));
26400 {
26401 if (temp2) delete arg2;
26402 }
26403 return resultobj;
26404 fail:
26405 {
26406 if (temp2) delete arg2;
26407 }
26408 return NULL;
26409 }
26410
26411
26412 SWIGINTERN PyObject *_wrap_DateTime_GetDayOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26413 PyObject *resultobj = 0;
26414 wxDateTime *arg1 = (wxDateTime *) 0 ;
26415 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26416 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26417 int result;
26418 void *argp1 = 0 ;
26419 int res1 = 0 ;
26420 bool temp2 = false ;
26421 PyObject * obj0 = 0 ;
26422 PyObject * obj1 = 0 ;
26423 char * kwnames[] = {
26424 (char *) "self",(char *) "tz", NULL
26425 };
26426
26427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) SWIG_fail;
26428 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26429 if (!SWIG_IsOK(res1)) {
26430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDayOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26431 }
26432 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26433 if (obj1) {
26434 {
26435 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26436 temp2 = true;
26437 }
26438 }
26439 {
26440 PyThreadState* __tstate = wxPyBeginAllowThreads();
26441 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
26442 wxPyEndAllowThreads(__tstate);
26443 if (PyErr_Occurred()) SWIG_fail;
26444 }
26445 resultobj = SWIG_From_int(static_cast< int >(result));
26446 {
26447 if (temp2) delete arg2;
26448 }
26449 return resultobj;
26450 fail:
26451 {
26452 if (temp2) delete arg2;
26453 }
26454 return NULL;
26455 }
26456
26457
26458 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26459 PyObject *resultobj = 0;
26460 wxDateTime *arg1 = (wxDateTime *) 0 ;
26461 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
26462 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
26463 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
26464 int result;
26465 void *argp1 = 0 ;
26466 int res1 = 0 ;
26467 int val2 ;
26468 int ecode2 = 0 ;
26469 bool temp3 = false ;
26470 PyObject * obj0 = 0 ;
26471 PyObject * obj1 = 0 ;
26472 PyObject * obj2 = 0 ;
26473 char * kwnames[] = {
26474 (char *) "self",(char *) "flags",(char *) "tz", NULL
26475 };
26476
26477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26478 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26479 if (!SWIG_IsOK(res1)) {
26480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26481 }
26482 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26483 if (obj1) {
26484 ecode2 = SWIG_AsVal_int(obj1, &val2);
26485 if (!SWIG_IsOK(ecode2)) {
26486 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
26487 }
26488 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
26489 }
26490 if (obj2) {
26491 {
26492 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
26493 temp3 = true;
26494 }
26495 }
26496 {
26497 PyThreadState* __tstate = wxPyBeginAllowThreads();
26498 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear(arg2,(wxDateTime::TimeZone const &)*arg3);
26499 wxPyEndAllowThreads(__tstate);
26500 if (PyErr_Occurred()) SWIG_fail;
26501 }
26502 resultobj = SWIG_From_int(static_cast< int >(result));
26503 {
26504 if (temp3) delete arg3;
26505 }
26506 return resultobj;
26507 fail:
26508 {
26509 if (temp3) delete arg3;
26510 }
26511 return NULL;
26512 }
26513
26514
26515 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26516 PyObject *resultobj = 0;
26517 wxDateTime *arg1 = (wxDateTime *) 0 ;
26518 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
26519 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
26520 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
26521 int result;
26522 void *argp1 = 0 ;
26523 int res1 = 0 ;
26524 int val2 ;
26525 int ecode2 = 0 ;
26526 bool temp3 = false ;
26527 PyObject * obj0 = 0 ;
26528 PyObject * obj1 = 0 ;
26529 PyObject * obj2 = 0 ;
26530 char * kwnames[] = {
26531 (char *) "self",(char *) "flags",(char *) "tz", NULL
26532 };
26533
26534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26535 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26536 if (!SWIG_IsOK(res1)) {
26537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26538 }
26539 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26540 if (obj1) {
26541 ecode2 = SWIG_AsVal_int(obj1, &val2);
26542 if (!SWIG_IsOK(ecode2)) {
26543 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
26544 }
26545 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
26546 }
26547 if (obj2) {
26548 {
26549 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
26550 temp3 = true;
26551 }
26552 }
26553 {
26554 PyThreadState* __tstate = wxPyBeginAllowThreads();
26555 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth(arg2,(wxDateTime::TimeZone const &)*arg3);
26556 wxPyEndAllowThreads(__tstate);
26557 if (PyErr_Occurred()) SWIG_fail;
26558 }
26559 resultobj = SWIG_From_int(static_cast< int >(result));
26560 {
26561 if (temp3) delete arg3;
26562 }
26563 return resultobj;
26564 fail:
26565 {
26566 if (temp3) delete arg3;
26567 }
26568 return NULL;
26569 }
26570
26571
26572 SWIGINTERN PyObject *_wrap_DateTime_IsWorkDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26573 PyObject *resultobj = 0;
26574 wxDateTime *arg1 = (wxDateTime *) 0 ;
26575 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
26576 bool result;
26577 void *argp1 = 0 ;
26578 int res1 = 0 ;
26579 int val2 ;
26580 int ecode2 = 0 ;
26581 PyObject * obj0 = 0 ;
26582 PyObject * obj1 = 0 ;
26583 char * kwnames[] = {
26584 (char *) "self",(char *) "country", NULL
26585 };
26586
26587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) SWIG_fail;
26588 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26589 if (!SWIG_IsOK(res1)) {
26590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsWorkDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26591 }
26592 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26593 if (obj1) {
26594 ecode2 = SWIG_AsVal_int(obj1, &val2);
26595 if (!SWIG_IsOK(ecode2)) {
26596 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsWorkDay" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
26597 }
26598 arg2 = static_cast< wxDateTime::Country >(val2);
26599 }
26600 {
26601 PyThreadState* __tstate = wxPyBeginAllowThreads();
26602 result = (bool)((wxDateTime const *)arg1)->IsWorkDay(arg2);
26603 wxPyEndAllowThreads(__tstate);
26604 if (PyErr_Occurred()) SWIG_fail;
26605 }
26606 {
26607 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26608 }
26609 return resultobj;
26610 fail:
26611 return NULL;
26612 }
26613
26614
26615 SWIGINTERN PyObject *_wrap_DateTime_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26616 PyObject *resultobj = 0;
26617 wxDateTime *arg1 = (wxDateTime *) 0 ;
26618 wxDateTime *arg2 = 0 ;
26619 bool result;
26620 void *argp1 = 0 ;
26621 int res1 = 0 ;
26622 void *argp2 = 0 ;
26623 int res2 = 0 ;
26624 PyObject * obj0 = 0 ;
26625 PyObject * obj1 = 0 ;
26626 char * kwnames[] = {
26627 (char *) "self",(char *) "datetime", NULL
26628 };
26629
26630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
26631 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26632 if (!SWIG_IsOK(res1)) {
26633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26634 }
26635 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26636 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26637 if (!SWIG_IsOK(res2)) {
26638 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26639 }
26640 if (!argp2) {
26641 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26642 }
26643 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26644 {
26645 PyThreadState* __tstate = wxPyBeginAllowThreads();
26646 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
26647 wxPyEndAllowThreads(__tstate);
26648 if (PyErr_Occurred()) SWIG_fail;
26649 }
26650 {
26651 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26652 }
26653 return resultobj;
26654 fail:
26655 return NULL;
26656 }
26657
26658
26659 SWIGINTERN PyObject *_wrap_DateTime_IsEarlierThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26660 PyObject *resultobj = 0;
26661 wxDateTime *arg1 = (wxDateTime *) 0 ;
26662 wxDateTime *arg2 = 0 ;
26663 bool result;
26664 void *argp1 = 0 ;
26665 int res1 = 0 ;
26666 void *argp2 = 0 ;
26667 int res2 = 0 ;
26668 PyObject * obj0 = 0 ;
26669 PyObject * obj1 = 0 ;
26670 char * kwnames[] = {
26671 (char *) "self",(char *) "datetime", NULL
26672 };
26673
26674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) SWIG_fail;
26675 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26676 if (!SWIG_IsOK(res1)) {
26677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEarlierThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26678 }
26679 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26680 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26681 if (!SWIG_IsOK(res2)) {
26682 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26683 }
26684 if (!argp2) {
26685 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26686 }
26687 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26688 {
26689 PyThreadState* __tstate = wxPyBeginAllowThreads();
26690 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
26691 wxPyEndAllowThreads(__tstate);
26692 if (PyErr_Occurred()) SWIG_fail;
26693 }
26694 {
26695 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26696 }
26697 return resultobj;
26698 fail:
26699 return NULL;
26700 }
26701
26702
26703 SWIGINTERN PyObject *_wrap_DateTime_IsLaterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26704 PyObject *resultobj = 0;
26705 wxDateTime *arg1 = (wxDateTime *) 0 ;
26706 wxDateTime *arg2 = 0 ;
26707 bool result;
26708 void *argp1 = 0 ;
26709 int res1 = 0 ;
26710 void *argp2 = 0 ;
26711 int res2 = 0 ;
26712 PyObject * obj0 = 0 ;
26713 PyObject * obj1 = 0 ;
26714 char * kwnames[] = {
26715 (char *) "self",(char *) "datetime", NULL
26716 };
26717
26718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) SWIG_fail;
26719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26720 if (!SWIG_IsOK(res1)) {
26721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsLaterThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26722 }
26723 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26724 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26725 if (!SWIG_IsOK(res2)) {
26726 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26727 }
26728 if (!argp2) {
26729 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26730 }
26731 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26732 {
26733 PyThreadState* __tstate = wxPyBeginAllowThreads();
26734 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
26735 wxPyEndAllowThreads(__tstate);
26736 if (PyErr_Occurred()) SWIG_fail;
26737 }
26738 {
26739 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26740 }
26741 return resultobj;
26742 fail:
26743 return NULL;
26744 }
26745
26746
26747 SWIGINTERN PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26748 PyObject *resultobj = 0;
26749 wxDateTime *arg1 = (wxDateTime *) 0 ;
26750 wxDateTime *arg2 = 0 ;
26751 wxDateTime *arg3 = 0 ;
26752 bool result;
26753 void *argp1 = 0 ;
26754 int res1 = 0 ;
26755 void *argp2 = 0 ;
26756 int res2 = 0 ;
26757 void *argp3 = 0 ;
26758 int res3 = 0 ;
26759 PyObject * obj0 = 0 ;
26760 PyObject * obj1 = 0 ;
26761 PyObject * obj2 = 0 ;
26762 char * kwnames[] = {
26763 (char *) "self",(char *) "t1",(char *) "t2", NULL
26764 };
26765
26766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26768 if (!SWIG_IsOK(res1)) {
26769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26770 }
26771 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26772 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26773 if (!SWIG_IsOK(res2)) {
26774 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26775 }
26776 if (!argp2) {
26777 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26778 }
26779 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26780 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
26781 if (!SWIG_IsOK(res3)) {
26782 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
26783 }
26784 if (!argp3) {
26785 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
26786 }
26787 arg3 = reinterpret_cast< wxDateTime * >(argp3);
26788 {
26789 PyThreadState* __tstate = wxPyBeginAllowThreads();
26790 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
26791 wxPyEndAllowThreads(__tstate);
26792 if (PyErr_Occurred()) SWIG_fail;
26793 }
26794 {
26795 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26796 }
26797 return resultobj;
26798 fail:
26799 return NULL;
26800 }
26801
26802
26803 SWIGINTERN PyObject *_wrap_DateTime_IsBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26804 PyObject *resultobj = 0;
26805 wxDateTime *arg1 = (wxDateTime *) 0 ;
26806 wxDateTime *arg2 = 0 ;
26807 wxDateTime *arg3 = 0 ;
26808 bool result;
26809 void *argp1 = 0 ;
26810 int res1 = 0 ;
26811 void *argp2 = 0 ;
26812 int res2 = 0 ;
26813 void *argp3 = 0 ;
26814 int res3 = 0 ;
26815 PyObject * obj0 = 0 ;
26816 PyObject * obj1 = 0 ;
26817 PyObject * obj2 = 0 ;
26818 char * kwnames[] = {
26819 (char *) "self",(char *) "t1",(char *) "t2", NULL
26820 };
26821
26822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26824 if (!SWIG_IsOK(res1)) {
26825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26826 }
26827 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26828 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26829 if (!SWIG_IsOK(res2)) {
26830 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26831 }
26832 if (!argp2) {
26833 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26834 }
26835 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26836 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
26837 if (!SWIG_IsOK(res3)) {
26838 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
26839 }
26840 if (!argp3) {
26841 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
26842 }
26843 arg3 = reinterpret_cast< wxDateTime * >(argp3);
26844 {
26845 PyThreadState* __tstate = wxPyBeginAllowThreads();
26846 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
26847 wxPyEndAllowThreads(__tstate);
26848 if (PyErr_Occurred()) SWIG_fail;
26849 }
26850 {
26851 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26852 }
26853 return resultobj;
26854 fail:
26855 return NULL;
26856 }
26857
26858
26859 SWIGINTERN PyObject *_wrap_DateTime_IsSameDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26860 PyObject *resultobj = 0;
26861 wxDateTime *arg1 = (wxDateTime *) 0 ;
26862 wxDateTime *arg2 = 0 ;
26863 bool result;
26864 void *argp1 = 0 ;
26865 int res1 = 0 ;
26866 void *argp2 = 0 ;
26867 int res2 = 0 ;
26868 PyObject * obj0 = 0 ;
26869 PyObject * obj1 = 0 ;
26870 char * kwnames[] = {
26871 (char *) "self",(char *) "dt", NULL
26872 };
26873
26874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) SWIG_fail;
26875 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26876 if (!SWIG_IsOK(res1)) {
26877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26878 }
26879 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26880 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26881 if (!SWIG_IsOK(res2)) {
26882 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26883 }
26884 if (!argp2) {
26885 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26886 }
26887 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26888 {
26889 PyThreadState* __tstate = wxPyBeginAllowThreads();
26890 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
26891 wxPyEndAllowThreads(__tstate);
26892 if (PyErr_Occurred()) SWIG_fail;
26893 }
26894 {
26895 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26896 }
26897 return resultobj;
26898 fail:
26899 return NULL;
26900 }
26901
26902
26903 SWIGINTERN PyObject *_wrap_DateTime_IsSameTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26904 PyObject *resultobj = 0;
26905 wxDateTime *arg1 = (wxDateTime *) 0 ;
26906 wxDateTime *arg2 = 0 ;
26907 bool result;
26908 void *argp1 = 0 ;
26909 int res1 = 0 ;
26910 void *argp2 = 0 ;
26911 int res2 = 0 ;
26912 PyObject * obj0 = 0 ;
26913 PyObject * obj1 = 0 ;
26914 char * kwnames[] = {
26915 (char *) "self",(char *) "dt", NULL
26916 };
26917
26918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) SWIG_fail;
26919 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26920 if (!SWIG_IsOK(res1)) {
26921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26922 }
26923 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26924 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26925 if (!SWIG_IsOK(res2)) {
26926 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26927 }
26928 if (!argp2) {
26929 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26930 }
26931 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26932 {
26933 PyThreadState* __tstate = wxPyBeginAllowThreads();
26934 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
26935 wxPyEndAllowThreads(__tstate);
26936 if (PyErr_Occurred()) SWIG_fail;
26937 }
26938 {
26939 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26940 }
26941 return resultobj;
26942 fail:
26943 return NULL;
26944 }
26945
26946
26947 SWIGINTERN PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26948 PyObject *resultobj = 0;
26949 wxDateTime *arg1 = (wxDateTime *) 0 ;
26950 wxDateTime *arg2 = 0 ;
26951 wxTimeSpan *arg3 = 0 ;
26952 bool result;
26953 void *argp1 = 0 ;
26954 int res1 = 0 ;
26955 void *argp2 = 0 ;
26956 int res2 = 0 ;
26957 void *argp3 = 0 ;
26958 int res3 = 0 ;
26959 PyObject * obj0 = 0 ;
26960 PyObject * obj1 = 0 ;
26961 PyObject * obj2 = 0 ;
26962 char * kwnames[] = {
26963 (char *) "self",(char *) "dt",(char *) "ts", NULL
26964 };
26965
26966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26967 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26968 if (!SWIG_IsOK(res1)) {
26969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26970 }
26971 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26972 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26973 if (!SWIG_IsOK(res2)) {
26974 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26975 }
26976 if (!argp2) {
26977 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26978 }
26979 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26980 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26981 if (!SWIG_IsOK(res3)) {
26982 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
26983 }
26984 if (!argp3) {
26985 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
26986 }
26987 arg3 = reinterpret_cast< wxTimeSpan * >(argp3);
26988 {
26989 PyThreadState* __tstate = wxPyBeginAllowThreads();
26990 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
26991 wxPyEndAllowThreads(__tstate);
26992 if (PyErr_Occurred()) SWIG_fail;
26993 }
26994 {
26995 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26996 }
26997 return resultobj;
26998 fail:
26999 return NULL;
27000 }
27001
27002
27003 SWIGINTERN PyObject *_wrap_DateTime_AddTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27004 PyObject *resultobj = 0;
27005 wxDateTime *arg1 = (wxDateTime *) 0 ;
27006 wxTimeSpan *arg2 = 0 ;
27007 wxDateTime *result = 0 ;
27008 void *argp1 = 0 ;
27009 int res1 = 0 ;
27010 void *argp2 = 0 ;
27011 int res2 = 0 ;
27012 PyObject * obj0 = 0 ;
27013 PyObject * obj1 = 0 ;
27014 char * kwnames[] = {
27015 (char *) "self",(char *) "diff", NULL
27016 };
27017
27018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) SWIG_fail;
27019 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27020 if (!SWIG_IsOK(res1)) {
27021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27022 }
27023 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27024 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27025 if (!SWIG_IsOK(res2)) {
27026 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27027 }
27028 if (!argp2) {
27029 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27030 }
27031 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27032 {
27033 PyThreadState* __tstate = wxPyBeginAllowThreads();
27034 {
27035 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
27036 result = (wxDateTime *) &_result_ref;
27037 }
27038 wxPyEndAllowThreads(__tstate);
27039 if (PyErr_Occurred()) SWIG_fail;
27040 }
27041 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27042 return resultobj;
27043 fail:
27044 return NULL;
27045 }
27046
27047
27048 SWIGINTERN PyObject *_wrap_DateTime_AddDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27049 PyObject *resultobj = 0;
27050 wxDateTime *arg1 = (wxDateTime *) 0 ;
27051 wxDateSpan *arg2 = 0 ;
27052 wxDateTime *result = 0 ;
27053 void *argp1 = 0 ;
27054 int res1 = 0 ;
27055 void *argp2 = 0 ;
27056 int res2 = 0 ;
27057 PyObject * obj0 = 0 ;
27058 PyObject * obj1 = 0 ;
27059 char * kwnames[] = {
27060 (char *) "self",(char *) "diff", NULL
27061 };
27062
27063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) SWIG_fail;
27064 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27065 if (!SWIG_IsOK(res1)) {
27066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27067 }
27068 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27069 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27070 if (!SWIG_IsOK(res2)) {
27071 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27072 }
27073 if (!argp2) {
27074 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27075 }
27076 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27077 {
27078 PyThreadState* __tstate = wxPyBeginAllowThreads();
27079 {
27080 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
27081 result = (wxDateTime *) &_result_ref;
27082 }
27083 wxPyEndAllowThreads(__tstate);
27084 if (PyErr_Occurred()) SWIG_fail;
27085 }
27086 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27087 return resultobj;
27088 fail:
27089 return NULL;
27090 }
27091
27092
27093 SWIGINTERN PyObject *_wrap_DateTime_SubtractTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27094 PyObject *resultobj = 0;
27095 wxDateTime *arg1 = (wxDateTime *) 0 ;
27096 wxTimeSpan *arg2 = 0 ;
27097 wxDateTime *result = 0 ;
27098 void *argp1 = 0 ;
27099 int res1 = 0 ;
27100 void *argp2 = 0 ;
27101 int res2 = 0 ;
27102 PyObject * obj0 = 0 ;
27103 PyObject * obj1 = 0 ;
27104 char * kwnames[] = {
27105 (char *) "self",(char *) "diff", NULL
27106 };
27107
27108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) SWIG_fail;
27109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27110 if (!SWIG_IsOK(res1)) {
27111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27112 }
27113 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27114 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27115 if (!SWIG_IsOK(res2)) {
27116 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27117 }
27118 if (!argp2) {
27119 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27120 }
27121 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27122 {
27123 PyThreadState* __tstate = wxPyBeginAllowThreads();
27124 {
27125 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
27126 result = (wxDateTime *) &_result_ref;
27127 }
27128 wxPyEndAllowThreads(__tstate);
27129 if (PyErr_Occurred()) SWIG_fail;
27130 }
27131 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27132 return resultobj;
27133 fail:
27134 return NULL;
27135 }
27136
27137
27138 SWIGINTERN PyObject *_wrap_DateTime_SubtractDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27139 PyObject *resultobj = 0;
27140 wxDateTime *arg1 = (wxDateTime *) 0 ;
27141 wxDateSpan *arg2 = 0 ;
27142 wxDateTime *result = 0 ;
27143 void *argp1 = 0 ;
27144 int res1 = 0 ;
27145 void *argp2 = 0 ;
27146 int res2 = 0 ;
27147 PyObject * obj0 = 0 ;
27148 PyObject * obj1 = 0 ;
27149 char * kwnames[] = {
27150 (char *) "self",(char *) "diff", NULL
27151 };
27152
27153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) SWIG_fail;
27154 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27155 if (!SWIG_IsOK(res1)) {
27156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27157 }
27158 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27159 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27160 if (!SWIG_IsOK(res2)) {
27161 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27162 }
27163 if (!argp2) {
27164 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27165 }
27166 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27167 {
27168 PyThreadState* __tstate = wxPyBeginAllowThreads();
27169 {
27170 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
27171 result = (wxDateTime *) &_result_ref;
27172 }
27173 wxPyEndAllowThreads(__tstate);
27174 if (PyErr_Occurred()) SWIG_fail;
27175 }
27176 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27177 return resultobj;
27178 fail:
27179 return NULL;
27180 }
27181
27182
27183 SWIGINTERN PyObject *_wrap_DateTime_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27184 PyObject *resultobj = 0;
27185 wxDateTime *arg1 = (wxDateTime *) 0 ;
27186 wxDateTime *arg2 = 0 ;
27187 wxTimeSpan result;
27188 void *argp1 = 0 ;
27189 int res1 = 0 ;
27190 void *argp2 = 0 ;
27191 int res2 = 0 ;
27192 PyObject * obj0 = 0 ;
27193 PyObject * obj1 = 0 ;
27194 char * kwnames[] = {
27195 (char *) "self",(char *) "dt", NULL
27196 };
27197
27198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
27199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27200 if (!SWIG_IsOK(res1)) {
27201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Subtract" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27202 }
27203 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27204 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27205 if (!SWIG_IsOK(res2)) {
27206 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27207 }
27208 if (!argp2) {
27209 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27210 }
27211 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27212 {
27213 PyThreadState* __tstate = wxPyBeginAllowThreads();
27214 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
27215 wxPyEndAllowThreads(__tstate);
27216 if (PyErr_Occurred()) SWIG_fail;
27217 }
27218 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27219 return resultobj;
27220 fail:
27221 return NULL;
27222 }
27223
27224
27225 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27226 PyObject *resultobj = 0;
27227 wxDateTime *arg1 = (wxDateTime *) 0 ;
27228 wxTimeSpan *arg2 = 0 ;
27229 wxDateTime *result = 0 ;
27230 void *argp1 = 0 ;
27231 int res1 = 0 ;
27232 void *argp2 = 0 ;
27233 int res2 = 0 ;
27234
27235 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27236 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27237 if (!SWIG_IsOK(res1)) {
27238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27239 }
27240 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27241 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27242 if (!SWIG_IsOK(res2)) {
27243 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27244 }
27245 if (!argp2) {
27246 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27247 }
27248 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27249 {
27250 PyThreadState* __tstate = wxPyBeginAllowThreads();
27251 {
27252 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
27253 result = (wxDateTime *) &_result_ref;
27254 }
27255 wxPyEndAllowThreads(__tstate);
27256 if (PyErr_Occurred()) SWIG_fail;
27257 }
27258 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27259 return resultobj;
27260 fail:
27261 return NULL;
27262 }
27263
27264
27265 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27266 PyObject *resultobj = 0;
27267 wxDateTime *arg1 = (wxDateTime *) 0 ;
27268 wxDateSpan *arg2 = 0 ;
27269 wxDateTime *result = 0 ;
27270 void *argp1 = 0 ;
27271 int res1 = 0 ;
27272 void *argp2 = 0 ;
27273 int res2 = 0 ;
27274
27275 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27277 if (!SWIG_IsOK(res1)) {
27278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27279 }
27280 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27281 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27282 if (!SWIG_IsOK(res2)) {
27283 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27284 }
27285 if (!argp2) {
27286 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27287 }
27288 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27289 {
27290 PyThreadState* __tstate = wxPyBeginAllowThreads();
27291 {
27292 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
27293 result = (wxDateTime *) &_result_ref;
27294 }
27295 wxPyEndAllowThreads(__tstate);
27296 if (PyErr_Occurred()) SWIG_fail;
27297 }
27298 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27299 return resultobj;
27300 fail:
27301 return NULL;
27302 }
27303
27304
27305 SWIGINTERN PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
27306 int argc;
27307 PyObject *argv[3];
27308
27309 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___iadd__",0,2,argv))) SWIG_fail;
27310 --argc;
27311 if (argc == 2) {
27312 int _v = 0;
27313 {
27314 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27315 _v = SWIG_CheckState(res);
27316 }
27317 if (!_v) goto check_1;
27318 return _wrap_DateTime___iadd____SWIG_0(self, argc, argv);
27319 }
27320 check_1:
27321
27322 if (argc == 2) {
27323 return _wrap_DateTime___iadd____SWIG_1(self, argc, argv);
27324 }
27325
27326 fail:
27327 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
27328 return NULL;
27329 }
27330
27331
27332 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27333 PyObject *resultobj = 0;
27334 wxDateTime *arg1 = (wxDateTime *) 0 ;
27335 wxTimeSpan *arg2 = 0 ;
27336 wxDateTime *result = 0 ;
27337 void *argp1 = 0 ;
27338 int res1 = 0 ;
27339 void *argp2 = 0 ;
27340 int res2 = 0 ;
27341
27342 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27343 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27344 if (!SWIG_IsOK(res1)) {
27345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27346 }
27347 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27348 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27349 if (!SWIG_IsOK(res2)) {
27350 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27351 }
27352 if (!argp2) {
27353 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27354 }
27355 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27356 {
27357 PyThreadState* __tstate = wxPyBeginAllowThreads();
27358 {
27359 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
27360 result = (wxDateTime *) &_result_ref;
27361 }
27362 wxPyEndAllowThreads(__tstate);
27363 if (PyErr_Occurred()) SWIG_fail;
27364 }
27365 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27366 return resultobj;
27367 fail:
27368 return NULL;
27369 }
27370
27371
27372 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27373 PyObject *resultobj = 0;
27374 wxDateTime *arg1 = (wxDateTime *) 0 ;
27375 wxDateSpan *arg2 = 0 ;
27376 wxDateTime *result = 0 ;
27377 void *argp1 = 0 ;
27378 int res1 = 0 ;
27379 void *argp2 = 0 ;
27380 int res2 = 0 ;
27381
27382 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27383 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27384 if (!SWIG_IsOK(res1)) {
27385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27386 }
27387 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27388 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27389 if (!SWIG_IsOK(res2)) {
27390 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27391 }
27392 if (!argp2) {
27393 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27394 }
27395 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27396 {
27397 PyThreadState* __tstate = wxPyBeginAllowThreads();
27398 {
27399 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
27400 result = (wxDateTime *) &_result_ref;
27401 }
27402 wxPyEndAllowThreads(__tstate);
27403 if (PyErr_Occurred()) SWIG_fail;
27404 }
27405 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27406 return resultobj;
27407 fail:
27408 return NULL;
27409 }
27410
27411
27412 SWIGINTERN PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
27413 int argc;
27414 PyObject *argv[3];
27415
27416 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___isub__",0,2,argv))) SWIG_fail;
27417 --argc;
27418 if (argc == 2) {
27419 int _v = 0;
27420 {
27421 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27422 _v = SWIG_CheckState(res);
27423 }
27424 if (!_v) goto check_1;
27425 return _wrap_DateTime___isub____SWIG_0(self, argc, argv);
27426 }
27427 check_1:
27428
27429 if (argc == 2) {
27430 return _wrap_DateTime___isub____SWIG_1(self, argc, argv);
27431 }
27432
27433 fail:
27434 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
27435 return NULL;
27436 }
27437
27438
27439 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27440 PyObject *resultobj = 0;
27441 wxDateTime *arg1 = (wxDateTime *) 0 ;
27442 wxTimeSpan *arg2 = 0 ;
27443 wxDateTime result;
27444 void *argp1 = 0 ;
27445 int res1 = 0 ;
27446 void *argp2 = 0 ;
27447 int res2 = 0 ;
27448
27449 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27451 if (!SWIG_IsOK(res1)) {
27452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27453 }
27454 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27455 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27456 if (!SWIG_IsOK(res2)) {
27457 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27458 }
27459 if (!argp2) {
27460 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27461 }
27462 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27463 {
27464 PyThreadState* __tstate = wxPyBeginAllowThreads();
27465 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
27466 wxPyEndAllowThreads(__tstate);
27467 if (PyErr_Occurred()) SWIG_fail;
27468 }
27469 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27470 return resultobj;
27471 fail:
27472 return NULL;
27473 }
27474
27475
27476 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27477 PyObject *resultobj = 0;
27478 wxDateTime *arg1 = (wxDateTime *) 0 ;
27479 wxDateSpan *arg2 = 0 ;
27480 wxDateTime result;
27481 void *argp1 = 0 ;
27482 int res1 = 0 ;
27483 void *argp2 = 0 ;
27484 int res2 = 0 ;
27485
27486 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27488 if (!SWIG_IsOK(res1)) {
27489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27490 }
27491 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27492 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27493 if (!SWIG_IsOK(res2)) {
27494 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27495 }
27496 if (!argp2) {
27497 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27498 }
27499 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27500 {
27501 PyThreadState* __tstate = wxPyBeginAllowThreads();
27502 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
27503 wxPyEndAllowThreads(__tstate);
27504 if (PyErr_Occurred()) SWIG_fail;
27505 }
27506 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27507 return resultobj;
27508 fail:
27509 return NULL;
27510 }
27511
27512
27513 SWIGINTERN PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
27514 int argc;
27515 PyObject *argv[3];
27516
27517 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___add__",0,2,argv))) SWIG_fail;
27518 --argc;
27519 if (argc == 2) {
27520 int _v = 0;
27521 {
27522 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27523 _v = SWIG_CheckState(res);
27524 }
27525 if (!_v) goto check_1;
27526 return _wrap_DateTime___add____SWIG_0(self, argc, argv);
27527 }
27528 check_1:
27529
27530 if (argc == 2) {
27531 return _wrap_DateTime___add____SWIG_1(self, argc, argv);
27532 }
27533
27534 fail:
27535 Py_INCREF(Py_NotImplemented);
27536 return Py_NotImplemented;
27537 }
27538
27539
27540 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27541 PyObject *resultobj = 0;
27542 wxDateTime *arg1 = (wxDateTime *) 0 ;
27543 wxDateTime *arg2 = 0 ;
27544 wxTimeSpan result;
27545 void *argp1 = 0 ;
27546 int res1 = 0 ;
27547 void *argp2 = 0 ;
27548 int res2 = 0 ;
27549
27550 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27552 if (!SWIG_IsOK(res1)) {
27553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27554 }
27555 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27556 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27557 if (!SWIG_IsOK(res2)) {
27558 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27559 }
27560 if (!argp2) {
27561 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27562 }
27563 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27564 {
27565 PyThreadState* __tstate = wxPyBeginAllowThreads();
27566 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
27567 wxPyEndAllowThreads(__tstate);
27568 if (PyErr_Occurred()) SWIG_fail;
27569 }
27570 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27571 return resultobj;
27572 fail:
27573 return NULL;
27574 }
27575
27576
27577 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27578 PyObject *resultobj = 0;
27579 wxDateTime *arg1 = (wxDateTime *) 0 ;
27580 wxTimeSpan *arg2 = 0 ;
27581 wxDateTime result;
27582 void *argp1 = 0 ;
27583 int res1 = 0 ;
27584 void *argp2 = 0 ;
27585 int res2 = 0 ;
27586
27587 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27588 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27589 if (!SWIG_IsOK(res1)) {
27590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27591 }
27592 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27593 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27594 if (!SWIG_IsOK(res2)) {
27595 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27596 }
27597 if (!argp2) {
27598 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27599 }
27600 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27601 {
27602 PyThreadState* __tstate = wxPyBeginAllowThreads();
27603 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
27604 wxPyEndAllowThreads(__tstate);
27605 if (PyErr_Occurred()) SWIG_fail;
27606 }
27607 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27608 return resultobj;
27609 fail:
27610 return NULL;
27611 }
27612
27613
27614 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27615 PyObject *resultobj = 0;
27616 wxDateTime *arg1 = (wxDateTime *) 0 ;
27617 wxDateSpan *arg2 = 0 ;
27618 wxDateTime result;
27619 void *argp1 = 0 ;
27620 int res1 = 0 ;
27621 void *argp2 = 0 ;
27622 int res2 = 0 ;
27623
27624 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27626 if (!SWIG_IsOK(res1)) {
27627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27628 }
27629 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27630 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27631 if (!SWIG_IsOK(res2)) {
27632 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27633 }
27634 if (!argp2) {
27635 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27636 }
27637 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27638 {
27639 PyThreadState* __tstate = wxPyBeginAllowThreads();
27640 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
27641 wxPyEndAllowThreads(__tstate);
27642 if (PyErr_Occurred()) SWIG_fail;
27643 }
27644 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27645 return resultobj;
27646 fail:
27647 return NULL;
27648 }
27649
27650
27651 SWIGINTERN PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
27652 int argc;
27653 PyObject *argv[3];
27654
27655 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___sub__",0,2,argv))) SWIG_fail;
27656 --argc;
27657 if (argc == 2) {
27658 int _v = 0;
27659 {
27660 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDateTime, 0);
27661 _v = SWIG_CheckState(res);
27662 }
27663 if (!_v) goto check_1;
27664 return _wrap_DateTime___sub____SWIG_0(self, argc, argv);
27665 }
27666 check_1:
27667
27668 if (argc == 2) {
27669 int _v = 0;
27670 {
27671 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27672 _v = SWIG_CheckState(res);
27673 }
27674 if (!_v) goto check_2;
27675 return _wrap_DateTime___sub____SWIG_1(self, argc, argv);
27676 }
27677 check_2:
27678
27679 if (argc == 2) {
27680 return _wrap_DateTime___sub____SWIG_2(self, argc, argv);
27681 }
27682
27683 fail:
27684 Py_INCREF(Py_NotImplemented);
27685 return Py_NotImplemented;
27686 }
27687
27688
27689 SWIGINTERN PyObject *_wrap_DateTime___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27690 PyObject *resultobj = 0;
27691 wxDateTime *arg1 = (wxDateTime *) 0 ;
27692 wxDateTime *arg2 = (wxDateTime *) 0 ;
27693 bool result;
27694 void *argp1 = 0 ;
27695 int res1 = 0 ;
27696 void *argp2 = 0 ;
27697 int res2 = 0 ;
27698 PyObject * obj0 = 0 ;
27699 PyObject * obj1 = 0 ;
27700 char * kwnames[] = {
27701 (char *) "self",(char *) "other", NULL
27702 };
27703
27704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
27705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27706 if (!SWIG_IsOK(res1)) {
27707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___lt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27708 }
27709 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27710 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27711 if (!SWIG_IsOK(res2)) {
27712 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___lt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
27713 }
27714 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27715 {
27716 PyThreadState* __tstate = wxPyBeginAllowThreads();
27717 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
27718 wxPyEndAllowThreads(__tstate);
27719 if (PyErr_Occurred()) SWIG_fail;
27720 }
27721 {
27722 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27723 }
27724 return resultobj;
27725 fail:
27726 return NULL;
27727 }
27728
27729
27730 SWIGINTERN PyObject *_wrap_DateTime___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27731 PyObject *resultobj = 0;
27732 wxDateTime *arg1 = (wxDateTime *) 0 ;
27733 wxDateTime *arg2 = (wxDateTime *) 0 ;
27734 bool result;
27735 void *argp1 = 0 ;
27736 int res1 = 0 ;
27737 void *argp2 = 0 ;
27738 int res2 = 0 ;
27739 PyObject * obj0 = 0 ;
27740 PyObject * obj1 = 0 ;
27741 char * kwnames[] = {
27742 (char *) "self",(char *) "other", NULL
27743 };
27744
27745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) SWIG_fail;
27746 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27747 if (!SWIG_IsOK(res1)) {
27748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___le__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27749 }
27750 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27751 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27752 if (!SWIG_IsOK(res2)) {
27753 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___le__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
27754 }
27755 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27756 {
27757 PyThreadState* __tstate = wxPyBeginAllowThreads();
27758 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
27759 wxPyEndAllowThreads(__tstate);
27760 if (PyErr_Occurred()) SWIG_fail;
27761 }
27762 {
27763 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27764 }
27765 return resultobj;
27766 fail:
27767 return NULL;
27768 }
27769
27770
27771 SWIGINTERN PyObject *_wrap_DateTime___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27772 PyObject *resultobj = 0;
27773 wxDateTime *arg1 = (wxDateTime *) 0 ;
27774 wxDateTime *arg2 = (wxDateTime *) 0 ;
27775 bool result;
27776 void *argp1 = 0 ;
27777 int res1 = 0 ;
27778 void *argp2 = 0 ;
27779 int res2 = 0 ;
27780 PyObject * obj0 = 0 ;
27781 PyObject * obj1 = 0 ;
27782 char * kwnames[] = {
27783 (char *) "self",(char *) "other", NULL
27784 };
27785
27786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
27787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27788 if (!SWIG_IsOK(res1)) {
27789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___gt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27790 }
27791 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27792 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27793 if (!SWIG_IsOK(res2)) {
27794 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___gt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
27795 }
27796 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27797 {
27798 PyThreadState* __tstate = wxPyBeginAllowThreads();
27799 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
27800 wxPyEndAllowThreads(__tstate);
27801 if (PyErr_Occurred()) SWIG_fail;
27802 }
27803 {
27804 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27805 }
27806 return resultobj;
27807 fail:
27808 return NULL;
27809 }
27810
27811
27812 SWIGINTERN PyObject *_wrap_DateTime___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27813 PyObject *resultobj = 0;
27814 wxDateTime *arg1 = (wxDateTime *) 0 ;
27815 wxDateTime *arg2 = (wxDateTime *) 0 ;
27816 bool result;
27817 void *argp1 = 0 ;
27818 int res1 = 0 ;
27819 void *argp2 = 0 ;
27820 int res2 = 0 ;
27821 PyObject * obj0 = 0 ;
27822 PyObject * obj1 = 0 ;
27823 char * kwnames[] = {
27824 (char *) "self",(char *) "other", NULL
27825 };
27826
27827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
27828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27829 if (!SWIG_IsOK(res1)) {
27830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ge__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27831 }
27832 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27833 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27834 if (!SWIG_IsOK(res2)) {
27835 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ge__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
27836 }
27837 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27838 {
27839 PyThreadState* __tstate = wxPyBeginAllowThreads();
27840 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
27841 wxPyEndAllowThreads(__tstate);
27842 if (PyErr_Occurred()) SWIG_fail;
27843 }
27844 {
27845 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27846 }
27847 return resultobj;
27848 fail:
27849 return NULL;
27850 }
27851
27852
27853 SWIGINTERN PyObject *_wrap_DateTime___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27854 PyObject *resultobj = 0;
27855 wxDateTime *arg1 = (wxDateTime *) 0 ;
27856 wxDateTime *arg2 = (wxDateTime *) 0 ;
27857 bool result;
27858 void *argp1 = 0 ;
27859 int res1 = 0 ;
27860 void *argp2 = 0 ;
27861 int res2 = 0 ;
27862 PyObject * obj0 = 0 ;
27863 PyObject * obj1 = 0 ;
27864 char * kwnames[] = {
27865 (char *) "self",(char *) "other", NULL
27866 };
27867
27868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
27869 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27870 if (!SWIG_IsOK(res1)) {
27871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___eq__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27872 }
27873 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27874 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27875 if (!SWIG_IsOK(res2)) {
27876 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___eq__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
27877 }
27878 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27879 {
27880 PyThreadState* __tstate = wxPyBeginAllowThreads();
27881 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
27882 wxPyEndAllowThreads(__tstate);
27883 if (PyErr_Occurred()) SWIG_fail;
27884 }
27885 {
27886 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27887 }
27888 return resultobj;
27889 fail:
27890 return NULL;
27891 }
27892
27893
27894 SWIGINTERN PyObject *_wrap_DateTime___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27895 PyObject *resultobj = 0;
27896 wxDateTime *arg1 = (wxDateTime *) 0 ;
27897 wxDateTime *arg2 = (wxDateTime *) 0 ;
27898 bool result;
27899 void *argp1 = 0 ;
27900 int res1 = 0 ;
27901 void *argp2 = 0 ;
27902 int res2 = 0 ;
27903 PyObject * obj0 = 0 ;
27904 PyObject * obj1 = 0 ;
27905 char * kwnames[] = {
27906 (char *) "self",(char *) "other", NULL
27907 };
27908
27909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
27910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27911 if (!SWIG_IsOK(res1)) {
27912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ne__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27913 }
27914 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27915 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27916 if (!SWIG_IsOK(res2)) {
27917 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ne__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
27918 }
27919 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27920 {
27921 PyThreadState* __tstate = wxPyBeginAllowThreads();
27922 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
27923 wxPyEndAllowThreads(__tstate);
27924 if (PyErr_Occurred()) SWIG_fail;
27925 }
27926 {
27927 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27928 }
27929 return resultobj;
27930 fail:
27931 return NULL;
27932 }
27933
27934
27935 SWIGINTERN PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27936 PyObject *resultobj = 0;
27937 wxDateTime *arg1 = (wxDateTime *) 0 ;
27938 wxString *arg2 = 0 ;
27939 int result;
27940 void *argp1 = 0 ;
27941 int res1 = 0 ;
27942 bool temp2 = false ;
27943 PyObject * obj0 = 0 ;
27944 PyObject * obj1 = 0 ;
27945 char * kwnames[] = {
27946 (char *) "self",(char *) "date", NULL
27947 };
27948
27949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) SWIG_fail;
27950 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27951 if (!SWIG_IsOK(res1)) {
27952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseRfc822Date" "', expected argument " "1"" of type '" "wxDateTime *""'");
27953 }
27954 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27955 {
27956 arg2 = wxString_in_helper(obj1);
27957 if (arg2 == NULL) SWIG_fail;
27958 temp2 = true;
27959 }
27960 {
27961 PyThreadState* __tstate = wxPyBeginAllowThreads();
27962 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
27963 wxPyEndAllowThreads(__tstate);
27964 if (PyErr_Occurred()) SWIG_fail;
27965 }
27966 resultobj = SWIG_From_int(static_cast< int >(result));
27967 {
27968 if (temp2)
27969 delete arg2;
27970 }
27971 return resultobj;
27972 fail:
27973 {
27974 if (temp2)
27975 delete arg2;
27976 }
27977 return NULL;
27978 }
27979
27980
27981 SWIGINTERN PyObject *_wrap_DateTime_ParseFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27982 PyObject *resultobj = 0;
27983 wxDateTime *arg1 = (wxDateTime *) 0 ;
27984 wxString *arg2 = 0 ;
27985 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
27986 wxString *arg3 = (wxString *) &arg3_defvalue ;
27987 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
27988 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
27989 int result;
27990 void *argp1 = 0 ;
27991 int res1 = 0 ;
27992 bool temp2 = false ;
27993 bool temp3 = false ;
27994 void *argp4 = 0 ;
27995 int res4 = 0 ;
27996 PyObject * obj0 = 0 ;
27997 PyObject * obj1 = 0 ;
27998 PyObject * obj2 = 0 ;
27999 PyObject * obj3 = 0 ;
28000 char * kwnames[] = {
28001 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
28002 };
28003
28004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28005 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28006 if (!SWIG_IsOK(res1)) {
28007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseFormat" "', expected argument " "1"" of type '" "wxDateTime *""'");
28008 }
28009 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28010 {
28011 arg2 = wxString_in_helper(obj1);
28012 if (arg2 == NULL) SWIG_fail;
28013 temp2 = true;
28014 }
28015 if (obj2) {
28016 {
28017 arg3 = wxString_in_helper(obj2);
28018 if (arg3 == NULL) SWIG_fail;
28019 temp3 = true;
28020 }
28021 }
28022 if (obj3) {
28023 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDateTime, 0 | 0);
28024 if (!SWIG_IsOK(res4)) {
28025 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
28026 }
28027 if (!argp4) {
28028 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
28029 }
28030 arg4 = reinterpret_cast< wxDateTime * >(argp4);
28031 }
28032 {
28033 PyThreadState* __tstate = wxPyBeginAllowThreads();
28034 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
28035 wxPyEndAllowThreads(__tstate);
28036 if (PyErr_Occurred()) SWIG_fail;
28037 }
28038 resultobj = SWIG_From_int(static_cast< int >(result));
28039 {
28040 if (temp2)
28041 delete arg2;
28042 }
28043 {
28044 if (temp3)
28045 delete arg3;
28046 }
28047 return resultobj;
28048 fail:
28049 {
28050 if (temp2)
28051 delete arg2;
28052 }
28053 {
28054 if (temp3)
28055 delete arg3;
28056 }
28057 return NULL;
28058 }
28059
28060
28061 SWIGINTERN PyObject *_wrap_DateTime_ParseDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28062 PyObject *resultobj = 0;
28063 wxDateTime *arg1 = (wxDateTime *) 0 ;
28064 wxString *arg2 = 0 ;
28065 int result;
28066 void *argp1 = 0 ;
28067 int res1 = 0 ;
28068 bool temp2 = false ;
28069 PyObject * obj0 = 0 ;
28070 PyObject * obj1 = 0 ;
28071 char * kwnames[] = {
28072 (char *) "self",(char *) "datetime", NULL
28073 };
28074
28075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) SWIG_fail;
28076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28077 if (!SWIG_IsOK(res1)) {
28078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
28079 }
28080 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28081 {
28082 arg2 = wxString_in_helper(obj1);
28083 if (arg2 == NULL) SWIG_fail;
28084 temp2 = true;
28085 }
28086 {
28087 PyThreadState* __tstate = wxPyBeginAllowThreads();
28088 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
28089 wxPyEndAllowThreads(__tstate);
28090 if (PyErr_Occurred()) SWIG_fail;
28091 }
28092 resultobj = SWIG_From_int(static_cast< int >(result));
28093 {
28094 if (temp2)
28095 delete arg2;
28096 }
28097 return resultobj;
28098 fail:
28099 {
28100 if (temp2)
28101 delete arg2;
28102 }
28103 return NULL;
28104 }
28105
28106
28107 SWIGINTERN PyObject *_wrap_DateTime_ParseDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28108 PyObject *resultobj = 0;
28109 wxDateTime *arg1 = (wxDateTime *) 0 ;
28110 wxString *arg2 = 0 ;
28111 int result;
28112 void *argp1 = 0 ;
28113 int res1 = 0 ;
28114 bool temp2 = false ;
28115 PyObject * obj0 = 0 ;
28116 PyObject * obj1 = 0 ;
28117 char * kwnames[] = {
28118 (char *) "self",(char *) "date", NULL
28119 };
28120
28121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) SWIG_fail;
28122 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28123 if (!SWIG_IsOK(res1)) {
28124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDate" "', expected argument " "1"" of type '" "wxDateTime *""'");
28125 }
28126 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28127 {
28128 arg2 = wxString_in_helper(obj1);
28129 if (arg2 == NULL) SWIG_fail;
28130 temp2 = true;
28131 }
28132 {
28133 PyThreadState* __tstate = wxPyBeginAllowThreads();
28134 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
28135 wxPyEndAllowThreads(__tstate);
28136 if (PyErr_Occurred()) SWIG_fail;
28137 }
28138 resultobj = SWIG_From_int(static_cast< int >(result));
28139 {
28140 if (temp2)
28141 delete arg2;
28142 }
28143 return resultobj;
28144 fail:
28145 {
28146 if (temp2)
28147 delete arg2;
28148 }
28149 return NULL;
28150 }
28151
28152
28153 SWIGINTERN PyObject *_wrap_DateTime_ParseTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28154 PyObject *resultobj = 0;
28155 wxDateTime *arg1 = (wxDateTime *) 0 ;
28156 wxString *arg2 = 0 ;
28157 int result;
28158 void *argp1 = 0 ;
28159 int res1 = 0 ;
28160 bool temp2 = false ;
28161 PyObject * obj0 = 0 ;
28162 PyObject * obj1 = 0 ;
28163 char * kwnames[] = {
28164 (char *) "self",(char *) "time", NULL
28165 };
28166
28167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) SWIG_fail;
28168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28169 if (!SWIG_IsOK(res1)) {
28170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
28171 }
28172 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28173 {
28174 arg2 = wxString_in_helper(obj1);
28175 if (arg2 == NULL) SWIG_fail;
28176 temp2 = true;
28177 }
28178 {
28179 PyThreadState* __tstate = wxPyBeginAllowThreads();
28180 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
28181 wxPyEndAllowThreads(__tstate);
28182 if (PyErr_Occurred()) SWIG_fail;
28183 }
28184 resultobj = SWIG_From_int(static_cast< int >(result));
28185 {
28186 if (temp2)
28187 delete arg2;
28188 }
28189 return resultobj;
28190 fail:
28191 {
28192 if (temp2)
28193 delete arg2;
28194 }
28195 return NULL;
28196 }
28197
28198
28199 SWIGINTERN PyObject *_wrap_DateTime_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28200 PyObject *resultobj = 0;
28201 wxDateTime *arg1 = (wxDateTime *) 0 ;
28202 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
28203 wxString *arg2 = (wxString *) &arg2_defvalue ;
28204 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
28205 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
28206 wxString result;
28207 void *argp1 = 0 ;
28208 int res1 = 0 ;
28209 bool temp2 = false ;
28210 bool temp3 = false ;
28211 PyObject * obj0 = 0 ;
28212 PyObject * obj1 = 0 ;
28213 PyObject * obj2 = 0 ;
28214 char * kwnames[] = {
28215 (char *) "self",(char *) "format",(char *) "tz", NULL
28216 };
28217
28218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28220 if (!SWIG_IsOK(res1)) {
28221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Format" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28222 }
28223 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28224 if (obj1) {
28225 {
28226 arg2 = wxString_in_helper(obj1);
28227 if (arg2 == NULL) SWIG_fail;
28228 temp2 = true;
28229 }
28230 }
28231 if (obj2) {
28232 {
28233 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
28234 temp3 = true;
28235 }
28236 }
28237 {
28238 PyThreadState* __tstate = wxPyBeginAllowThreads();
28239 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
28240 wxPyEndAllowThreads(__tstate);
28241 if (PyErr_Occurred()) SWIG_fail;
28242 }
28243 {
28244 #if wxUSE_UNICODE
28245 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28246 #else
28247 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28248 #endif
28249 }
28250 {
28251 if (temp2)
28252 delete arg2;
28253 }
28254 {
28255 if (temp3) delete arg3;
28256 }
28257 return resultobj;
28258 fail:
28259 {
28260 if (temp2)
28261 delete arg2;
28262 }
28263 {
28264 if (temp3) delete arg3;
28265 }
28266 return NULL;
28267 }
28268
28269
28270 SWIGINTERN PyObject *_wrap_DateTime_FormatDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28271 PyObject *resultobj = 0;
28272 wxDateTime *arg1 = (wxDateTime *) 0 ;
28273 wxString result;
28274 void *argp1 = 0 ;
28275 int res1 = 0 ;
28276 PyObject *swig_obj[1] ;
28277
28278 if (!args) SWIG_fail;
28279 swig_obj[0] = args;
28280 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28281 if (!SWIG_IsOK(res1)) {
28282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28283 }
28284 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28285 {
28286 PyThreadState* __tstate = wxPyBeginAllowThreads();
28287 result = ((wxDateTime const *)arg1)->FormatDate();
28288 wxPyEndAllowThreads(__tstate);
28289 if (PyErr_Occurred()) SWIG_fail;
28290 }
28291 {
28292 #if wxUSE_UNICODE
28293 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28294 #else
28295 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28296 #endif
28297 }
28298 return resultobj;
28299 fail:
28300 return NULL;
28301 }
28302
28303
28304 SWIGINTERN PyObject *_wrap_DateTime_FormatTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28305 PyObject *resultobj = 0;
28306 wxDateTime *arg1 = (wxDateTime *) 0 ;
28307 wxString result;
28308 void *argp1 = 0 ;
28309 int res1 = 0 ;
28310 PyObject *swig_obj[1] ;
28311
28312 if (!args) SWIG_fail;
28313 swig_obj[0] = args;
28314 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28315 if (!SWIG_IsOK(res1)) {
28316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28317 }
28318 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28319 {
28320 PyThreadState* __tstate = wxPyBeginAllowThreads();
28321 result = ((wxDateTime const *)arg1)->FormatTime();
28322 wxPyEndAllowThreads(__tstate);
28323 if (PyErr_Occurred()) SWIG_fail;
28324 }
28325 {
28326 #if wxUSE_UNICODE
28327 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28328 #else
28329 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28330 #endif
28331 }
28332 return resultobj;
28333 fail:
28334 return NULL;
28335 }
28336
28337
28338 SWIGINTERN PyObject *_wrap_DateTime_FormatISODate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28339 PyObject *resultobj = 0;
28340 wxDateTime *arg1 = (wxDateTime *) 0 ;
28341 wxString result;
28342 void *argp1 = 0 ;
28343 int res1 = 0 ;
28344 PyObject *swig_obj[1] ;
28345
28346 if (!args) SWIG_fail;
28347 swig_obj[0] = args;
28348 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28349 if (!SWIG_IsOK(res1)) {
28350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISODate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28351 }
28352 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28353 {
28354 PyThreadState* __tstate = wxPyBeginAllowThreads();
28355 result = ((wxDateTime const *)arg1)->FormatISODate();
28356 wxPyEndAllowThreads(__tstate);
28357 if (PyErr_Occurred()) SWIG_fail;
28358 }
28359 {
28360 #if wxUSE_UNICODE
28361 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28362 #else
28363 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28364 #endif
28365 }
28366 return resultobj;
28367 fail:
28368 return NULL;
28369 }
28370
28371
28372 SWIGINTERN PyObject *_wrap_DateTime_FormatISOTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28373 PyObject *resultobj = 0;
28374 wxDateTime *arg1 = (wxDateTime *) 0 ;
28375 wxString result;
28376 void *argp1 = 0 ;
28377 int res1 = 0 ;
28378 PyObject *swig_obj[1] ;
28379
28380 if (!args) SWIG_fail;
28381 swig_obj[0] = args;
28382 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28383 if (!SWIG_IsOK(res1)) {
28384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISOTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28385 }
28386 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28387 {
28388 PyThreadState* __tstate = wxPyBeginAllowThreads();
28389 result = ((wxDateTime const *)arg1)->FormatISOTime();
28390 wxPyEndAllowThreads(__tstate);
28391 if (PyErr_Occurred()) SWIG_fail;
28392 }
28393 {
28394 #if wxUSE_UNICODE
28395 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28396 #else
28397 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28398 #endif
28399 }
28400 return resultobj;
28401 fail:
28402 return NULL;
28403 }
28404
28405
28406 SWIGINTERN PyObject *DateTime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28407 PyObject *obj;
28408 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28409 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateTime, SWIG_NewClientData(obj));
28410 return SWIG_Py_Void();
28411 }
28412
28413 SWIGINTERN PyObject *DateTime_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28414 return SWIG_Python_InitShadowInstance(args);
28415 }
28416
28417 SWIGINTERN PyObject *_wrap_TimeSpan_Milliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28418 PyObject *resultobj = 0;
28419 long arg1 ;
28420 wxTimeSpan result;
28421 long val1 ;
28422 int ecode1 = 0 ;
28423 PyObject * obj0 = 0 ;
28424 char * kwnames[] = {
28425 (char *) "ms", NULL
28426 };
28427
28428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Milliseconds",kwnames,&obj0)) SWIG_fail;
28429 ecode1 = SWIG_AsVal_long(obj0, &val1);
28430 if (!SWIG_IsOK(ecode1)) {
28431 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Milliseconds" "', expected argument " "1"" of type '" "long""'");
28432 }
28433 arg1 = static_cast< long >(val1);
28434 {
28435 PyThreadState* __tstate = wxPyBeginAllowThreads();
28436 result = wxTimeSpan::Milliseconds(arg1);
28437 wxPyEndAllowThreads(__tstate);
28438 if (PyErr_Occurred()) SWIG_fail;
28439 }
28440 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28441 return resultobj;
28442 fail:
28443 return NULL;
28444 }
28445
28446
28447 SWIGINTERN PyObject *_wrap_TimeSpan_Millisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28448 PyObject *resultobj = 0;
28449 wxTimeSpan result;
28450
28451 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Millisecond",0,0,0)) SWIG_fail;
28452 {
28453 PyThreadState* __tstate = wxPyBeginAllowThreads();
28454 result = wxTimeSpan::Millisecond();
28455 wxPyEndAllowThreads(__tstate);
28456 if (PyErr_Occurred()) SWIG_fail;
28457 }
28458 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28459 return resultobj;
28460 fail:
28461 return NULL;
28462 }
28463
28464
28465 SWIGINTERN PyObject *_wrap_TimeSpan_Seconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28466 PyObject *resultobj = 0;
28467 long arg1 ;
28468 wxTimeSpan result;
28469 long val1 ;
28470 int ecode1 = 0 ;
28471 PyObject * obj0 = 0 ;
28472 char * kwnames[] = {
28473 (char *) "sec", NULL
28474 };
28475
28476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) SWIG_fail;
28477 ecode1 = SWIG_AsVal_long(obj0, &val1);
28478 if (!SWIG_IsOK(ecode1)) {
28479 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Seconds" "', expected argument " "1"" of type '" "long""'");
28480 }
28481 arg1 = static_cast< long >(val1);
28482 {
28483 PyThreadState* __tstate = wxPyBeginAllowThreads();
28484 result = wxTimeSpan::Seconds(arg1);
28485 wxPyEndAllowThreads(__tstate);
28486 if (PyErr_Occurred()) SWIG_fail;
28487 }
28488 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28489 return resultobj;
28490 fail:
28491 return NULL;
28492 }
28493
28494
28495 SWIGINTERN PyObject *_wrap_TimeSpan_Second(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28496 PyObject *resultobj = 0;
28497 wxTimeSpan result;
28498
28499 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Second",0,0,0)) SWIG_fail;
28500 {
28501 PyThreadState* __tstate = wxPyBeginAllowThreads();
28502 result = wxTimeSpan::Second();
28503 wxPyEndAllowThreads(__tstate);
28504 if (PyErr_Occurred()) SWIG_fail;
28505 }
28506 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28507 return resultobj;
28508 fail:
28509 return NULL;
28510 }
28511
28512
28513 SWIGINTERN PyObject *_wrap_TimeSpan_Minutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28514 PyObject *resultobj = 0;
28515 long arg1 ;
28516 wxTimeSpan result;
28517 long val1 ;
28518 int ecode1 = 0 ;
28519 PyObject * obj0 = 0 ;
28520 char * kwnames[] = {
28521 (char *) "min", NULL
28522 };
28523
28524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) SWIG_fail;
28525 ecode1 = SWIG_AsVal_long(obj0, &val1);
28526 if (!SWIG_IsOK(ecode1)) {
28527 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Minutes" "', expected argument " "1"" of type '" "long""'");
28528 }
28529 arg1 = static_cast< long >(val1);
28530 {
28531 PyThreadState* __tstate = wxPyBeginAllowThreads();
28532 result = wxTimeSpan::Minutes(arg1);
28533 wxPyEndAllowThreads(__tstate);
28534 if (PyErr_Occurred()) SWIG_fail;
28535 }
28536 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28537 return resultobj;
28538 fail:
28539 return NULL;
28540 }
28541
28542
28543 SWIGINTERN PyObject *_wrap_TimeSpan_Minute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28544 PyObject *resultobj = 0;
28545 wxTimeSpan result;
28546
28547 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Minute",0,0,0)) SWIG_fail;
28548 {
28549 PyThreadState* __tstate = wxPyBeginAllowThreads();
28550 result = wxTimeSpan::Minute();
28551 wxPyEndAllowThreads(__tstate);
28552 if (PyErr_Occurred()) SWIG_fail;
28553 }
28554 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28555 return resultobj;
28556 fail:
28557 return NULL;
28558 }
28559
28560
28561 SWIGINTERN PyObject *_wrap_TimeSpan_Hours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28562 PyObject *resultobj = 0;
28563 long arg1 ;
28564 wxTimeSpan result;
28565 long val1 ;
28566 int ecode1 = 0 ;
28567 PyObject * obj0 = 0 ;
28568 char * kwnames[] = {
28569 (char *) "hours", NULL
28570 };
28571
28572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) SWIG_fail;
28573 ecode1 = SWIG_AsVal_long(obj0, &val1);
28574 if (!SWIG_IsOK(ecode1)) {
28575 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Hours" "', expected argument " "1"" of type '" "long""'");
28576 }
28577 arg1 = static_cast< long >(val1);
28578 {
28579 PyThreadState* __tstate = wxPyBeginAllowThreads();
28580 result = wxTimeSpan::Hours(arg1);
28581 wxPyEndAllowThreads(__tstate);
28582 if (PyErr_Occurred()) SWIG_fail;
28583 }
28584 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28585 return resultobj;
28586 fail:
28587 return NULL;
28588 }
28589
28590
28591 SWIGINTERN PyObject *_wrap_TimeSpan_Hour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28592 PyObject *resultobj = 0;
28593 wxTimeSpan result;
28594
28595 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Hour",0,0,0)) SWIG_fail;
28596 {
28597 PyThreadState* __tstate = wxPyBeginAllowThreads();
28598 result = wxTimeSpan::Hour();
28599 wxPyEndAllowThreads(__tstate);
28600 if (PyErr_Occurred()) SWIG_fail;
28601 }
28602 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28603 return resultobj;
28604 fail:
28605 return NULL;
28606 }
28607
28608
28609 SWIGINTERN PyObject *_wrap_TimeSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28610 PyObject *resultobj = 0;
28611 long arg1 ;
28612 wxTimeSpan result;
28613 long val1 ;
28614 int ecode1 = 0 ;
28615 PyObject * obj0 = 0 ;
28616 char * kwnames[] = {
28617 (char *) "days", NULL
28618 };
28619
28620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) SWIG_fail;
28621 ecode1 = SWIG_AsVal_long(obj0, &val1);
28622 if (!SWIG_IsOK(ecode1)) {
28623 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Days" "', expected argument " "1"" of type '" "long""'");
28624 }
28625 arg1 = static_cast< long >(val1);
28626 {
28627 PyThreadState* __tstate = wxPyBeginAllowThreads();
28628 result = wxTimeSpan::Days(arg1);
28629 wxPyEndAllowThreads(__tstate);
28630 if (PyErr_Occurred()) SWIG_fail;
28631 }
28632 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28633 return resultobj;
28634 fail:
28635 return NULL;
28636 }
28637
28638
28639 SWIGINTERN PyObject *_wrap_TimeSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28640 PyObject *resultobj = 0;
28641 wxTimeSpan result;
28642
28643 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Day",0,0,0)) SWIG_fail;
28644 {
28645 PyThreadState* __tstate = wxPyBeginAllowThreads();
28646 result = wxTimeSpan::Day();
28647 wxPyEndAllowThreads(__tstate);
28648 if (PyErr_Occurred()) SWIG_fail;
28649 }
28650 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28651 return resultobj;
28652 fail:
28653 return NULL;
28654 }
28655
28656
28657 SWIGINTERN PyObject *_wrap_TimeSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28658 PyObject *resultobj = 0;
28659 long arg1 ;
28660 wxTimeSpan result;
28661 long val1 ;
28662 int ecode1 = 0 ;
28663 PyObject * obj0 = 0 ;
28664 char * kwnames[] = {
28665 (char *) "days", NULL
28666 };
28667
28668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) SWIG_fail;
28669 ecode1 = SWIG_AsVal_long(obj0, &val1);
28670 if (!SWIG_IsOK(ecode1)) {
28671 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Weeks" "', expected argument " "1"" of type '" "long""'");
28672 }
28673 arg1 = static_cast< long >(val1);
28674 {
28675 PyThreadState* __tstate = wxPyBeginAllowThreads();
28676 result = wxTimeSpan::Weeks(arg1);
28677 wxPyEndAllowThreads(__tstate);
28678 if (PyErr_Occurred()) SWIG_fail;
28679 }
28680 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28681 return resultobj;
28682 fail:
28683 return NULL;
28684 }
28685
28686
28687 SWIGINTERN PyObject *_wrap_TimeSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28688 PyObject *resultobj = 0;
28689 wxTimeSpan result;
28690
28691 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Week",0,0,0)) SWIG_fail;
28692 {
28693 PyThreadState* __tstate = wxPyBeginAllowThreads();
28694 result = wxTimeSpan::Week();
28695 wxPyEndAllowThreads(__tstate);
28696 if (PyErr_Occurred()) SWIG_fail;
28697 }
28698 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28699 return resultobj;
28700 fail:
28701 return NULL;
28702 }
28703
28704
28705 SWIGINTERN PyObject *_wrap_new_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28706 PyObject *resultobj = 0;
28707 long arg1 = (long) 0 ;
28708 long arg2 = (long) 0 ;
28709 long arg3 = (long) 0 ;
28710 long arg4 = (long) 0 ;
28711 wxTimeSpan *result = 0 ;
28712 long val1 ;
28713 int ecode1 = 0 ;
28714 long val2 ;
28715 int ecode2 = 0 ;
28716 long val3 ;
28717 int ecode3 = 0 ;
28718 long val4 ;
28719 int ecode4 = 0 ;
28720 PyObject * obj0 = 0 ;
28721 PyObject * obj1 = 0 ;
28722 PyObject * obj2 = 0 ;
28723 PyObject * obj3 = 0 ;
28724 char * kwnames[] = {
28725 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
28726 };
28727
28728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28729 if (obj0) {
28730 ecode1 = SWIG_AsVal_long(obj0, &val1);
28731 if (!SWIG_IsOK(ecode1)) {
28732 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimeSpan" "', expected argument " "1"" of type '" "long""'");
28733 }
28734 arg1 = static_cast< long >(val1);
28735 }
28736 if (obj1) {
28737 ecode2 = SWIG_AsVal_long(obj1, &val2);
28738 if (!SWIG_IsOK(ecode2)) {
28739 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimeSpan" "', expected argument " "2"" of type '" "long""'");
28740 }
28741 arg2 = static_cast< long >(val2);
28742 }
28743 if (obj2) {
28744 ecode3 = SWIG_AsVal_long(obj2, &val3);
28745 if (!SWIG_IsOK(ecode3)) {
28746 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimeSpan" "', expected argument " "3"" of type '" "long""'");
28747 }
28748 arg3 = static_cast< long >(val3);
28749 }
28750 if (obj3) {
28751 ecode4 = SWIG_AsVal_long(obj3, &val4);
28752 if (!SWIG_IsOK(ecode4)) {
28753 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TimeSpan" "', expected argument " "4"" of type '" "long""'");
28754 }
28755 arg4 = static_cast< long >(val4);
28756 }
28757 {
28758 PyThreadState* __tstate = wxPyBeginAllowThreads();
28759 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
28760 wxPyEndAllowThreads(__tstate);
28761 if (PyErr_Occurred()) SWIG_fail;
28762 }
28763 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_NEW | 0 );
28764 return resultobj;
28765 fail:
28766 return NULL;
28767 }
28768
28769
28770 SWIGINTERN PyObject *_wrap_delete_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28771 PyObject *resultobj = 0;
28772 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28773 void *argp1 = 0 ;
28774 int res1 = 0 ;
28775 PyObject *swig_obj[1] ;
28776
28777 if (!args) SWIG_fail;
28778 swig_obj[0] = args;
28779 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
28780 if (!SWIG_IsOK(res1)) {
28781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimeSpan" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28782 }
28783 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28784 {
28785 PyThreadState* __tstate = wxPyBeginAllowThreads();
28786 delete arg1;
28787
28788 wxPyEndAllowThreads(__tstate);
28789 if (PyErr_Occurred()) SWIG_fail;
28790 }
28791 resultobj = SWIG_Py_Void();
28792 return resultobj;
28793 fail:
28794 return NULL;
28795 }
28796
28797
28798 SWIGINTERN PyObject *_wrap_TimeSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28799 PyObject *resultobj = 0;
28800 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28801 wxTimeSpan *arg2 = 0 ;
28802 wxTimeSpan *result = 0 ;
28803 void *argp1 = 0 ;
28804 int res1 = 0 ;
28805 void *argp2 = 0 ;
28806 int res2 = 0 ;
28807 PyObject * obj0 = 0 ;
28808 PyObject * obj1 = 0 ;
28809 char * kwnames[] = {
28810 (char *) "self",(char *) "diff", NULL
28811 };
28812
28813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
28814 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28815 if (!SWIG_IsOK(res1)) {
28816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Add" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28817 }
28818 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28819 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28820 if (!SWIG_IsOK(res2)) {
28821 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28822 }
28823 if (!argp2) {
28824 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28825 }
28826 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28827 {
28828 PyThreadState* __tstate = wxPyBeginAllowThreads();
28829 {
28830 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
28831 result = (wxTimeSpan *) &_result_ref;
28832 }
28833 wxPyEndAllowThreads(__tstate);
28834 if (PyErr_Occurred()) SWIG_fail;
28835 }
28836 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28837 return resultobj;
28838 fail:
28839 return NULL;
28840 }
28841
28842
28843 SWIGINTERN PyObject *_wrap_TimeSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28844 PyObject *resultobj = 0;
28845 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28846 wxTimeSpan *arg2 = 0 ;
28847 wxTimeSpan *result = 0 ;
28848 void *argp1 = 0 ;
28849 int res1 = 0 ;
28850 void *argp2 = 0 ;
28851 int res2 = 0 ;
28852 PyObject * obj0 = 0 ;
28853 PyObject * obj1 = 0 ;
28854 char * kwnames[] = {
28855 (char *) "self",(char *) "diff", NULL
28856 };
28857
28858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
28859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28860 if (!SWIG_IsOK(res1)) {
28861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Subtract" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28862 }
28863 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28864 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28865 if (!SWIG_IsOK(res2)) {
28866 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28867 }
28868 if (!argp2) {
28869 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28870 }
28871 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28872 {
28873 PyThreadState* __tstate = wxPyBeginAllowThreads();
28874 {
28875 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
28876 result = (wxTimeSpan *) &_result_ref;
28877 }
28878 wxPyEndAllowThreads(__tstate);
28879 if (PyErr_Occurred()) SWIG_fail;
28880 }
28881 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28882 return resultobj;
28883 fail:
28884 return NULL;
28885 }
28886
28887
28888 SWIGINTERN PyObject *_wrap_TimeSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28889 PyObject *resultobj = 0;
28890 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28891 int arg2 ;
28892 wxTimeSpan *result = 0 ;
28893 void *argp1 = 0 ;
28894 int res1 = 0 ;
28895 int val2 ;
28896 int ecode2 = 0 ;
28897 PyObject * obj0 = 0 ;
28898 PyObject * obj1 = 0 ;
28899 char * kwnames[] = {
28900 (char *) "self",(char *) "n", NULL
28901 };
28902
28903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
28904 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28905 if (!SWIG_IsOK(res1)) {
28906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Multiply" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28907 }
28908 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28909 ecode2 = SWIG_AsVal_int(obj1, &val2);
28910 if (!SWIG_IsOK(ecode2)) {
28911 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
28912 }
28913 arg2 = static_cast< int >(val2);
28914 {
28915 PyThreadState* __tstate = wxPyBeginAllowThreads();
28916 {
28917 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
28918 result = (wxTimeSpan *) &_result_ref;
28919 }
28920 wxPyEndAllowThreads(__tstate);
28921 if (PyErr_Occurred()) SWIG_fail;
28922 }
28923 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28924 return resultobj;
28925 fail:
28926 return NULL;
28927 }
28928
28929
28930 SWIGINTERN PyObject *_wrap_TimeSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28931 PyObject *resultobj = 0;
28932 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28933 wxTimeSpan *result = 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_wxTimeSpan, 0 | 0 );
28941 if (!SWIG_IsOK(res1)) {
28942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Neg" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28943 }
28944 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28945 {
28946 PyThreadState* __tstate = wxPyBeginAllowThreads();
28947 {
28948 wxTimeSpan &_result_ref = (arg1)->Neg();
28949 result = (wxTimeSpan *) &_result_ref;
28950 }
28951 wxPyEndAllowThreads(__tstate);
28952 if (PyErr_Occurred()) SWIG_fail;
28953 }
28954 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28955 return resultobj;
28956 fail:
28957 return NULL;
28958 }
28959
28960
28961 SWIGINTERN PyObject *_wrap_TimeSpan_Abs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28962 PyObject *resultobj = 0;
28963 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28964 wxTimeSpan result;
28965 void *argp1 = 0 ;
28966 int res1 = 0 ;
28967 PyObject *swig_obj[1] ;
28968
28969 if (!args) SWIG_fail;
28970 swig_obj[0] = args;
28971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28972 if (!SWIG_IsOK(res1)) {
28973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Abs" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28974 }
28975 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28976 {
28977 PyThreadState* __tstate = wxPyBeginAllowThreads();
28978 result = ((wxTimeSpan const *)arg1)->Abs();
28979 wxPyEndAllowThreads(__tstate);
28980 if (PyErr_Occurred()) SWIG_fail;
28981 }
28982 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28983 return resultobj;
28984 fail:
28985 return NULL;
28986 }
28987
28988
28989 SWIGINTERN PyObject *_wrap_TimeSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28990 PyObject *resultobj = 0;
28991 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28992 wxTimeSpan *arg2 = 0 ;
28993 wxTimeSpan *result = 0 ;
28994 void *argp1 = 0 ;
28995 int res1 = 0 ;
28996 void *argp2 = 0 ;
28997 int res2 = 0 ;
28998 PyObject * obj0 = 0 ;
28999 PyObject * obj1 = 0 ;
29000 char * kwnames[] = {
29001 (char *) "self",(char *) "diff", NULL
29002 };
29003
29004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
29005 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29006 if (!SWIG_IsOK(res1)) {
29007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___iadd__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29008 }
29009 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29010 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29011 if (!SWIG_IsOK(res2)) {
29012 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29013 }
29014 if (!argp2) {
29015 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29016 }
29017 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29018 {
29019 PyThreadState* __tstate = wxPyBeginAllowThreads();
29020 {
29021 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
29022 result = (wxTimeSpan *) &_result_ref;
29023 }
29024 wxPyEndAllowThreads(__tstate);
29025 if (PyErr_Occurred()) SWIG_fail;
29026 }
29027 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29028 return resultobj;
29029 fail:
29030 return NULL;
29031 }
29032
29033
29034 SWIGINTERN PyObject *_wrap_TimeSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29035 PyObject *resultobj = 0;
29036 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29037 wxTimeSpan *arg2 = 0 ;
29038 wxTimeSpan *result = 0 ;
29039 void *argp1 = 0 ;
29040 int res1 = 0 ;
29041 void *argp2 = 0 ;
29042 int res2 = 0 ;
29043 PyObject * obj0 = 0 ;
29044 PyObject * obj1 = 0 ;
29045 char * kwnames[] = {
29046 (char *) "self",(char *) "diff", NULL
29047 };
29048
29049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
29050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29051 if (!SWIG_IsOK(res1)) {
29052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___isub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29053 }
29054 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29055 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29056 if (!SWIG_IsOK(res2)) {
29057 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29058 }
29059 if (!argp2) {
29060 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29061 }
29062 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29063 {
29064 PyThreadState* __tstate = wxPyBeginAllowThreads();
29065 {
29066 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
29067 result = (wxTimeSpan *) &_result_ref;
29068 }
29069 wxPyEndAllowThreads(__tstate);
29070 if (PyErr_Occurred()) SWIG_fail;
29071 }
29072 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29073 return resultobj;
29074 fail:
29075 return NULL;
29076 }
29077
29078
29079 SWIGINTERN PyObject *_wrap_TimeSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29080 PyObject *resultobj = 0;
29081 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29082 int arg2 ;
29083 wxTimeSpan *result = 0 ;
29084 void *argp1 = 0 ;
29085 int res1 = 0 ;
29086 int val2 ;
29087 int ecode2 = 0 ;
29088 PyObject * obj0 = 0 ;
29089 PyObject * obj1 = 0 ;
29090 char * kwnames[] = {
29091 (char *) "self",(char *) "n", NULL
29092 };
29093
29094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
29095 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29096 if (!SWIG_IsOK(res1)) {
29097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___imul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29098 }
29099 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29100 ecode2 = SWIG_AsVal_int(obj1, &val2);
29101 if (!SWIG_IsOK(ecode2)) {
29102 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___imul__" "', expected argument " "2"" of type '" "int""'");
29103 }
29104 arg2 = static_cast< int >(val2);
29105 {
29106 PyThreadState* __tstate = wxPyBeginAllowThreads();
29107 {
29108 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
29109 result = (wxTimeSpan *) &_result_ref;
29110 }
29111 wxPyEndAllowThreads(__tstate);
29112 if (PyErr_Occurred()) SWIG_fail;
29113 }
29114 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29115 return resultobj;
29116 fail:
29117 return NULL;
29118 }
29119
29120
29121 SWIGINTERN PyObject *_wrap_TimeSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29122 PyObject *resultobj = 0;
29123 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29124 wxTimeSpan *result = 0 ;
29125 void *argp1 = 0 ;
29126 int res1 = 0 ;
29127 PyObject *swig_obj[1] ;
29128
29129 if (!args) SWIG_fail;
29130 swig_obj[0] = args;
29131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29132 if (!SWIG_IsOK(res1)) {
29133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___neg__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29134 }
29135 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29136 {
29137 PyThreadState* __tstate = wxPyBeginAllowThreads();
29138 {
29139 wxTimeSpan &_result_ref = (arg1)->operator -();
29140 result = (wxTimeSpan *) &_result_ref;
29141 }
29142 wxPyEndAllowThreads(__tstate);
29143 if (PyErr_Occurred()) SWIG_fail;
29144 }
29145 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29146 return resultobj;
29147 fail:
29148 return NULL;
29149 }
29150
29151
29152 SWIGINTERN PyObject *_wrap_TimeSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29153 PyObject *resultobj = 0;
29154 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29155 wxTimeSpan *arg2 = 0 ;
29156 wxTimeSpan result;
29157 void *argp1 = 0 ;
29158 int res1 = 0 ;
29159 void *argp2 = 0 ;
29160 int res2 = 0 ;
29161 PyObject * obj0 = 0 ;
29162 PyObject * obj1 = 0 ;
29163 char * kwnames[] = {
29164 (char *) "self",(char *) "other", NULL
29165 };
29166
29167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
29168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29169 if (!SWIG_IsOK(res1)) {
29170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___add__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29171 }
29172 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29173 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29174 if (!SWIG_IsOK(res2)) {
29175 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29176 }
29177 if (!argp2) {
29178 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29179 }
29180 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29181 {
29182 PyThreadState* __tstate = wxPyBeginAllowThreads();
29183 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
29184 wxPyEndAllowThreads(__tstate);
29185 if (PyErr_Occurred()) SWIG_fail;
29186 }
29187 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29188 return resultobj;
29189 fail:
29190 return NULL;
29191 }
29192
29193
29194 SWIGINTERN PyObject *_wrap_TimeSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29195 PyObject *resultobj = 0;
29196 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29197 wxTimeSpan *arg2 = 0 ;
29198 wxTimeSpan result;
29199 void *argp1 = 0 ;
29200 int res1 = 0 ;
29201 void *argp2 = 0 ;
29202 int res2 = 0 ;
29203 PyObject * obj0 = 0 ;
29204 PyObject * obj1 = 0 ;
29205 char * kwnames[] = {
29206 (char *) "self",(char *) "other", NULL
29207 };
29208
29209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
29210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29211 if (!SWIG_IsOK(res1)) {
29212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___sub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29213 }
29214 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29215 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29216 if (!SWIG_IsOK(res2)) {
29217 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29218 }
29219 if (!argp2) {
29220 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29221 }
29222 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29223 {
29224 PyThreadState* __tstate = wxPyBeginAllowThreads();
29225 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
29226 wxPyEndAllowThreads(__tstate);
29227 if (PyErr_Occurred()) SWIG_fail;
29228 }
29229 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29230 return resultobj;
29231 fail:
29232 return NULL;
29233 }
29234
29235
29236 SWIGINTERN PyObject *_wrap_TimeSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29237 PyObject *resultobj = 0;
29238 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29239 int arg2 ;
29240 wxTimeSpan result;
29241 void *argp1 = 0 ;
29242 int res1 = 0 ;
29243 int val2 ;
29244 int ecode2 = 0 ;
29245 PyObject * obj0 = 0 ;
29246 PyObject * obj1 = 0 ;
29247 char * kwnames[] = {
29248 (char *) "self",(char *) "n", NULL
29249 };
29250
29251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
29252 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29253 if (!SWIG_IsOK(res1)) {
29254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___mul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29255 }
29256 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29257 ecode2 = SWIG_AsVal_int(obj1, &val2);
29258 if (!SWIG_IsOK(ecode2)) {
29259 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___mul__" "', expected argument " "2"" of type '" "int""'");
29260 }
29261 arg2 = static_cast< int >(val2);
29262 {
29263 PyThreadState* __tstate = wxPyBeginAllowThreads();
29264 result = wxTimeSpan___mul__(arg1,arg2);
29265 wxPyEndAllowThreads(__tstate);
29266 if (PyErr_Occurred()) SWIG_fail;
29267 }
29268 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29269 return resultobj;
29270 fail:
29271 return NULL;
29272 }
29273
29274
29275 SWIGINTERN PyObject *_wrap_TimeSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29276 PyObject *resultobj = 0;
29277 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29278 int arg2 ;
29279 wxTimeSpan result;
29280 void *argp1 = 0 ;
29281 int res1 = 0 ;
29282 int val2 ;
29283 int ecode2 = 0 ;
29284 PyObject * obj0 = 0 ;
29285 PyObject * obj1 = 0 ;
29286 char * kwnames[] = {
29287 (char *) "self",(char *) "n", NULL
29288 };
29289
29290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
29291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29292 if (!SWIG_IsOK(res1)) {
29293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___rmul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29294 }
29295 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29296 ecode2 = SWIG_AsVal_int(obj1, &val2);
29297 if (!SWIG_IsOK(ecode2)) {
29298 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
29299 }
29300 arg2 = static_cast< int >(val2);
29301 {
29302 PyThreadState* __tstate = wxPyBeginAllowThreads();
29303 result = wxTimeSpan___rmul__(arg1,arg2);
29304 wxPyEndAllowThreads(__tstate);
29305 if (PyErr_Occurred()) SWIG_fail;
29306 }
29307 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29308 return resultobj;
29309 fail:
29310 return NULL;
29311 }
29312
29313
29314 SWIGINTERN PyObject *_wrap_TimeSpan___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29315 PyObject *resultobj = 0;
29316 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29317 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29318 bool result;
29319 void *argp1 = 0 ;
29320 int res1 = 0 ;
29321 void *argp2 = 0 ;
29322 int res2 = 0 ;
29323 PyObject * obj0 = 0 ;
29324 PyObject * obj1 = 0 ;
29325 char * kwnames[] = {
29326 (char *) "self",(char *) "other", NULL
29327 };
29328
29329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
29330 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29331 if (!SWIG_IsOK(res1)) {
29332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___lt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29333 }
29334 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29335 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29336 if (!SWIG_IsOK(res2)) {
29337 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___lt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29338 }
29339 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29340 {
29341 PyThreadState* __tstate = wxPyBeginAllowThreads();
29342 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
29343 wxPyEndAllowThreads(__tstate);
29344 if (PyErr_Occurred()) SWIG_fail;
29345 }
29346 {
29347 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29348 }
29349 return resultobj;
29350 fail:
29351 return NULL;
29352 }
29353
29354
29355 SWIGINTERN PyObject *_wrap_TimeSpan___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29356 PyObject *resultobj = 0;
29357 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29358 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29359 bool result;
29360 void *argp1 = 0 ;
29361 int res1 = 0 ;
29362 void *argp2 = 0 ;
29363 int res2 = 0 ;
29364 PyObject * obj0 = 0 ;
29365 PyObject * obj1 = 0 ;
29366 char * kwnames[] = {
29367 (char *) "self",(char *) "other", NULL
29368 };
29369
29370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) SWIG_fail;
29371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29372 if (!SWIG_IsOK(res1)) {
29373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___le__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29374 }
29375 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29376 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29377 if (!SWIG_IsOK(res2)) {
29378 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___le__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29379 }
29380 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29381 {
29382 PyThreadState* __tstate = wxPyBeginAllowThreads();
29383 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
29384 wxPyEndAllowThreads(__tstate);
29385 if (PyErr_Occurred()) SWIG_fail;
29386 }
29387 {
29388 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29389 }
29390 return resultobj;
29391 fail:
29392 return NULL;
29393 }
29394
29395
29396 SWIGINTERN PyObject *_wrap_TimeSpan___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29397 PyObject *resultobj = 0;
29398 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29399 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29400 bool result;
29401 void *argp1 = 0 ;
29402 int res1 = 0 ;
29403 void *argp2 = 0 ;
29404 int res2 = 0 ;
29405 PyObject * obj0 = 0 ;
29406 PyObject * obj1 = 0 ;
29407 char * kwnames[] = {
29408 (char *) "self",(char *) "other", NULL
29409 };
29410
29411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
29412 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29413 if (!SWIG_IsOK(res1)) {
29414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___gt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29415 }
29416 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29417 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29418 if (!SWIG_IsOK(res2)) {
29419 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___gt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29420 }
29421 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29422 {
29423 PyThreadState* __tstate = wxPyBeginAllowThreads();
29424 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
29425 wxPyEndAllowThreads(__tstate);
29426 if (PyErr_Occurred()) SWIG_fail;
29427 }
29428 {
29429 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29430 }
29431 return resultobj;
29432 fail:
29433 return NULL;
29434 }
29435
29436
29437 SWIGINTERN PyObject *_wrap_TimeSpan___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29438 PyObject *resultobj = 0;
29439 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29440 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29441 bool result;
29442 void *argp1 = 0 ;
29443 int res1 = 0 ;
29444 void *argp2 = 0 ;
29445 int res2 = 0 ;
29446 PyObject * obj0 = 0 ;
29447 PyObject * obj1 = 0 ;
29448 char * kwnames[] = {
29449 (char *) "self",(char *) "other", NULL
29450 };
29451
29452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
29453 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29454 if (!SWIG_IsOK(res1)) {
29455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ge__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29456 }
29457 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29458 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29459 if (!SWIG_IsOK(res2)) {
29460 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ge__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29461 }
29462 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29463 {
29464 PyThreadState* __tstate = wxPyBeginAllowThreads();
29465 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
29466 wxPyEndAllowThreads(__tstate);
29467 if (PyErr_Occurred()) SWIG_fail;
29468 }
29469 {
29470 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29471 }
29472 return resultobj;
29473 fail:
29474 return NULL;
29475 }
29476
29477
29478 SWIGINTERN PyObject *_wrap_TimeSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29479 PyObject *resultobj = 0;
29480 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29481 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29482 bool result;
29483 void *argp1 = 0 ;
29484 int res1 = 0 ;
29485 void *argp2 = 0 ;
29486 int res2 = 0 ;
29487 PyObject * obj0 = 0 ;
29488 PyObject * obj1 = 0 ;
29489 char * kwnames[] = {
29490 (char *) "self",(char *) "other", NULL
29491 };
29492
29493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
29494 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29495 if (!SWIG_IsOK(res1)) {
29496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___eq__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29497 }
29498 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29499 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29500 if (!SWIG_IsOK(res2)) {
29501 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___eq__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29502 }
29503 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29504 {
29505 PyThreadState* __tstate = wxPyBeginAllowThreads();
29506 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
29507 wxPyEndAllowThreads(__tstate);
29508 if (PyErr_Occurred()) SWIG_fail;
29509 }
29510 {
29511 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29512 }
29513 return resultobj;
29514 fail:
29515 return NULL;
29516 }
29517
29518
29519 SWIGINTERN PyObject *_wrap_TimeSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29520 PyObject *resultobj = 0;
29521 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29522 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29523 bool result;
29524 void *argp1 = 0 ;
29525 int res1 = 0 ;
29526 void *argp2 = 0 ;
29527 int res2 = 0 ;
29528 PyObject * obj0 = 0 ;
29529 PyObject * obj1 = 0 ;
29530 char * kwnames[] = {
29531 (char *) "self",(char *) "other", NULL
29532 };
29533
29534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
29535 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29536 if (!SWIG_IsOK(res1)) {
29537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ne__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29538 }
29539 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29540 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29541 if (!SWIG_IsOK(res2)) {
29542 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ne__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29543 }
29544 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29545 {
29546 PyThreadState* __tstate = wxPyBeginAllowThreads();
29547 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
29548 wxPyEndAllowThreads(__tstate);
29549 if (PyErr_Occurred()) SWIG_fail;
29550 }
29551 {
29552 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29553 }
29554 return resultobj;
29555 fail:
29556 return NULL;
29557 }
29558
29559
29560 SWIGINTERN PyObject *_wrap_TimeSpan_IsNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29561 PyObject *resultobj = 0;
29562 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29563 bool result;
29564 void *argp1 = 0 ;
29565 int res1 = 0 ;
29566 PyObject *swig_obj[1] ;
29567
29568 if (!args) SWIG_fail;
29569 swig_obj[0] = args;
29570 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29571 if (!SWIG_IsOK(res1)) {
29572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNull" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29573 }
29574 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29575 {
29576 PyThreadState* __tstate = wxPyBeginAllowThreads();
29577 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
29578 wxPyEndAllowThreads(__tstate);
29579 if (PyErr_Occurred()) SWIG_fail;
29580 }
29581 {
29582 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29583 }
29584 return resultobj;
29585 fail:
29586 return NULL;
29587 }
29588
29589
29590 SWIGINTERN PyObject *_wrap_TimeSpan_IsPositive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29591 PyObject *resultobj = 0;
29592 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29593 bool result;
29594 void *argp1 = 0 ;
29595 int res1 = 0 ;
29596 PyObject *swig_obj[1] ;
29597
29598 if (!args) SWIG_fail;
29599 swig_obj[0] = args;
29600 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29601 if (!SWIG_IsOK(res1)) {
29602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsPositive" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29603 }
29604 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29605 {
29606 PyThreadState* __tstate = wxPyBeginAllowThreads();
29607 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
29608 wxPyEndAllowThreads(__tstate);
29609 if (PyErr_Occurred()) SWIG_fail;
29610 }
29611 {
29612 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29613 }
29614 return resultobj;
29615 fail:
29616 return NULL;
29617 }
29618
29619
29620 SWIGINTERN PyObject *_wrap_TimeSpan_IsNegative(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29621 PyObject *resultobj = 0;
29622 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29623 bool result;
29624 void *argp1 = 0 ;
29625 int res1 = 0 ;
29626 PyObject *swig_obj[1] ;
29627
29628 if (!args) SWIG_fail;
29629 swig_obj[0] = args;
29630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29631 if (!SWIG_IsOK(res1)) {
29632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNegative" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29633 }
29634 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29635 {
29636 PyThreadState* __tstate = wxPyBeginAllowThreads();
29637 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
29638 wxPyEndAllowThreads(__tstate);
29639 if (PyErr_Occurred()) SWIG_fail;
29640 }
29641 {
29642 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29643 }
29644 return resultobj;
29645 fail:
29646 return NULL;
29647 }
29648
29649
29650 SWIGINTERN PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29651 PyObject *resultobj = 0;
29652 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29653 wxTimeSpan *arg2 = 0 ;
29654 bool result;
29655 void *argp1 = 0 ;
29656 int res1 = 0 ;
29657 void *argp2 = 0 ;
29658 int res2 = 0 ;
29659 PyObject * obj0 = 0 ;
29660 PyObject * obj1 = 0 ;
29661 char * kwnames[] = {
29662 (char *) "self",(char *) "ts", NULL
29663 };
29664
29665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
29666 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29667 if (!SWIG_IsOK(res1)) {
29668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29669 }
29670 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29671 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29672 if (!SWIG_IsOK(res2)) {
29673 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29674 }
29675 if (!argp2) {
29676 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29677 }
29678 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29679 {
29680 PyThreadState* __tstate = wxPyBeginAllowThreads();
29681 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
29682 wxPyEndAllowThreads(__tstate);
29683 if (PyErr_Occurred()) SWIG_fail;
29684 }
29685 {
29686 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29687 }
29688 return resultobj;
29689 fail:
29690 return NULL;
29691 }
29692
29693
29694 SWIGINTERN PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29695 PyObject *resultobj = 0;
29696 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29697 wxTimeSpan *arg2 = 0 ;
29698 bool result;
29699 void *argp1 = 0 ;
29700 int res1 = 0 ;
29701 void *argp2 = 0 ;
29702 int res2 = 0 ;
29703 PyObject * obj0 = 0 ;
29704 PyObject * obj1 = 0 ;
29705 char * kwnames[] = {
29706 (char *) "self",(char *) "ts", NULL
29707 };
29708
29709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) SWIG_fail;
29710 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29711 if (!SWIG_IsOK(res1)) {
29712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29713 }
29714 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29715 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29716 if (!SWIG_IsOK(res2)) {
29717 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29718 }
29719 if (!argp2) {
29720 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29721 }
29722 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29723 {
29724 PyThreadState* __tstate = wxPyBeginAllowThreads();
29725 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
29726 wxPyEndAllowThreads(__tstate);
29727 if (PyErr_Occurred()) SWIG_fail;
29728 }
29729 {
29730 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29731 }
29732 return resultobj;
29733 fail:
29734 return NULL;
29735 }
29736
29737
29738 SWIGINTERN PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29739 PyObject *resultobj = 0;
29740 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29741 wxTimeSpan *arg2 = 0 ;
29742 bool result;
29743 void *argp1 = 0 ;
29744 int res1 = 0 ;
29745 void *argp2 = 0 ;
29746 int res2 = 0 ;
29747 PyObject * obj0 = 0 ;
29748 PyObject * obj1 = 0 ;
29749 char * kwnames[] = {
29750 (char *) "self",(char *) "t", NULL
29751 };
29752
29753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) SWIG_fail;
29754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29755 if (!SWIG_IsOK(res1)) {
29756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29757 }
29758 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29759 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29760 if (!SWIG_IsOK(res2)) {
29761 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29762 }
29763 if (!argp2) {
29764 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29765 }
29766 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29767 {
29768 PyThreadState* __tstate = wxPyBeginAllowThreads();
29769 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
29770 wxPyEndAllowThreads(__tstate);
29771 if (PyErr_Occurred()) SWIG_fail;
29772 }
29773 {
29774 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29775 }
29776 return resultobj;
29777 fail:
29778 return NULL;
29779 }
29780
29781
29782 SWIGINTERN PyObject *_wrap_TimeSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29783 PyObject *resultobj = 0;
29784 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29785 int result;
29786 void *argp1 = 0 ;
29787 int res1 = 0 ;
29788 PyObject *swig_obj[1] ;
29789
29790 if (!args) SWIG_fail;
29791 swig_obj[0] = args;
29792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29793 if (!SWIG_IsOK(res1)) {
29794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetWeeks" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29795 }
29796 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29797 {
29798 PyThreadState* __tstate = wxPyBeginAllowThreads();
29799 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
29800 wxPyEndAllowThreads(__tstate);
29801 if (PyErr_Occurred()) SWIG_fail;
29802 }
29803 resultobj = SWIG_From_int(static_cast< int >(result));
29804 return resultobj;
29805 fail:
29806 return NULL;
29807 }
29808
29809
29810 SWIGINTERN PyObject *_wrap_TimeSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29811 PyObject *resultobj = 0;
29812 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29813 int result;
29814 void *argp1 = 0 ;
29815 int res1 = 0 ;
29816 PyObject *swig_obj[1] ;
29817
29818 if (!args) SWIG_fail;
29819 swig_obj[0] = args;
29820 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29821 if (!SWIG_IsOK(res1)) {
29822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetDays" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29823 }
29824 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29825 {
29826 PyThreadState* __tstate = wxPyBeginAllowThreads();
29827 result = (int)((wxTimeSpan const *)arg1)->GetDays();
29828 wxPyEndAllowThreads(__tstate);
29829 if (PyErr_Occurred()) SWIG_fail;
29830 }
29831 resultobj = SWIG_From_int(static_cast< int >(result));
29832 return resultobj;
29833 fail:
29834 return NULL;
29835 }
29836
29837
29838 SWIGINTERN PyObject *_wrap_TimeSpan_GetHours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29839 PyObject *resultobj = 0;
29840 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29841 int result;
29842 void *argp1 = 0 ;
29843 int res1 = 0 ;
29844 PyObject *swig_obj[1] ;
29845
29846 if (!args) SWIG_fail;
29847 swig_obj[0] = args;
29848 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29849 if (!SWIG_IsOK(res1)) {
29850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetHours" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29851 }
29852 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29853 {
29854 PyThreadState* __tstate = wxPyBeginAllowThreads();
29855 result = (int)((wxTimeSpan const *)arg1)->GetHours();
29856 wxPyEndAllowThreads(__tstate);
29857 if (PyErr_Occurred()) SWIG_fail;
29858 }
29859 resultobj = SWIG_From_int(static_cast< int >(result));
29860 return resultobj;
29861 fail:
29862 return NULL;
29863 }
29864
29865
29866 SWIGINTERN PyObject *_wrap_TimeSpan_GetMinutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29867 PyObject *resultobj = 0;
29868 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29869 int result;
29870 void *argp1 = 0 ;
29871 int res1 = 0 ;
29872 PyObject *swig_obj[1] ;
29873
29874 if (!args) SWIG_fail;
29875 swig_obj[0] = args;
29876 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29877 if (!SWIG_IsOK(res1)) {
29878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMinutes" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29879 }
29880 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29881 {
29882 PyThreadState* __tstate = wxPyBeginAllowThreads();
29883 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
29884 wxPyEndAllowThreads(__tstate);
29885 if (PyErr_Occurred()) SWIG_fail;
29886 }
29887 resultobj = SWIG_From_int(static_cast< int >(result));
29888 return resultobj;
29889 fail:
29890 return NULL;
29891 }
29892
29893
29894 SWIGINTERN PyObject *_wrap_TimeSpan_GetSeconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29895 PyObject *resultobj = 0;
29896 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29897 wxLongLong result;
29898 void *argp1 = 0 ;
29899 int res1 = 0 ;
29900 PyObject *swig_obj[1] ;
29901
29902 if (!args) SWIG_fail;
29903 swig_obj[0] = args;
29904 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29905 if (!SWIG_IsOK(res1)) {
29906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetSeconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29907 }
29908 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29909 {
29910 PyThreadState* __tstate = wxPyBeginAllowThreads();
29911 result = ((wxTimeSpan const *)arg1)->GetSeconds();
29912 wxPyEndAllowThreads(__tstate);
29913 if (PyErr_Occurred()) SWIG_fail;
29914 }
29915 {
29916 PyObject *hi, *lo, *shifter, *shifted;
29917 hi = PyLong_FromLong( (&result)->GetHi() );
29918 lo = PyLong_FromLong( (&result)->GetLo() );
29919 shifter = PyLong_FromLong(32);
29920 shifted = PyNumber_Lshift(hi, shifter);
29921 resultobj = PyNumber_Or(shifted, lo);
29922 Py_DECREF(hi);
29923 Py_DECREF(lo);
29924 Py_DECREF(shifter);
29925 Py_DECREF(shifted);
29926 }
29927 return resultobj;
29928 fail:
29929 return NULL;
29930 }
29931
29932
29933 SWIGINTERN PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29934 PyObject *resultobj = 0;
29935 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29936 wxLongLong result;
29937 void *argp1 = 0 ;
29938 int res1 = 0 ;
29939 PyObject *swig_obj[1] ;
29940
29941 if (!args) SWIG_fail;
29942 swig_obj[0] = args;
29943 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29944 if (!SWIG_IsOK(res1)) {
29945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMilliseconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29946 }
29947 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29948 {
29949 PyThreadState* __tstate = wxPyBeginAllowThreads();
29950 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
29951 wxPyEndAllowThreads(__tstate);
29952 if (PyErr_Occurred()) SWIG_fail;
29953 }
29954 {
29955 PyObject *hi, *lo, *shifter, *shifted;
29956 hi = PyLong_FromLong( (&result)->GetHi() );
29957 lo = PyLong_FromLong( (&result)->GetLo() );
29958 shifter = PyLong_FromLong(32);
29959 shifted = PyNumber_Lshift(hi, shifter);
29960 resultobj = PyNumber_Or(shifted, lo);
29961 Py_DECREF(hi);
29962 Py_DECREF(lo);
29963 Py_DECREF(shifter);
29964 Py_DECREF(shifted);
29965 }
29966 return resultobj;
29967 fail:
29968 return NULL;
29969 }
29970
29971
29972 SWIGINTERN PyObject *_wrap_TimeSpan_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29973 PyObject *resultobj = 0;
29974 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29975 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
29976 wxString *arg2 = (wxString *) &arg2_defvalue ;
29977 wxString result;
29978 void *argp1 = 0 ;
29979 int res1 = 0 ;
29980 bool temp2 = false ;
29981 PyObject * obj0 = 0 ;
29982 PyObject * obj1 = 0 ;
29983 char * kwnames[] = {
29984 (char *) "self",(char *) "format", NULL
29985 };
29986
29987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) SWIG_fail;
29988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29989 if (!SWIG_IsOK(res1)) {
29990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Format" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29991 }
29992 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29993 if (obj1) {
29994 {
29995 arg2 = wxString_in_helper(obj1);
29996 if (arg2 == NULL) SWIG_fail;
29997 temp2 = true;
29998 }
29999 }
30000 {
30001 PyThreadState* __tstate = wxPyBeginAllowThreads();
30002 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
30003 wxPyEndAllowThreads(__tstate);
30004 if (PyErr_Occurred()) SWIG_fail;
30005 }
30006 {
30007 #if wxUSE_UNICODE
30008 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30009 #else
30010 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30011 #endif
30012 }
30013 {
30014 if (temp2)
30015 delete arg2;
30016 }
30017 return resultobj;
30018 fail:
30019 {
30020 if (temp2)
30021 delete arg2;
30022 }
30023 return NULL;
30024 }
30025
30026
30027 SWIGINTERN PyObject *TimeSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30028 PyObject *obj;
30029 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30030 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimeSpan, SWIG_NewClientData(obj));
30031 return SWIG_Py_Void();
30032 }
30033
30034 SWIGINTERN PyObject *TimeSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30035 return SWIG_Python_InitShadowInstance(args);
30036 }
30037
30038 SWIGINTERN PyObject *_wrap_new_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30039 PyObject *resultobj = 0;
30040 int arg1 = (int) 0 ;
30041 int arg2 = (int) 0 ;
30042 int arg3 = (int) 0 ;
30043 int arg4 = (int) 0 ;
30044 wxDateSpan *result = 0 ;
30045 int val1 ;
30046 int ecode1 = 0 ;
30047 int val2 ;
30048 int ecode2 = 0 ;
30049 int val3 ;
30050 int ecode3 = 0 ;
30051 int val4 ;
30052 int ecode4 = 0 ;
30053 PyObject * obj0 = 0 ;
30054 PyObject * obj1 = 0 ;
30055 PyObject * obj2 = 0 ;
30056 PyObject * obj3 = 0 ;
30057 char * kwnames[] = {
30058 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
30059 };
30060
30061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30062 if (obj0) {
30063 ecode1 = SWIG_AsVal_int(obj0, &val1);
30064 if (!SWIG_IsOK(ecode1)) {
30065 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateSpan" "', expected argument " "1"" of type '" "int""'");
30066 }
30067 arg1 = static_cast< int >(val1);
30068 }
30069 if (obj1) {
30070 ecode2 = SWIG_AsVal_int(obj1, &val2);
30071 if (!SWIG_IsOK(ecode2)) {
30072 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateSpan" "', expected argument " "2"" of type '" "int""'");
30073 }
30074 arg2 = static_cast< int >(val2);
30075 }
30076 if (obj2) {
30077 ecode3 = SWIG_AsVal_int(obj2, &val3);
30078 if (!SWIG_IsOK(ecode3)) {
30079 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateSpan" "', expected argument " "3"" of type '" "int""'");
30080 }
30081 arg3 = static_cast< int >(val3);
30082 }
30083 if (obj3) {
30084 ecode4 = SWIG_AsVal_int(obj3, &val4);
30085 if (!SWIG_IsOK(ecode4)) {
30086 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateSpan" "', expected argument " "4"" of type '" "int""'");
30087 }
30088 arg4 = static_cast< int >(val4);
30089 }
30090 {
30091 PyThreadState* __tstate = wxPyBeginAllowThreads();
30092 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
30093 wxPyEndAllowThreads(__tstate);
30094 if (PyErr_Occurred()) SWIG_fail;
30095 }
30096 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_NEW | 0 );
30097 return resultobj;
30098 fail:
30099 return NULL;
30100 }
30101
30102
30103 SWIGINTERN PyObject *_wrap_delete_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30104 PyObject *resultobj = 0;
30105 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30106 void *argp1 = 0 ;
30107 int res1 = 0 ;
30108 PyObject *swig_obj[1] ;
30109
30110 if (!args) SWIG_fail;
30111 swig_obj[0] = args;
30112 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
30113 if (!SWIG_IsOK(res1)) {
30114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateSpan" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30115 }
30116 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30117 {
30118 PyThreadState* __tstate = wxPyBeginAllowThreads();
30119 delete arg1;
30120
30121 wxPyEndAllowThreads(__tstate);
30122 if (PyErr_Occurred()) SWIG_fail;
30123 }
30124 resultobj = SWIG_Py_Void();
30125 return resultobj;
30126 fail:
30127 return NULL;
30128 }
30129
30130
30131 SWIGINTERN PyObject *_wrap_DateSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30132 PyObject *resultobj = 0;
30133 int arg1 ;
30134 wxDateSpan result;
30135 int val1 ;
30136 int ecode1 = 0 ;
30137 PyObject * obj0 = 0 ;
30138 char * kwnames[] = {
30139 (char *) "days", NULL
30140 };
30141
30142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) SWIG_fail;
30143 ecode1 = SWIG_AsVal_int(obj0, &val1);
30144 if (!SWIG_IsOK(ecode1)) {
30145 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Days" "', expected argument " "1"" of type '" "int""'");
30146 }
30147 arg1 = static_cast< int >(val1);
30148 {
30149 PyThreadState* __tstate = wxPyBeginAllowThreads();
30150 result = wxDateSpan::Days(arg1);
30151 wxPyEndAllowThreads(__tstate);
30152 if (PyErr_Occurred()) SWIG_fail;
30153 }
30154 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30155 return resultobj;
30156 fail:
30157 return NULL;
30158 }
30159
30160
30161 SWIGINTERN PyObject *_wrap_DateSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30162 PyObject *resultobj = 0;
30163 wxDateSpan result;
30164
30165 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Day",0,0,0)) SWIG_fail;
30166 {
30167 PyThreadState* __tstate = wxPyBeginAllowThreads();
30168 result = wxDateSpan::Day();
30169 wxPyEndAllowThreads(__tstate);
30170 if (PyErr_Occurred()) SWIG_fail;
30171 }
30172 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30173 return resultobj;
30174 fail:
30175 return NULL;
30176 }
30177
30178
30179 SWIGINTERN PyObject *_wrap_DateSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30180 PyObject *resultobj = 0;
30181 int arg1 ;
30182 wxDateSpan result;
30183 int val1 ;
30184 int ecode1 = 0 ;
30185 PyObject * obj0 = 0 ;
30186 char * kwnames[] = {
30187 (char *) "weeks", NULL
30188 };
30189
30190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) SWIG_fail;
30191 ecode1 = SWIG_AsVal_int(obj0, &val1);
30192 if (!SWIG_IsOK(ecode1)) {
30193 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Weeks" "', expected argument " "1"" of type '" "int""'");
30194 }
30195 arg1 = static_cast< int >(val1);
30196 {
30197 PyThreadState* __tstate = wxPyBeginAllowThreads();
30198 result = wxDateSpan::Weeks(arg1);
30199 wxPyEndAllowThreads(__tstate);
30200 if (PyErr_Occurred()) SWIG_fail;
30201 }
30202 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30203 return resultobj;
30204 fail:
30205 return NULL;
30206 }
30207
30208
30209 SWIGINTERN PyObject *_wrap_DateSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30210 PyObject *resultobj = 0;
30211 wxDateSpan result;
30212
30213 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Week",0,0,0)) SWIG_fail;
30214 {
30215 PyThreadState* __tstate = wxPyBeginAllowThreads();
30216 result = wxDateSpan::Week();
30217 wxPyEndAllowThreads(__tstate);
30218 if (PyErr_Occurred()) SWIG_fail;
30219 }
30220 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30221 return resultobj;
30222 fail:
30223 return NULL;
30224 }
30225
30226
30227 SWIGINTERN PyObject *_wrap_DateSpan_Months(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30228 PyObject *resultobj = 0;
30229 int arg1 ;
30230 wxDateSpan result;
30231 int val1 ;
30232 int ecode1 = 0 ;
30233 PyObject * obj0 = 0 ;
30234 char * kwnames[] = {
30235 (char *) "mon", NULL
30236 };
30237
30238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) SWIG_fail;
30239 ecode1 = SWIG_AsVal_int(obj0, &val1);
30240 if (!SWIG_IsOK(ecode1)) {
30241 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Months" "', expected argument " "1"" of type '" "int""'");
30242 }
30243 arg1 = static_cast< int >(val1);
30244 {
30245 PyThreadState* __tstate = wxPyBeginAllowThreads();
30246 result = wxDateSpan::Months(arg1);
30247 wxPyEndAllowThreads(__tstate);
30248 if (PyErr_Occurred()) SWIG_fail;
30249 }
30250 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30251 return resultobj;
30252 fail:
30253 return NULL;
30254 }
30255
30256
30257 SWIGINTERN PyObject *_wrap_DateSpan_Month(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30258 PyObject *resultobj = 0;
30259 wxDateSpan result;
30260
30261 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Month",0,0,0)) SWIG_fail;
30262 {
30263 PyThreadState* __tstate = wxPyBeginAllowThreads();
30264 result = wxDateSpan::Month();
30265 wxPyEndAllowThreads(__tstate);
30266 if (PyErr_Occurred()) SWIG_fail;
30267 }
30268 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30269 return resultobj;
30270 fail:
30271 return NULL;
30272 }
30273
30274
30275 SWIGINTERN PyObject *_wrap_DateSpan_Years(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30276 PyObject *resultobj = 0;
30277 int arg1 ;
30278 wxDateSpan result;
30279 int val1 ;
30280 int ecode1 = 0 ;
30281 PyObject * obj0 = 0 ;
30282 char * kwnames[] = {
30283 (char *) "years", NULL
30284 };
30285
30286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) SWIG_fail;
30287 ecode1 = SWIG_AsVal_int(obj0, &val1);
30288 if (!SWIG_IsOK(ecode1)) {
30289 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Years" "', expected argument " "1"" of type '" "int""'");
30290 }
30291 arg1 = static_cast< int >(val1);
30292 {
30293 PyThreadState* __tstate = wxPyBeginAllowThreads();
30294 result = wxDateSpan::Years(arg1);
30295 wxPyEndAllowThreads(__tstate);
30296 if (PyErr_Occurred()) SWIG_fail;
30297 }
30298 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30299 return resultobj;
30300 fail:
30301 return NULL;
30302 }
30303
30304
30305 SWIGINTERN PyObject *_wrap_DateSpan_Year(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30306 PyObject *resultobj = 0;
30307 wxDateSpan result;
30308
30309 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Year",0,0,0)) SWIG_fail;
30310 {
30311 PyThreadState* __tstate = wxPyBeginAllowThreads();
30312 result = wxDateSpan::Year();
30313 wxPyEndAllowThreads(__tstate);
30314 if (PyErr_Occurred()) SWIG_fail;
30315 }
30316 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30317 return resultobj;
30318 fail:
30319 return NULL;
30320 }
30321
30322
30323 SWIGINTERN PyObject *_wrap_DateSpan_SetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30324 PyObject *resultobj = 0;
30325 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30326 int arg2 ;
30327 wxDateSpan *result = 0 ;
30328 void *argp1 = 0 ;
30329 int res1 = 0 ;
30330 int val2 ;
30331 int ecode2 = 0 ;
30332 PyObject * obj0 = 0 ;
30333 PyObject * obj1 = 0 ;
30334 char * kwnames[] = {
30335 (char *) "self",(char *) "n", NULL
30336 };
30337
30338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) SWIG_fail;
30339 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30340 if (!SWIG_IsOK(res1)) {
30341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetYears" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30342 }
30343 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30344 ecode2 = SWIG_AsVal_int(obj1, &val2);
30345 if (!SWIG_IsOK(ecode2)) {
30346 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetYears" "', expected argument " "2"" of type '" "int""'");
30347 }
30348 arg2 = static_cast< int >(val2);
30349 {
30350 PyThreadState* __tstate = wxPyBeginAllowThreads();
30351 {
30352 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
30353 result = (wxDateSpan *) &_result_ref;
30354 }
30355 wxPyEndAllowThreads(__tstate);
30356 if (PyErr_Occurred()) SWIG_fail;
30357 }
30358 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30359 return resultobj;
30360 fail:
30361 return NULL;
30362 }
30363
30364
30365 SWIGINTERN PyObject *_wrap_DateSpan_SetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30366 PyObject *resultobj = 0;
30367 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30368 int arg2 ;
30369 wxDateSpan *result = 0 ;
30370 void *argp1 = 0 ;
30371 int res1 = 0 ;
30372 int val2 ;
30373 int ecode2 = 0 ;
30374 PyObject * obj0 = 0 ;
30375 PyObject * obj1 = 0 ;
30376 char * kwnames[] = {
30377 (char *) "self",(char *) "n", NULL
30378 };
30379
30380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) SWIG_fail;
30381 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30382 if (!SWIG_IsOK(res1)) {
30383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetMonths" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30384 }
30385 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30386 ecode2 = SWIG_AsVal_int(obj1, &val2);
30387 if (!SWIG_IsOK(ecode2)) {
30388 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetMonths" "', expected argument " "2"" of type '" "int""'");
30389 }
30390 arg2 = static_cast< int >(val2);
30391 {
30392 PyThreadState* __tstate = wxPyBeginAllowThreads();
30393 {
30394 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
30395 result = (wxDateSpan *) &_result_ref;
30396 }
30397 wxPyEndAllowThreads(__tstate);
30398 if (PyErr_Occurred()) SWIG_fail;
30399 }
30400 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30401 return resultobj;
30402 fail:
30403 return NULL;
30404 }
30405
30406
30407 SWIGINTERN PyObject *_wrap_DateSpan_SetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30408 PyObject *resultobj = 0;
30409 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30410 int arg2 ;
30411 wxDateSpan *result = 0 ;
30412 void *argp1 = 0 ;
30413 int res1 = 0 ;
30414 int val2 ;
30415 int ecode2 = 0 ;
30416 PyObject * obj0 = 0 ;
30417 PyObject * obj1 = 0 ;
30418 char * kwnames[] = {
30419 (char *) "self",(char *) "n", NULL
30420 };
30421
30422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) SWIG_fail;
30423 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30424 if (!SWIG_IsOK(res1)) {
30425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetWeeks" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30426 }
30427 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30428 ecode2 = SWIG_AsVal_int(obj1, &val2);
30429 if (!SWIG_IsOK(ecode2)) {
30430 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetWeeks" "', expected argument " "2"" of type '" "int""'");
30431 }
30432 arg2 = static_cast< int >(val2);
30433 {
30434 PyThreadState* __tstate = wxPyBeginAllowThreads();
30435 {
30436 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
30437 result = (wxDateSpan *) &_result_ref;
30438 }
30439 wxPyEndAllowThreads(__tstate);
30440 if (PyErr_Occurred()) SWIG_fail;
30441 }
30442 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30443 return resultobj;
30444 fail:
30445 return NULL;
30446 }
30447
30448
30449 SWIGINTERN PyObject *_wrap_DateSpan_SetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30450 PyObject *resultobj = 0;
30451 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30452 int arg2 ;
30453 wxDateSpan *result = 0 ;
30454 void *argp1 = 0 ;
30455 int res1 = 0 ;
30456 int val2 ;
30457 int ecode2 = 0 ;
30458 PyObject * obj0 = 0 ;
30459 PyObject * obj1 = 0 ;
30460 char * kwnames[] = {
30461 (char *) "self",(char *) "n", NULL
30462 };
30463
30464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) SWIG_fail;
30465 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30466 if (!SWIG_IsOK(res1)) {
30467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetDays" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30468 }
30469 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30470 ecode2 = SWIG_AsVal_int(obj1, &val2);
30471 if (!SWIG_IsOK(ecode2)) {
30472 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetDays" "', expected argument " "2"" of type '" "int""'");
30473 }
30474 arg2 = static_cast< int >(val2);
30475 {
30476 PyThreadState* __tstate = wxPyBeginAllowThreads();
30477 {
30478 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
30479 result = (wxDateSpan *) &_result_ref;
30480 }
30481 wxPyEndAllowThreads(__tstate);
30482 if (PyErr_Occurred()) SWIG_fail;
30483 }
30484 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30485 return resultobj;
30486 fail:
30487 return NULL;
30488 }
30489
30490
30491 SWIGINTERN PyObject *_wrap_DateSpan_GetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30492 PyObject *resultobj = 0;
30493 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30494 int result;
30495 void *argp1 = 0 ;
30496 int res1 = 0 ;
30497 PyObject *swig_obj[1] ;
30498
30499 if (!args) SWIG_fail;
30500 swig_obj[0] = args;
30501 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30502 if (!SWIG_IsOK(res1)) {
30503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetYears" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30504 }
30505 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30506 {
30507 PyThreadState* __tstate = wxPyBeginAllowThreads();
30508 result = (int)((wxDateSpan const *)arg1)->GetYears();
30509 wxPyEndAllowThreads(__tstate);
30510 if (PyErr_Occurred()) SWIG_fail;
30511 }
30512 resultobj = SWIG_From_int(static_cast< int >(result));
30513 return resultobj;
30514 fail:
30515 return NULL;
30516 }
30517
30518
30519 SWIGINTERN PyObject *_wrap_DateSpan_GetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30520 PyObject *resultobj = 0;
30521 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30522 int result;
30523 void *argp1 = 0 ;
30524 int res1 = 0 ;
30525 PyObject *swig_obj[1] ;
30526
30527 if (!args) SWIG_fail;
30528 swig_obj[0] = args;
30529 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30530 if (!SWIG_IsOK(res1)) {
30531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetMonths" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30532 }
30533 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30534 {
30535 PyThreadState* __tstate = wxPyBeginAllowThreads();
30536 result = (int)((wxDateSpan const *)arg1)->GetMonths();
30537 wxPyEndAllowThreads(__tstate);
30538 if (PyErr_Occurred()) SWIG_fail;
30539 }
30540 resultobj = SWIG_From_int(static_cast< int >(result));
30541 return resultobj;
30542 fail:
30543 return NULL;
30544 }
30545
30546
30547 SWIGINTERN PyObject *_wrap_DateSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30548 PyObject *resultobj = 0;
30549 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30550 int result;
30551 void *argp1 = 0 ;
30552 int res1 = 0 ;
30553 PyObject *swig_obj[1] ;
30554
30555 if (!args) SWIG_fail;
30556 swig_obj[0] = args;
30557 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30558 if (!SWIG_IsOK(res1)) {
30559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetWeeks" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30560 }
30561 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30562 {
30563 PyThreadState* __tstate = wxPyBeginAllowThreads();
30564 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
30565 wxPyEndAllowThreads(__tstate);
30566 if (PyErr_Occurred()) SWIG_fail;
30567 }
30568 resultobj = SWIG_From_int(static_cast< int >(result));
30569 return resultobj;
30570 fail:
30571 return NULL;
30572 }
30573
30574
30575 SWIGINTERN PyObject *_wrap_DateSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30576 PyObject *resultobj = 0;
30577 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30578 int result;
30579 void *argp1 = 0 ;
30580 int res1 = 0 ;
30581 PyObject *swig_obj[1] ;
30582
30583 if (!args) SWIG_fail;
30584 swig_obj[0] = args;
30585 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30586 if (!SWIG_IsOK(res1)) {
30587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30588 }
30589 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30590 {
30591 PyThreadState* __tstate = wxPyBeginAllowThreads();
30592 result = (int)((wxDateSpan const *)arg1)->GetDays();
30593 wxPyEndAllowThreads(__tstate);
30594 if (PyErr_Occurred()) SWIG_fail;
30595 }
30596 resultobj = SWIG_From_int(static_cast< int >(result));
30597 return resultobj;
30598 fail:
30599 return NULL;
30600 }
30601
30602
30603 SWIGINTERN PyObject *_wrap_DateSpan_GetTotalDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30604 PyObject *resultobj = 0;
30605 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30606 int result;
30607 void *argp1 = 0 ;
30608 int res1 = 0 ;
30609 PyObject *swig_obj[1] ;
30610
30611 if (!args) SWIG_fail;
30612 swig_obj[0] = args;
30613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30614 if (!SWIG_IsOK(res1)) {
30615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetTotalDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30616 }
30617 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30618 {
30619 PyThreadState* __tstate = wxPyBeginAllowThreads();
30620 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
30621 wxPyEndAllowThreads(__tstate);
30622 if (PyErr_Occurred()) SWIG_fail;
30623 }
30624 resultobj = SWIG_From_int(static_cast< int >(result));
30625 return resultobj;
30626 fail:
30627 return NULL;
30628 }
30629
30630
30631 SWIGINTERN PyObject *_wrap_DateSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30632 PyObject *resultobj = 0;
30633 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30634 wxDateSpan *arg2 = 0 ;
30635 wxDateSpan *result = 0 ;
30636 void *argp1 = 0 ;
30637 int res1 = 0 ;
30638 void *argp2 = 0 ;
30639 int res2 = 0 ;
30640 PyObject * obj0 = 0 ;
30641 PyObject * obj1 = 0 ;
30642 char * kwnames[] = {
30643 (char *) "self",(char *) "other", NULL
30644 };
30645
30646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
30647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30648 if (!SWIG_IsOK(res1)) {
30649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Add" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30650 }
30651 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30652 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30653 if (!SWIG_IsOK(res2)) {
30654 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30655 }
30656 if (!argp2) {
30657 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30658 }
30659 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30660 {
30661 PyThreadState* __tstate = wxPyBeginAllowThreads();
30662 {
30663 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
30664 result = (wxDateSpan *) &_result_ref;
30665 }
30666 wxPyEndAllowThreads(__tstate);
30667 if (PyErr_Occurred()) SWIG_fail;
30668 }
30669 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30670 return resultobj;
30671 fail:
30672 return NULL;
30673 }
30674
30675
30676 SWIGINTERN PyObject *_wrap_DateSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30677 PyObject *resultobj = 0;
30678 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30679 wxDateSpan *arg2 = 0 ;
30680 wxDateSpan *result = 0 ;
30681 void *argp1 = 0 ;
30682 int res1 = 0 ;
30683 void *argp2 = 0 ;
30684 int res2 = 0 ;
30685 PyObject * obj0 = 0 ;
30686 PyObject * obj1 = 0 ;
30687 char * kwnames[] = {
30688 (char *) "self",(char *) "other", NULL
30689 };
30690
30691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
30692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30693 if (!SWIG_IsOK(res1)) {
30694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Subtract" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30695 }
30696 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30697 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30698 if (!SWIG_IsOK(res2)) {
30699 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30700 }
30701 if (!argp2) {
30702 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30703 }
30704 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30705 {
30706 PyThreadState* __tstate = wxPyBeginAllowThreads();
30707 {
30708 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
30709 result = (wxDateSpan *) &_result_ref;
30710 }
30711 wxPyEndAllowThreads(__tstate);
30712 if (PyErr_Occurred()) SWIG_fail;
30713 }
30714 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30715 return resultobj;
30716 fail:
30717 return NULL;
30718 }
30719
30720
30721 SWIGINTERN PyObject *_wrap_DateSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30722 PyObject *resultobj = 0;
30723 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30724 wxDateSpan *result = 0 ;
30725 void *argp1 = 0 ;
30726 int res1 = 0 ;
30727 PyObject *swig_obj[1] ;
30728
30729 if (!args) SWIG_fail;
30730 swig_obj[0] = args;
30731 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30732 if (!SWIG_IsOK(res1)) {
30733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Neg" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30734 }
30735 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30736 {
30737 PyThreadState* __tstate = wxPyBeginAllowThreads();
30738 {
30739 wxDateSpan &_result_ref = (arg1)->Neg();
30740 result = (wxDateSpan *) &_result_ref;
30741 }
30742 wxPyEndAllowThreads(__tstate);
30743 if (PyErr_Occurred()) SWIG_fail;
30744 }
30745 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30746 return resultobj;
30747 fail:
30748 return NULL;
30749 }
30750
30751
30752 SWIGINTERN PyObject *_wrap_DateSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30753 PyObject *resultobj = 0;
30754 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30755 int arg2 ;
30756 wxDateSpan *result = 0 ;
30757 void *argp1 = 0 ;
30758 int res1 = 0 ;
30759 int val2 ;
30760 int ecode2 = 0 ;
30761 PyObject * obj0 = 0 ;
30762 PyObject * obj1 = 0 ;
30763 char * kwnames[] = {
30764 (char *) "self",(char *) "factor", NULL
30765 };
30766
30767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
30768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30769 if (!SWIG_IsOK(res1)) {
30770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Multiply" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30771 }
30772 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30773 ecode2 = SWIG_AsVal_int(obj1, &val2);
30774 if (!SWIG_IsOK(ecode2)) {
30775 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
30776 }
30777 arg2 = static_cast< int >(val2);
30778 {
30779 PyThreadState* __tstate = wxPyBeginAllowThreads();
30780 {
30781 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
30782 result = (wxDateSpan *) &_result_ref;
30783 }
30784 wxPyEndAllowThreads(__tstate);
30785 if (PyErr_Occurred()) SWIG_fail;
30786 }
30787 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30788 return resultobj;
30789 fail:
30790 return NULL;
30791 }
30792
30793
30794 SWIGINTERN PyObject *_wrap_DateSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30795 PyObject *resultobj = 0;
30796 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30797 wxDateSpan *arg2 = 0 ;
30798 wxDateSpan *result = 0 ;
30799 void *argp1 = 0 ;
30800 int res1 = 0 ;
30801 void *argp2 = 0 ;
30802 int res2 = 0 ;
30803 PyObject * obj0 = 0 ;
30804 PyObject * obj1 = 0 ;
30805 char * kwnames[] = {
30806 (char *) "self",(char *) "other", NULL
30807 };
30808
30809 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
30810 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
30811 if (!SWIG_IsOK(res1)) {
30812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___iadd__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30813 }
30814 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30815 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30816 if (!SWIG_IsOK(res2)) {
30817 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30818 }
30819 if (!argp2) {
30820 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30821 }
30822 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30823 {
30824 PyThreadState* __tstate = wxPyBeginAllowThreads();
30825 {
30826 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
30827 result = (wxDateSpan *) &_result_ref;
30828 }
30829 wxPyEndAllowThreads(__tstate);
30830 if (PyErr_Occurred()) SWIG_fail;
30831 }
30832 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30833 return resultobj;
30834 fail:
30835 return NULL;
30836 }
30837
30838
30839 SWIGINTERN PyObject *_wrap_DateSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30840 PyObject *resultobj = 0;
30841 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30842 wxDateSpan *arg2 = 0 ;
30843 wxDateSpan *result = 0 ;
30844 void *argp1 = 0 ;
30845 int res1 = 0 ;
30846 void *argp2 = 0 ;
30847 int res2 = 0 ;
30848 PyObject * obj0 = 0 ;
30849 PyObject * obj1 = 0 ;
30850 char * kwnames[] = {
30851 (char *) "self",(char *) "other", NULL
30852 };
30853
30854 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
30855 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
30856 if (!SWIG_IsOK(res1)) {
30857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___isub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30858 }
30859 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30860 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30861 if (!SWIG_IsOK(res2)) {
30862 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30863 }
30864 if (!argp2) {
30865 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30866 }
30867 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30868 {
30869 PyThreadState* __tstate = wxPyBeginAllowThreads();
30870 {
30871 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
30872 result = (wxDateSpan *) &_result_ref;
30873 }
30874 wxPyEndAllowThreads(__tstate);
30875 if (PyErr_Occurred()) SWIG_fail;
30876 }
30877 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30878 return resultobj;
30879 fail:
30880 return NULL;
30881 }
30882
30883
30884 SWIGINTERN PyObject *_wrap_DateSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30885 PyObject *resultobj = 0;
30886 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30887 wxDateSpan *result = 0 ;
30888 void *argp1 = 0 ;
30889 int res1 = 0 ;
30890 PyObject *swig_obj[1] ;
30891
30892 if (!args) SWIG_fail;
30893 swig_obj[0] = args;
30894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30895 if (!SWIG_IsOK(res1)) {
30896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___neg__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30897 }
30898 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30899 {
30900 PyThreadState* __tstate = wxPyBeginAllowThreads();
30901 {
30902 wxDateSpan &_result_ref = (arg1)->operator -();
30903 result = (wxDateSpan *) &_result_ref;
30904 }
30905 wxPyEndAllowThreads(__tstate);
30906 if (PyErr_Occurred()) SWIG_fail;
30907 }
30908 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30909 return resultobj;
30910 fail:
30911 return NULL;
30912 }
30913
30914
30915 SWIGINTERN PyObject *_wrap_DateSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30916 PyObject *resultobj = 0;
30917 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30918 int arg2 ;
30919 wxDateSpan *result = 0 ;
30920 void *argp1 = 0 ;
30921 int res1 = 0 ;
30922 int val2 ;
30923 int ecode2 = 0 ;
30924 PyObject * obj0 = 0 ;
30925 PyObject * obj1 = 0 ;
30926 char * kwnames[] = {
30927 (char *) "self",(char *) "factor", NULL
30928 };
30929
30930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
30931 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
30932 if (!SWIG_IsOK(res1)) {
30933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___imul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30934 }
30935 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30936 ecode2 = SWIG_AsVal_int(obj1, &val2);
30937 if (!SWIG_IsOK(ecode2)) {
30938 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___imul__" "', expected argument " "2"" of type '" "int""'");
30939 }
30940 arg2 = static_cast< int >(val2);
30941 {
30942 PyThreadState* __tstate = wxPyBeginAllowThreads();
30943 {
30944 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
30945 result = (wxDateSpan *) &_result_ref;
30946 }
30947 wxPyEndAllowThreads(__tstate);
30948 if (PyErr_Occurred()) SWIG_fail;
30949 }
30950 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30951 return resultobj;
30952 fail:
30953 return NULL;
30954 }
30955
30956
30957 SWIGINTERN PyObject *_wrap_DateSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30958 PyObject *resultobj = 0;
30959 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30960 wxDateSpan *arg2 = 0 ;
30961 wxDateSpan result;
30962 void *argp1 = 0 ;
30963 int res1 = 0 ;
30964 void *argp2 = 0 ;
30965 int res2 = 0 ;
30966 PyObject * obj0 = 0 ;
30967 PyObject * obj1 = 0 ;
30968 char * kwnames[] = {
30969 (char *) "self",(char *) "other", NULL
30970 };
30971
30972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
30973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30974 if (!SWIG_IsOK(res1)) {
30975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___add__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30976 }
30977 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30978 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30979 if (!SWIG_IsOK(res2)) {
30980 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30981 }
30982 if (!argp2) {
30983 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30984 }
30985 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30986 {
30987 PyThreadState* __tstate = wxPyBeginAllowThreads();
30988 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
30989 wxPyEndAllowThreads(__tstate);
30990 if (PyErr_Occurred()) SWIG_fail;
30991 }
30992 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30993 return resultobj;
30994 fail:
30995 return NULL;
30996 }
30997
30998
30999 SWIGINTERN PyObject *_wrap_DateSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31000 PyObject *resultobj = 0;
31001 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31002 wxDateSpan *arg2 = 0 ;
31003 wxDateSpan result;
31004 void *argp1 = 0 ;
31005 int res1 = 0 ;
31006 void *argp2 = 0 ;
31007 int res2 = 0 ;
31008 PyObject * obj0 = 0 ;
31009 PyObject * obj1 = 0 ;
31010 char * kwnames[] = {
31011 (char *) "self",(char *) "other", NULL
31012 };
31013
31014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
31015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31016 if (!SWIG_IsOK(res1)) {
31017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___sub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31018 }
31019 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31020 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31021 if (!SWIG_IsOK(res2)) {
31022 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31023 }
31024 if (!argp2) {
31025 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31026 }
31027 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31028 {
31029 PyThreadState* __tstate = wxPyBeginAllowThreads();
31030 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
31031 wxPyEndAllowThreads(__tstate);
31032 if (PyErr_Occurred()) SWIG_fail;
31033 }
31034 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31035 return resultobj;
31036 fail:
31037 return NULL;
31038 }
31039
31040
31041 SWIGINTERN PyObject *_wrap_DateSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31042 PyObject *resultobj = 0;
31043 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31044 int arg2 ;
31045 wxDateSpan result;
31046 void *argp1 = 0 ;
31047 int res1 = 0 ;
31048 int val2 ;
31049 int ecode2 = 0 ;
31050 PyObject * obj0 = 0 ;
31051 PyObject * obj1 = 0 ;
31052 char * kwnames[] = {
31053 (char *) "self",(char *) "n", NULL
31054 };
31055
31056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
31057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31058 if (!SWIG_IsOK(res1)) {
31059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___mul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31060 }
31061 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31062 ecode2 = SWIG_AsVal_int(obj1, &val2);
31063 if (!SWIG_IsOK(ecode2)) {
31064 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___mul__" "', expected argument " "2"" of type '" "int""'");
31065 }
31066 arg2 = static_cast< int >(val2);
31067 {
31068 PyThreadState* __tstate = wxPyBeginAllowThreads();
31069 result = wxDateSpan___mul__(arg1,arg2);
31070 wxPyEndAllowThreads(__tstate);
31071 if (PyErr_Occurred()) SWIG_fail;
31072 }
31073 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31074 return resultobj;
31075 fail:
31076 return NULL;
31077 }
31078
31079
31080 SWIGINTERN PyObject *_wrap_DateSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31081 PyObject *resultobj = 0;
31082 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31083 int arg2 ;
31084 wxDateSpan result;
31085 void *argp1 = 0 ;
31086 int res1 = 0 ;
31087 int val2 ;
31088 int ecode2 = 0 ;
31089 PyObject * obj0 = 0 ;
31090 PyObject * obj1 = 0 ;
31091 char * kwnames[] = {
31092 (char *) "self",(char *) "n", NULL
31093 };
31094
31095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
31096 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31097 if (!SWIG_IsOK(res1)) {
31098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___rmul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31099 }
31100 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31101 ecode2 = SWIG_AsVal_int(obj1, &val2);
31102 if (!SWIG_IsOK(ecode2)) {
31103 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
31104 }
31105 arg2 = static_cast< int >(val2);
31106 {
31107 PyThreadState* __tstate = wxPyBeginAllowThreads();
31108 result = wxDateSpan___rmul__(arg1,arg2);
31109 wxPyEndAllowThreads(__tstate);
31110 if (PyErr_Occurred()) SWIG_fail;
31111 }
31112 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31113 return resultobj;
31114 fail:
31115 return NULL;
31116 }
31117
31118
31119 SWIGINTERN PyObject *_wrap_DateSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31120 PyObject *resultobj = 0;
31121 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31122 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
31123 bool result;
31124 void *argp1 = 0 ;
31125 int res1 = 0 ;
31126 void *argp2 = 0 ;
31127 int res2 = 0 ;
31128 PyObject * obj0 = 0 ;
31129 PyObject * obj1 = 0 ;
31130 char * kwnames[] = {
31131 (char *) "self",(char *) "other", NULL
31132 };
31133
31134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
31135 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31136 if (!SWIG_IsOK(res1)) {
31137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___eq__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31138 }
31139 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31140 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31141 if (!SWIG_IsOK(res2)) {
31142 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___eq__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
31143 }
31144 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31145 {
31146 PyThreadState* __tstate = wxPyBeginAllowThreads();
31147 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
31148 wxPyEndAllowThreads(__tstate);
31149 if (PyErr_Occurred()) SWIG_fail;
31150 }
31151 {
31152 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31153 }
31154 return resultobj;
31155 fail:
31156 return NULL;
31157 }
31158
31159
31160 SWIGINTERN PyObject *_wrap_DateSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31161 PyObject *resultobj = 0;
31162 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31163 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
31164 bool result;
31165 void *argp1 = 0 ;
31166 int res1 = 0 ;
31167 void *argp2 = 0 ;
31168 int res2 = 0 ;
31169 PyObject * obj0 = 0 ;
31170 PyObject * obj1 = 0 ;
31171 char * kwnames[] = {
31172 (char *) "self",(char *) "other", NULL
31173 };
31174
31175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
31176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31177 if (!SWIG_IsOK(res1)) {
31178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___ne__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31179 }
31180 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31181 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31182 if (!SWIG_IsOK(res2)) {
31183 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___ne__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
31184 }
31185 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31186 {
31187 PyThreadState* __tstate = wxPyBeginAllowThreads();
31188 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
31189 wxPyEndAllowThreads(__tstate);
31190 if (PyErr_Occurred()) SWIG_fail;
31191 }
31192 {
31193 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31194 }
31195 return resultobj;
31196 fail:
31197 return NULL;
31198 }
31199
31200
31201 SWIGINTERN PyObject *DateSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31202 PyObject *obj;
31203 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31204 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateSpan, SWIG_NewClientData(obj));
31205 return SWIG_Py_Void();
31206 }
31207
31208 SWIGINTERN PyObject *DateSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31209 return SWIG_Python_InitShadowInstance(args);
31210 }
31211
31212 SWIGINTERN PyObject *_wrap_GetLocalTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31213 PyObject *resultobj = 0;
31214 long result;
31215
31216 if (!SWIG_Python_UnpackTuple(args,"GetLocalTime",0,0,0)) SWIG_fail;
31217 {
31218 PyThreadState* __tstate = wxPyBeginAllowThreads();
31219 result = (long)wxGetLocalTime();
31220 wxPyEndAllowThreads(__tstate);
31221 if (PyErr_Occurred()) SWIG_fail;
31222 }
31223 resultobj = SWIG_From_long(static_cast< long >(result));
31224 return resultobj;
31225 fail:
31226 return NULL;
31227 }
31228
31229
31230 SWIGINTERN PyObject *_wrap_GetUTCTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31231 PyObject *resultobj = 0;
31232 long result;
31233
31234 if (!SWIG_Python_UnpackTuple(args,"GetUTCTime",0,0,0)) SWIG_fail;
31235 {
31236 PyThreadState* __tstate = wxPyBeginAllowThreads();
31237 result = (long)wxGetUTCTime();
31238 wxPyEndAllowThreads(__tstate);
31239 if (PyErr_Occurred()) SWIG_fail;
31240 }
31241 resultobj = SWIG_From_long(static_cast< long >(result));
31242 return resultobj;
31243 fail:
31244 return NULL;
31245 }
31246
31247
31248 SWIGINTERN PyObject *_wrap_GetCurrentTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31249 PyObject *resultobj = 0;
31250 long result;
31251
31252 if (!SWIG_Python_UnpackTuple(args,"GetCurrentTime",0,0,0)) SWIG_fail;
31253 {
31254 PyThreadState* __tstate = wxPyBeginAllowThreads();
31255 result = (long)wxGetCurrentTime();
31256 wxPyEndAllowThreads(__tstate);
31257 if (PyErr_Occurred()) SWIG_fail;
31258 }
31259 resultobj = SWIG_From_long(static_cast< long >(result));
31260 return resultobj;
31261 fail:
31262 return NULL;
31263 }
31264
31265
31266 SWIGINTERN PyObject *_wrap_GetLocalTimeMillis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31267 PyObject *resultobj = 0;
31268 wxLongLong result;
31269
31270 if (!SWIG_Python_UnpackTuple(args,"GetLocalTimeMillis",0,0,0)) SWIG_fail;
31271 {
31272 PyThreadState* __tstate = wxPyBeginAllowThreads();
31273 result = wxGetLocalTimeMillis();
31274 wxPyEndAllowThreads(__tstate);
31275 if (PyErr_Occurred()) SWIG_fail;
31276 }
31277 {
31278 PyObject *hi, *lo, *shifter, *shifted;
31279 hi = PyLong_FromLong( (&result)->GetHi() );
31280 lo = PyLong_FromLong( (&result)->GetLo() );
31281 shifter = PyLong_FromLong(32);
31282 shifted = PyNumber_Lshift(hi, shifter);
31283 resultobj = PyNumber_Or(shifted, lo);
31284 Py_DECREF(hi);
31285 Py_DECREF(lo);
31286 Py_DECREF(shifter);
31287 Py_DECREF(shifted);
31288 }
31289 return resultobj;
31290 fail:
31291 return NULL;
31292 }
31293
31294
31295 SWIGINTERN int DefaultDateTime_set(PyObject *) {
31296 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTime is read-only.");
31297 return 1;
31298 }
31299
31300
31301 SWIGINTERN PyObject *DefaultDateTime_get(void) {
31302 PyObject *pyobj = 0;
31303
31304 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0 );
31305 return pyobj;
31306 }
31307
31308
31309 SWIGINTERN PyObject *_wrap_new_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31310 PyObject *resultobj = 0;
31311 wxDataFormatId arg1 ;
31312 wxDataFormat *result = 0 ;
31313 int val1 ;
31314 int ecode1 = 0 ;
31315 PyObject * obj0 = 0 ;
31316 char * kwnames[] = {
31317 (char *) "type", NULL
31318 };
31319
31320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) SWIG_fail;
31321 ecode1 = SWIG_AsVal_int(obj0, &val1);
31322 if (!SWIG_IsOK(ecode1)) {
31323 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DataFormat" "', expected argument " "1"" of type '" "wxDataFormatId""'");
31324 }
31325 arg1 = static_cast< wxDataFormatId >(val1);
31326 {
31327 PyThreadState* __tstate = wxPyBeginAllowThreads();
31328 result = (wxDataFormat *)new wxDataFormat(arg1);
31329 wxPyEndAllowThreads(__tstate);
31330 if (PyErr_Occurred()) SWIG_fail;
31331 }
31332 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_NEW | 0 );
31333 return resultobj;
31334 fail:
31335 return NULL;
31336 }
31337
31338
31339 SWIGINTERN PyObject *_wrap_new_CustomDataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31340 PyObject *resultobj = 0;
31341 wxString *arg1 = 0 ;
31342 wxDataFormat *result = 0 ;
31343 bool temp1 = false ;
31344 PyObject * obj0 = 0 ;
31345 char * kwnames[] = {
31346 (char *) "format", NULL
31347 };
31348
31349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) SWIG_fail;
31350 {
31351 arg1 = wxString_in_helper(obj0);
31352 if (arg1 == NULL) SWIG_fail;
31353 temp1 = true;
31354 }
31355 {
31356 PyThreadState* __tstate = wxPyBeginAllowThreads();
31357 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
31358 wxPyEndAllowThreads(__tstate);
31359 if (PyErr_Occurred()) SWIG_fail;
31360 }
31361 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
31362 {
31363 if (temp1)
31364 delete arg1;
31365 }
31366 return resultobj;
31367 fail:
31368 {
31369 if (temp1)
31370 delete arg1;
31371 }
31372 return NULL;
31373 }
31374
31375
31376 SWIGINTERN PyObject *_wrap_delete_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31377 PyObject *resultobj = 0;
31378 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31379 void *argp1 = 0 ;
31380 int res1 = 0 ;
31381 PyObject *swig_obj[1] ;
31382
31383 if (!args) SWIG_fail;
31384 swig_obj[0] = args;
31385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, SWIG_POINTER_DISOWN | 0 );
31386 if (!SWIG_IsOK(res1)) {
31387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataFormat" "', expected argument " "1"" of type '" "wxDataFormat *""'");
31388 }
31389 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31390 {
31391 PyThreadState* __tstate = wxPyBeginAllowThreads();
31392 delete arg1;
31393
31394 wxPyEndAllowThreads(__tstate);
31395 if (PyErr_Occurred()) SWIG_fail;
31396 }
31397 resultobj = SWIG_Py_Void();
31398 return resultobj;
31399 fail:
31400 return NULL;
31401 }
31402
31403
31404 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31405 PyObject *resultobj = 0;
31406 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31407 wxDataFormatId arg2 ;
31408 bool result;
31409 void *argp1 = 0 ;
31410 int res1 = 0 ;
31411 int val2 ;
31412 int ecode2 = 0 ;
31413
31414 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31415 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31416 if (!SWIG_IsOK(res1)) {
31417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31418 }
31419 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31420 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
31421 if (!SWIG_IsOK(ecode2)) {
31422 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31423 }
31424 arg2 = static_cast< wxDataFormatId >(val2);
31425 {
31426 PyThreadState* __tstate = wxPyBeginAllowThreads();
31427 result = (bool)((wxDataFormat const *)arg1)->operator ==(arg2);
31428 wxPyEndAllowThreads(__tstate);
31429 if (PyErr_Occurred()) SWIG_fail;
31430 }
31431 {
31432 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31433 }
31434 return resultobj;
31435 fail:
31436 return NULL;
31437 }
31438
31439
31440 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31441 PyObject *resultobj = 0;
31442 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31443 wxDataFormatId arg2 ;
31444 bool result;
31445 void *argp1 = 0 ;
31446 int res1 = 0 ;
31447 int val2 ;
31448 int ecode2 = 0 ;
31449
31450 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31451 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31452 if (!SWIG_IsOK(res1)) {
31453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31454 }
31455 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31456 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
31457 if (!SWIG_IsOK(ecode2)) {
31458 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31459 }
31460 arg2 = static_cast< wxDataFormatId >(val2);
31461 {
31462 PyThreadState* __tstate = wxPyBeginAllowThreads();
31463 result = (bool)((wxDataFormat const *)arg1)->operator !=(arg2);
31464 wxPyEndAllowThreads(__tstate);
31465 if (PyErr_Occurred()) SWIG_fail;
31466 }
31467 {
31468 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31469 }
31470 return resultobj;
31471 fail:
31472 return NULL;
31473 }
31474
31475
31476 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31477 PyObject *resultobj = 0;
31478 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31479 wxDataFormat *arg2 = 0 ;
31480 bool result;
31481 void *argp1 = 0 ;
31482 int res1 = 0 ;
31483 void *argp2 = 0 ;
31484 int res2 = 0 ;
31485
31486 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31488 if (!SWIG_IsOK(res1)) {
31489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31490 }
31491 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31492 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31493 if (!SWIG_IsOK(res2)) {
31494 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31495 }
31496 if (!argp2) {
31497 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31498 }
31499 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31500 {
31501 PyThreadState* __tstate = wxPyBeginAllowThreads();
31502 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
31503 wxPyEndAllowThreads(__tstate);
31504 if (PyErr_Occurred()) SWIG_fail;
31505 }
31506 {
31507 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31508 }
31509 return resultobj;
31510 fail:
31511 return NULL;
31512 }
31513
31514
31515 SWIGINTERN PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
31516 int argc;
31517 PyObject *argv[3];
31518
31519 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___eq__",0,2,argv))) SWIG_fail;
31520 --argc;
31521 if (argc == 2) {
31522 int _v = 0;
31523 {
31524 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
31525 _v = SWIG_CheckState(res);
31526 }
31527 if (!_v) goto check_1;
31528 return _wrap_DataFormat___eq____SWIG_1(self, argc, argv);
31529 }
31530 check_1:
31531
31532 if (argc == 2) {
31533 return _wrap_DataFormat___eq____SWIG_0(self, argc, argv);
31534 }
31535
31536 fail:
31537 Py_INCREF(Py_NotImplemented);
31538 return Py_NotImplemented;
31539 }
31540
31541
31542 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31543 PyObject *resultobj = 0;
31544 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31545 wxDataFormat *arg2 = 0 ;
31546 bool result;
31547 void *argp1 = 0 ;
31548 int res1 = 0 ;
31549 void *argp2 = 0 ;
31550 int res2 = 0 ;
31551
31552 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31553 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31554 if (!SWIG_IsOK(res1)) {
31555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31556 }
31557 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31558 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31559 if (!SWIG_IsOK(res2)) {
31560 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31561 }
31562 if (!argp2) {
31563 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31564 }
31565 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31566 {
31567 PyThreadState* __tstate = wxPyBeginAllowThreads();
31568 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
31569 wxPyEndAllowThreads(__tstate);
31570 if (PyErr_Occurred()) SWIG_fail;
31571 }
31572 {
31573 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31574 }
31575 return resultobj;
31576 fail:
31577 return NULL;
31578 }
31579
31580
31581 SWIGINTERN PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
31582 int argc;
31583 PyObject *argv[3];
31584
31585 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___ne__",0,2,argv))) SWIG_fail;
31586 --argc;
31587 if (argc == 2) {
31588 int _v = 0;
31589 {
31590 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
31591 _v = SWIG_CheckState(res);
31592 }
31593 if (!_v) goto check_1;
31594 return _wrap_DataFormat___ne____SWIG_1(self, argc, argv);
31595 }
31596 check_1:
31597
31598 if (argc == 2) {
31599 return _wrap_DataFormat___ne____SWIG_0(self, argc, argv);
31600 }
31601
31602 fail:
31603 Py_INCREF(Py_NotImplemented);
31604 return Py_NotImplemented;
31605 }
31606
31607
31608 SWIGINTERN PyObject *_wrap_DataFormat_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31609 PyObject *resultobj = 0;
31610 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31611 wxDataFormatId arg2 ;
31612 void *argp1 = 0 ;
31613 int res1 = 0 ;
31614 int val2 ;
31615 int ecode2 = 0 ;
31616 PyObject * obj0 = 0 ;
31617 PyObject * obj1 = 0 ;
31618 char * kwnames[] = {
31619 (char *) "self",(char *) "format", NULL
31620 };
31621
31622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
31623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31624 if (!SWIG_IsOK(res1)) {
31625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetType" "', expected argument " "1"" of type '" "wxDataFormat *""'");
31626 }
31627 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31628 ecode2 = SWIG_AsVal_int(obj1, &val2);
31629 if (!SWIG_IsOK(ecode2)) {
31630 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat_SetType" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31631 }
31632 arg2 = static_cast< wxDataFormatId >(val2);
31633 {
31634 PyThreadState* __tstate = wxPyBeginAllowThreads();
31635 (arg1)->SetType(arg2);
31636 wxPyEndAllowThreads(__tstate);
31637 if (PyErr_Occurred()) SWIG_fail;
31638 }
31639 resultobj = SWIG_Py_Void();
31640 return resultobj;
31641 fail:
31642 return NULL;
31643 }
31644
31645
31646 SWIGINTERN PyObject *_wrap_DataFormat_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31647 PyObject *resultobj = 0;
31648 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31649 wxDataFormatId result;
31650 void *argp1 = 0 ;
31651 int res1 = 0 ;
31652 PyObject *swig_obj[1] ;
31653
31654 if (!args) SWIG_fail;
31655 swig_obj[0] = args;
31656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31657 if (!SWIG_IsOK(res1)) {
31658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetType" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31659 }
31660 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31661 {
31662 PyThreadState* __tstate = wxPyBeginAllowThreads();
31663 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
31664 wxPyEndAllowThreads(__tstate);
31665 if (PyErr_Occurred()) SWIG_fail;
31666 }
31667 resultobj = SWIG_From_int(static_cast< int >(result));
31668 return resultobj;
31669 fail:
31670 return NULL;
31671 }
31672
31673
31674 SWIGINTERN PyObject *_wrap_DataFormat_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31675 PyObject *resultobj = 0;
31676 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31677 wxString result;
31678 void *argp1 = 0 ;
31679 int res1 = 0 ;
31680 PyObject *swig_obj[1] ;
31681
31682 if (!args) SWIG_fail;
31683 swig_obj[0] = args;
31684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31685 if (!SWIG_IsOK(res1)) {
31686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetId" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31687 }
31688 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31689 {
31690 PyThreadState* __tstate = wxPyBeginAllowThreads();
31691 result = ((wxDataFormat const *)arg1)->GetId();
31692 wxPyEndAllowThreads(__tstate);
31693 if (PyErr_Occurred()) SWIG_fail;
31694 }
31695 {
31696 #if wxUSE_UNICODE
31697 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31698 #else
31699 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31700 #endif
31701 }
31702 return resultobj;
31703 fail:
31704 return NULL;
31705 }
31706
31707
31708 SWIGINTERN PyObject *_wrap_DataFormat_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31709 PyObject *resultobj = 0;
31710 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31711 wxString *arg2 = 0 ;
31712 void *argp1 = 0 ;
31713 int res1 = 0 ;
31714 bool temp2 = false ;
31715 PyObject * obj0 = 0 ;
31716 PyObject * obj1 = 0 ;
31717 char * kwnames[] = {
31718 (char *) "self",(char *) "format", NULL
31719 };
31720
31721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
31722 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31723 if (!SWIG_IsOK(res1)) {
31724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetId" "', expected argument " "1"" of type '" "wxDataFormat *""'");
31725 }
31726 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31727 {
31728 arg2 = wxString_in_helper(obj1);
31729 if (arg2 == NULL) SWIG_fail;
31730 temp2 = true;
31731 }
31732 {
31733 PyThreadState* __tstate = wxPyBeginAllowThreads();
31734 (arg1)->SetId((wxString const &)*arg2);
31735 wxPyEndAllowThreads(__tstate);
31736 if (PyErr_Occurred()) SWIG_fail;
31737 }
31738 resultobj = SWIG_Py_Void();
31739 {
31740 if (temp2)
31741 delete arg2;
31742 }
31743 return resultobj;
31744 fail:
31745 {
31746 if (temp2)
31747 delete arg2;
31748 }
31749 return NULL;
31750 }
31751
31752
31753 SWIGINTERN PyObject *DataFormat_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31754 PyObject *obj;
31755 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31756 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataFormat, SWIG_NewClientData(obj));
31757 return SWIG_Py_Void();
31758 }
31759
31760 SWIGINTERN PyObject *DataFormat_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31761 return SWIG_Python_InitShadowInstance(args);
31762 }
31763
31764 SWIGINTERN int FormatInvalid_set(PyObject *) {
31765 SWIG_Error(SWIG_AttributeError,"Variable FormatInvalid is read-only.");
31766 return 1;
31767 }
31768
31769
31770 SWIGINTERN PyObject *FormatInvalid_get(void) {
31771 PyObject *pyobj = 0;
31772
31773 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0 );
31774 return pyobj;
31775 }
31776
31777
31778 SWIGINTERN PyObject *_wrap_delete_DataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31779 PyObject *resultobj = 0;
31780 wxDataObject *arg1 = (wxDataObject *) 0 ;
31781 void *argp1 = 0 ;
31782 int res1 = 0 ;
31783 PyObject *swig_obj[1] ;
31784
31785 if (!args) SWIG_fail;
31786 swig_obj[0] = args;
31787 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
31788 if (!SWIG_IsOK(res1)) {
31789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataObject" "', expected argument " "1"" of type '" "wxDataObject *""'");
31790 }
31791 arg1 = reinterpret_cast< wxDataObject * >(argp1);
31792 {
31793 PyThreadState* __tstate = wxPyBeginAllowThreads();
31794 delete arg1;
31795
31796 wxPyEndAllowThreads(__tstate);
31797 if (PyErr_Occurred()) SWIG_fail;
31798 }
31799 resultobj = SWIG_Py_Void();
31800 return resultobj;
31801 fail:
31802 return NULL;
31803 }
31804
31805
31806 SWIGINTERN PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31807 PyObject *resultobj = 0;
31808 wxDataObject *arg1 = (wxDataObject *) 0 ;
31809 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
31810 SwigValueWrapper<wxDataFormat > result;
31811 void *argp1 = 0 ;
31812 int res1 = 0 ;
31813 int val2 ;
31814 int ecode2 = 0 ;
31815 PyObject * obj0 = 0 ;
31816 PyObject * obj1 = 0 ;
31817 char * kwnames[] = {
31818 (char *) "self",(char *) "dir", NULL
31819 };
31820
31821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) SWIG_fail;
31822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
31823 if (!SWIG_IsOK(res1)) {
31824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "1"" of type '" "wxDataObject const *""'");
31825 }
31826 arg1 = reinterpret_cast< wxDataObject * >(argp1);
31827 if (obj1) {
31828 ecode2 = SWIG_AsVal_int(obj1, &val2);
31829 if (!SWIG_IsOK(ecode2)) {
31830 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
31831 }
31832 arg2 = static_cast< wxDataObject::Direction >(val2);
31833 }
31834 {
31835 PyThreadState* __tstate = wxPyBeginAllowThreads();
31836 result = ((wxDataObject const *)arg1)->GetPreferredFormat(arg2);
31837 wxPyEndAllowThreads(__tstate);
31838 if (PyErr_Occurred()) SWIG_fail;
31839 }
31840 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
31841 return resultobj;
31842 fail:
31843 return NULL;
31844 }
31845
31846
31847 SWIGINTERN PyObject *_wrap_DataObject_GetFormatCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31848 PyObject *resultobj = 0;
31849 wxDataObject *arg1 = (wxDataObject *) 0 ;
31850 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
31851 size_t result;
31852 void *argp1 = 0 ;
31853 int res1 = 0 ;
31854 int val2 ;
31855 int ecode2 = 0 ;
31856 PyObject * obj0 = 0 ;
31857 PyObject * obj1 = 0 ;
31858 char * kwnames[] = {
31859 (char *) "self",(char *) "dir", NULL
31860 };
31861
31862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) SWIG_fail;
31863 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
31864 if (!SWIG_IsOK(res1)) {
31865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetFormatCount" "', expected argument " "1"" of type '" "wxDataObject const *""'");
31866 }
31867 arg1 = reinterpret_cast< wxDataObject * >(argp1);
31868 if (obj1) {
31869 ecode2 = SWIG_AsVal_int(obj1, &val2);
31870 if (!SWIG_IsOK(ecode2)) {
31871 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetFormatCount" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
31872 }
31873 arg2 = static_cast< wxDataObject::Direction >(val2);
31874 }
31875 {
31876 PyThreadState* __tstate = wxPyBeginAllowThreads();
31877 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount(arg2);
31878 wxPyEndAllowThreads(__tstate);
31879 if (PyErr_Occurred()) SWIG_fail;
31880 }
31881 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
31882 return resultobj;
31883 fail:
31884 return NULL;
31885 }
31886
31887
31888 SWIGINTERN PyObject *_wrap_DataObject_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31889 PyObject *resultobj = 0;
31890 wxDataObject *arg1 = (wxDataObject *) 0 ;
31891 wxDataFormat *arg2 = 0 ;
31892 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
31893 bool result;
31894 void *argp1 = 0 ;
31895 int res1 = 0 ;
31896 void *argp2 = 0 ;
31897 int res2 = 0 ;
31898 int val3 ;
31899 int ecode3 = 0 ;
31900 PyObject * obj0 = 0 ;
31901 PyObject * obj1 = 0 ;
31902 PyObject * obj2 = 0 ;
31903 char * kwnames[] = {
31904 (char *) "self",(char *) "format",(char *) "dir", NULL
31905 };
31906
31907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
31909 if (!SWIG_IsOK(res1)) {
31910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_IsSupported" "', expected argument " "1"" of type '" "wxDataObject const *""'");
31911 }
31912 arg1 = reinterpret_cast< wxDataObject * >(argp1);
31913 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31914 if (!SWIG_IsOK(res2)) {
31915 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31916 }
31917 if (!argp2) {
31918 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31919 }
31920 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31921 if (obj2) {
31922 ecode3 = SWIG_AsVal_int(obj2, &val3);
31923 if (!SWIG_IsOK(ecode3)) {
31924 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObject_IsSupported" "', expected argument " "3"" of type '" "wxDataObject::Direction""'");
31925 }
31926 arg3 = static_cast< wxDataObject::Direction >(val3);
31927 }
31928 {
31929 PyThreadState* __tstate = wxPyBeginAllowThreads();
31930 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,arg3);
31931 wxPyEndAllowThreads(__tstate);
31932 if (PyErr_Occurred()) SWIG_fail;
31933 }
31934 {
31935 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31936 }
31937 return resultobj;
31938 fail:
31939 return NULL;
31940 }
31941
31942
31943 SWIGINTERN PyObject *_wrap_DataObject_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31944 PyObject *resultobj = 0;
31945 wxDataObject *arg1 = (wxDataObject *) 0 ;
31946 wxDataFormat *arg2 = 0 ;
31947 size_t result;
31948 void *argp1 = 0 ;
31949 int res1 = 0 ;
31950 void *argp2 = 0 ;
31951 int res2 = 0 ;
31952 PyObject * obj0 = 0 ;
31953 PyObject * obj1 = 0 ;
31954 char * kwnames[] = {
31955 (char *) "self",(char *) "format", NULL
31956 };
31957
31958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) SWIG_fail;
31959 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
31960 if (!SWIG_IsOK(res1)) {
31961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataSize" "', expected argument " "1"" of type '" "wxDataObject const *""'");
31962 }
31963 arg1 = reinterpret_cast< wxDataObject * >(argp1);
31964 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31965 if (!SWIG_IsOK(res2)) {
31966 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31967 }
31968 if (!argp2) {
31969 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31970 }
31971 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31972 {
31973 PyThreadState* __tstate = wxPyBeginAllowThreads();
31974 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
31975 wxPyEndAllowThreads(__tstate);
31976 if (PyErr_Occurred()) SWIG_fail;
31977 }
31978 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
31979 return resultobj;
31980 fail:
31981 return NULL;
31982 }
31983
31984
31985 SWIGINTERN PyObject *_wrap_DataObject_GetAllFormats(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31986 PyObject *resultobj = 0;
31987 wxDataObject *arg1 = (wxDataObject *) 0 ;
31988 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
31989 PyObject *result = 0 ;
31990 void *argp1 = 0 ;
31991 int res1 = 0 ;
31992 int val2 ;
31993 int ecode2 = 0 ;
31994 PyObject * obj0 = 0 ;
31995 PyObject * obj1 = 0 ;
31996 char * kwnames[] = {
31997 (char *) "self",(char *) "dir", NULL
31998 };
31999
32000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) SWIG_fail;
32001 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32002 if (!SWIG_IsOK(res1)) {
32003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetAllFormats" "', expected argument " "1"" of type '" "wxDataObject *""'");
32004 }
32005 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32006 if (obj1) {
32007 ecode2 = SWIG_AsVal_int(obj1, &val2);
32008 if (!SWIG_IsOK(ecode2)) {
32009 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetAllFormats" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
32010 }
32011 arg2 = static_cast< wxDataObject::Direction >(val2);
32012 }
32013 {
32014 PyThreadState* __tstate = wxPyBeginAllowThreads();
32015 result = (PyObject *)wxDataObject_GetAllFormats(arg1,arg2);
32016 wxPyEndAllowThreads(__tstate);
32017 if (PyErr_Occurred()) SWIG_fail;
32018 }
32019 resultobj = result;
32020 return resultobj;
32021 fail:
32022 return NULL;
32023 }
32024
32025
32026 SWIGINTERN PyObject *_wrap_DataObject_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32027 PyObject *resultobj = 0;
32028 wxDataObject *arg1 = (wxDataObject *) 0 ;
32029 wxDataFormat *arg2 = 0 ;
32030 PyObject *result = 0 ;
32031 void *argp1 = 0 ;
32032 int res1 = 0 ;
32033 void *argp2 = 0 ;
32034 int res2 = 0 ;
32035 PyObject * obj0 = 0 ;
32036 PyObject * obj1 = 0 ;
32037 char * kwnames[] = {
32038 (char *) "self",(char *) "format", NULL
32039 };
32040
32041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) SWIG_fail;
32042 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32043 if (!SWIG_IsOK(res1)) {
32044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataHere" "', expected argument " "1"" of type '" "wxDataObject *""'");
32045 }
32046 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32047 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32048 if (!SWIG_IsOK(res2)) {
32049 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32050 }
32051 if (!argp2) {
32052 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32053 }
32054 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32055 {
32056 PyThreadState* __tstate = wxPyBeginAllowThreads();
32057 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
32058 wxPyEndAllowThreads(__tstate);
32059 if (PyErr_Occurred()) SWIG_fail;
32060 }
32061 resultobj = result;
32062 return resultobj;
32063 fail:
32064 return NULL;
32065 }
32066
32067
32068 SWIGINTERN PyObject *_wrap_DataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32069 PyObject *resultobj = 0;
32070 wxDataObject *arg1 = (wxDataObject *) 0 ;
32071 wxDataFormat *arg2 = 0 ;
32072 PyObject *arg3 = (PyObject *) 0 ;
32073 bool result;
32074 void *argp1 = 0 ;
32075 int res1 = 0 ;
32076 void *argp2 = 0 ;
32077 int res2 = 0 ;
32078 PyObject * obj0 = 0 ;
32079 PyObject * obj1 = 0 ;
32080 PyObject * obj2 = 0 ;
32081 char * kwnames[] = {
32082 (char *) "self",(char *) "format",(char *) "data", NULL
32083 };
32084
32085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32086 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32087 if (!SWIG_IsOK(res1)) {
32088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_SetData" "', expected argument " "1"" of type '" "wxDataObject *""'");
32089 }
32090 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32091 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32092 if (!SWIG_IsOK(res2)) {
32093 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32094 }
32095 if (!argp2) {
32096 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32097 }
32098 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32099 arg3 = obj2;
32100 {
32101 PyThreadState* __tstate = wxPyBeginAllowThreads();
32102 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
32103 wxPyEndAllowThreads(__tstate);
32104 if (PyErr_Occurred()) SWIG_fail;
32105 }
32106 {
32107 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32108 }
32109 return resultobj;
32110 fail:
32111 return NULL;
32112 }
32113
32114
32115 SWIGINTERN PyObject *DataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32116 PyObject *obj;
32117 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32118 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObject, SWIG_NewClientData(obj));
32119 return SWIG_Py_Void();
32120 }
32121
32122 SWIGINTERN PyObject *_wrap_new_DataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32123 PyObject *resultobj = 0;
32124 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
32125 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
32126 wxDataObjectSimple *result = 0 ;
32127 void *argp1 = 0 ;
32128 int res1 = 0 ;
32129 PyObject * obj0 = 0 ;
32130 char * kwnames[] = {
32131 (char *) "format", NULL
32132 };
32133
32134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) SWIG_fail;
32135 if (obj0) {
32136 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
32137 if (!SWIG_IsOK(res1)) {
32138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32139 }
32140 if (!argp1) {
32141 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32142 }
32143 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
32144 }
32145 {
32146 PyThreadState* __tstate = wxPyBeginAllowThreads();
32147 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
32148 wxPyEndAllowThreads(__tstate);
32149 if (PyErr_Occurred()) SWIG_fail;
32150 }
32151 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_NEW | 0 );
32152 return resultobj;
32153 fail:
32154 return NULL;
32155 }
32156
32157
32158 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32159 PyObject *resultobj = 0;
32160 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32161 wxDataFormat *result = 0 ;
32162 void *argp1 = 0 ;
32163 int res1 = 0 ;
32164 PyObject *swig_obj[1] ;
32165
32166 if (!args) SWIG_fail;
32167 swig_obj[0] = args;
32168 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32169 if (!SWIG_IsOK(res1)) {
32170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32171 }
32172 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32173 {
32174 PyThreadState* __tstate = wxPyBeginAllowThreads();
32175 {
32176 wxDataFormat const &_result_ref = (arg1)->GetFormat();
32177 result = (wxDataFormat *) &_result_ref;
32178 }
32179 wxPyEndAllowThreads(__tstate);
32180 if (PyErr_Occurred()) SWIG_fail;
32181 }
32182 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, 0 | 0 );
32183 return resultobj;
32184 fail:
32185 return NULL;
32186 }
32187
32188
32189 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32190 PyObject *resultobj = 0;
32191 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32192 wxDataFormat *arg2 = 0 ;
32193 void *argp1 = 0 ;
32194 int res1 = 0 ;
32195 void *argp2 = 0 ;
32196 int res2 = 0 ;
32197 PyObject * obj0 = 0 ;
32198 PyObject * obj1 = 0 ;
32199 char * kwnames[] = {
32200 (char *) "self",(char *) "format", NULL
32201 };
32202
32203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) SWIG_fail;
32204 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32205 if (!SWIG_IsOK(res1)) {
32206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32207 }
32208 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32209 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32210 if (!SWIG_IsOK(res2)) {
32211 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32212 }
32213 if (!argp2) {
32214 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32215 }
32216 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32217 {
32218 PyThreadState* __tstate = wxPyBeginAllowThreads();
32219 (arg1)->SetFormat((wxDataFormat const &)*arg2);
32220 wxPyEndAllowThreads(__tstate);
32221 if (PyErr_Occurred()) SWIG_fail;
32222 }
32223 resultobj = SWIG_Py_Void();
32224 return resultobj;
32225 fail:
32226 return NULL;
32227 }
32228
32229
32230 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32231 PyObject *resultobj = 0;
32232 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32233 size_t result;
32234 void *argp1 = 0 ;
32235 int res1 = 0 ;
32236 PyObject *swig_obj[1] ;
32237
32238 if (!args) SWIG_fail;
32239 swig_obj[0] = args;
32240 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32241 if (!SWIG_IsOK(res1)) {
32242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataSize" "', expected argument " "1"" of type '" "wxDataObjectSimple const *""'");
32243 }
32244 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32245 {
32246 PyThreadState* __tstate = wxPyBeginAllowThreads();
32247 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
32248 wxPyEndAllowThreads(__tstate);
32249 if (PyErr_Occurred()) SWIG_fail;
32250 }
32251 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32252 return resultobj;
32253 fail:
32254 return NULL;
32255 }
32256
32257
32258 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32259 PyObject *resultobj = 0;
32260 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32261 PyObject *result = 0 ;
32262 void *argp1 = 0 ;
32263 int res1 = 0 ;
32264 PyObject *swig_obj[1] ;
32265
32266 if (!args) SWIG_fail;
32267 swig_obj[0] = args;
32268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32269 if (!SWIG_IsOK(res1)) {
32270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataHere" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32271 }
32272 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32273 {
32274 PyThreadState* __tstate = wxPyBeginAllowThreads();
32275 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
32276 wxPyEndAllowThreads(__tstate);
32277 if (PyErr_Occurred()) SWIG_fail;
32278 }
32279 resultobj = result;
32280 return resultobj;
32281 fail:
32282 return NULL;
32283 }
32284
32285
32286 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32287 PyObject *resultobj = 0;
32288 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32289 PyObject *arg2 = (PyObject *) 0 ;
32290 bool result;
32291 void *argp1 = 0 ;
32292 int res1 = 0 ;
32293 PyObject * obj0 = 0 ;
32294 PyObject * obj1 = 0 ;
32295 char * kwnames[] = {
32296 (char *) "self",(char *) "data", NULL
32297 };
32298
32299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
32300 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32301 if (!SWIG_IsOK(res1)) {
32302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetData" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32303 }
32304 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32305 arg2 = obj1;
32306 {
32307 PyThreadState* __tstate = wxPyBeginAllowThreads();
32308 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
32309 wxPyEndAllowThreads(__tstate);
32310 if (PyErr_Occurred()) SWIG_fail;
32311 }
32312 {
32313 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32314 }
32315 return resultobj;
32316 fail:
32317 return NULL;
32318 }
32319
32320
32321 SWIGINTERN PyObject *DataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32322 PyObject *obj;
32323 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32324 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectSimple, SWIG_NewClientData(obj));
32325 return SWIG_Py_Void();
32326 }
32327
32328 SWIGINTERN PyObject *DataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32329 return SWIG_Python_InitShadowInstance(args);
32330 }
32331
32332 SWIGINTERN PyObject *_wrap_new_PyDataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32333 PyObject *resultobj = 0;
32334 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
32335 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
32336 wxPyDataObjectSimple *result = 0 ;
32337 void *argp1 = 0 ;
32338 int res1 = 0 ;
32339 PyObject * obj0 = 0 ;
32340 char * kwnames[] = {
32341 (char *) "format", NULL
32342 };
32343
32344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) SWIG_fail;
32345 if (obj0) {
32346 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
32347 if (!SWIG_IsOK(res1)) {
32348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32349 }
32350 if (!argp1) {
32351 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32352 }
32353 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
32354 }
32355 {
32356 PyThreadState* __tstate = wxPyBeginAllowThreads();
32357 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
32358 wxPyEndAllowThreads(__tstate);
32359 if (PyErr_Occurred()) SWIG_fail;
32360 }
32361 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_NEW | 0 );
32362 return resultobj;
32363 fail:
32364 return NULL;
32365 }
32366
32367
32368 SWIGINTERN PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32369 PyObject *resultobj = 0;
32370 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
32371 PyObject *arg2 = (PyObject *) 0 ;
32372 PyObject *arg3 = (PyObject *) 0 ;
32373 void *argp1 = 0 ;
32374 int res1 = 0 ;
32375 PyObject * obj0 = 0 ;
32376 PyObject * obj1 = 0 ;
32377 PyObject * obj2 = 0 ;
32378 char * kwnames[] = {
32379 (char *) "self",(char *) "self",(char *) "_class", NULL
32380 };
32381
32382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32383 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDataObjectSimple, 0 | 0 );
32384 if (!SWIG_IsOK(res1)) {
32385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyDataObjectSimple__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDataObjectSimple *""'");
32386 }
32387 arg1 = reinterpret_cast< wxPyDataObjectSimple * >(argp1);
32388 arg2 = obj1;
32389 arg3 = obj2;
32390 {
32391 PyThreadState* __tstate = wxPyBeginAllowThreads();
32392 (arg1)->_setCallbackInfo(arg2,arg3);
32393 wxPyEndAllowThreads(__tstate);
32394 if (PyErr_Occurred()) SWIG_fail;
32395 }
32396 resultobj = SWIG_Py_Void();
32397 return resultobj;
32398 fail:
32399 return NULL;
32400 }
32401
32402
32403 SWIGINTERN PyObject *PyDataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32404 PyObject *obj;
32405 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32406 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDataObjectSimple, SWIG_NewClientData(obj));
32407 return SWIG_Py_Void();
32408 }
32409
32410 SWIGINTERN PyObject *PyDataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32411 return SWIG_Python_InitShadowInstance(args);
32412 }
32413
32414 SWIGINTERN PyObject *_wrap_new_DataObjectComposite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32415 PyObject *resultobj = 0;
32416 wxDataObjectComposite *result = 0 ;
32417
32418 if (!SWIG_Python_UnpackTuple(args,"new_DataObjectComposite",0,0,0)) SWIG_fail;
32419 {
32420 PyThreadState* __tstate = wxPyBeginAllowThreads();
32421 result = (wxDataObjectComposite *)new wxDataObjectComposite();
32422 wxPyEndAllowThreads(__tstate);
32423 if (PyErr_Occurred()) SWIG_fail;
32424 }
32425 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_NEW | 0 );
32426 return resultobj;
32427 fail:
32428 return NULL;
32429 }
32430
32431
32432 SWIGINTERN PyObject *_wrap_DataObjectComposite_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32433 PyObject *resultobj = 0;
32434 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
32435 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
32436 bool arg3 = (bool) false ;
32437 void *argp1 = 0 ;
32438 int res1 = 0 ;
32439 int res2 = 0 ;
32440 bool val3 ;
32441 int ecode3 = 0 ;
32442 PyObject * obj0 = 0 ;
32443 PyObject * obj1 = 0 ;
32444 PyObject * obj2 = 0 ;
32445 char * kwnames[] = {
32446 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
32447 };
32448
32449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32450 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
32451 if (!SWIG_IsOK(res1)) {
32452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_Add" "', expected argument " "1"" of type '" "wxDataObjectComposite *""'");
32453 }
32454 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
32455 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_DISOWN | 0 );
32456 if (!SWIG_IsOK(res2)) {
32457 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectComposite_Add" "', expected argument " "2"" of type '" "wxDataObjectSimple *""'");
32458 }
32459 if (obj2) {
32460 ecode3 = SWIG_AsVal_bool(obj2, &val3);
32461 if (!SWIG_IsOK(ecode3)) {
32462 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObjectComposite_Add" "', expected argument " "3"" of type '" "bool""'");
32463 }
32464 arg3 = static_cast< bool >(val3);
32465 }
32466 {
32467 PyThreadState* __tstate = wxPyBeginAllowThreads();
32468 (arg1)->Add(arg2,arg3);
32469 wxPyEndAllowThreads(__tstate);
32470 if (PyErr_Occurred()) SWIG_fail;
32471 }
32472 resultobj = SWIG_Py_Void();
32473 return resultobj;
32474 fail:
32475 return NULL;
32476 }
32477
32478
32479 SWIGINTERN PyObject *_wrap_DataObjectComposite_GetReceivedFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32480 PyObject *resultobj = 0;
32481 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
32482 SwigValueWrapper<wxDataFormat > result;
32483 void *argp1 = 0 ;
32484 int res1 = 0 ;
32485 PyObject *swig_obj[1] ;
32486
32487 if (!args) SWIG_fail;
32488 swig_obj[0] = args;
32489 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
32490 if (!SWIG_IsOK(res1)) {
32491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_GetReceivedFormat" "', expected argument " "1"" of type '" "wxDataObjectComposite const *""'");
32492 }
32493 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
32494 {
32495 PyThreadState* __tstate = wxPyBeginAllowThreads();
32496 result = ((wxDataObjectComposite const *)arg1)->GetReceivedFormat();
32497 wxPyEndAllowThreads(__tstate);
32498 if (PyErr_Occurred()) SWIG_fail;
32499 }
32500 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
32501 return resultobj;
32502 fail:
32503 return NULL;
32504 }
32505
32506
32507 SWIGINTERN PyObject *DataObjectComposite_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32508 PyObject *obj;
32509 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32510 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectComposite, SWIG_NewClientData(obj));
32511 return SWIG_Py_Void();
32512 }
32513
32514 SWIGINTERN PyObject *DataObjectComposite_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32515 return SWIG_Python_InitShadowInstance(args);
32516 }
32517
32518 SWIGINTERN PyObject *_wrap_new_TextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32519 PyObject *resultobj = 0;
32520 wxString const &arg1_defvalue = wxPyEmptyString ;
32521 wxString *arg1 = (wxString *) &arg1_defvalue ;
32522 wxTextDataObject *result = 0 ;
32523 bool temp1 = false ;
32524 PyObject * obj0 = 0 ;
32525 char * kwnames[] = {
32526 (char *) "text", NULL
32527 };
32528
32529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) SWIG_fail;
32530 if (obj0) {
32531 {
32532 arg1 = wxString_in_helper(obj0);
32533 if (arg1 == NULL) SWIG_fail;
32534 temp1 = true;
32535 }
32536 }
32537 {
32538 PyThreadState* __tstate = wxPyBeginAllowThreads();
32539 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
32540 wxPyEndAllowThreads(__tstate);
32541 if (PyErr_Occurred()) SWIG_fail;
32542 }
32543 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_NEW | 0 );
32544 {
32545 if (temp1)
32546 delete arg1;
32547 }
32548 return resultobj;
32549 fail:
32550 {
32551 if (temp1)
32552 delete arg1;
32553 }
32554 return NULL;
32555 }
32556
32557
32558 SWIGINTERN PyObject *_wrap_TextDataObject_GetTextLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32559 PyObject *resultobj = 0;
32560 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32561 size_t result;
32562 void *argp1 = 0 ;
32563 int res1 = 0 ;
32564 PyObject *swig_obj[1] ;
32565
32566 if (!args) SWIG_fail;
32567 swig_obj[0] = args;
32568 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32569 if (!SWIG_IsOK(res1)) {
32570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetTextLength" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32571 }
32572 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32573 {
32574 PyThreadState* __tstate = wxPyBeginAllowThreads();
32575 result = (size_t)(arg1)->GetTextLength();
32576 wxPyEndAllowThreads(__tstate);
32577 if (PyErr_Occurred()) SWIG_fail;
32578 }
32579 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32580 return resultobj;
32581 fail:
32582 return NULL;
32583 }
32584
32585
32586 SWIGINTERN PyObject *_wrap_TextDataObject_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32587 PyObject *resultobj = 0;
32588 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32589 wxString result;
32590 void *argp1 = 0 ;
32591 int res1 = 0 ;
32592 PyObject *swig_obj[1] ;
32593
32594 if (!args) SWIG_fail;
32595 swig_obj[0] = args;
32596 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32597 if (!SWIG_IsOK(res1)) {
32598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32599 }
32600 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32601 {
32602 PyThreadState* __tstate = wxPyBeginAllowThreads();
32603 result = (arg1)->GetText();
32604 wxPyEndAllowThreads(__tstate);
32605 if (PyErr_Occurred()) SWIG_fail;
32606 }
32607 {
32608 #if wxUSE_UNICODE
32609 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32610 #else
32611 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32612 #endif
32613 }
32614 return resultobj;
32615 fail:
32616 return NULL;
32617 }
32618
32619
32620 SWIGINTERN PyObject *_wrap_TextDataObject_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32621 PyObject *resultobj = 0;
32622 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32623 wxString *arg2 = 0 ;
32624 void *argp1 = 0 ;
32625 int res1 = 0 ;
32626 bool temp2 = false ;
32627 PyObject * obj0 = 0 ;
32628 PyObject * obj1 = 0 ;
32629 char * kwnames[] = {
32630 (char *) "self",(char *) "text", NULL
32631 };
32632
32633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
32634 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32635 if (!SWIG_IsOK(res1)) {
32636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_SetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32637 }
32638 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32639 {
32640 arg2 = wxString_in_helper(obj1);
32641 if (arg2 == NULL) SWIG_fail;
32642 temp2 = true;
32643 }
32644 {
32645 PyThreadState* __tstate = wxPyBeginAllowThreads();
32646 (arg1)->SetText((wxString const &)*arg2);
32647 wxPyEndAllowThreads(__tstate);
32648 if (PyErr_Occurred()) SWIG_fail;
32649 }
32650 resultobj = SWIG_Py_Void();
32651 {
32652 if (temp2)
32653 delete arg2;
32654 }
32655 return resultobj;
32656 fail:
32657 {
32658 if (temp2)
32659 delete arg2;
32660 }
32661 return NULL;
32662 }
32663
32664
32665 SWIGINTERN PyObject *TextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32666 PyObject *obj;
32667 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32668 SWIG_TypeNewClientData(SWIGTYPE_p_wxTextDataObject, SWIG_NewClientData(obj));
32669 return SWIG_Py_Void();
32670 }
32671
32672 SWIGINTERN PyObject *TextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32673 return SWIG_Python_InitShadowInstance(args);
32674 }
32675
32676 SWIGINTERN PyObject *_wrap_new_PyTextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32677 PyObject *resultobj = 0;
32678 wxString const &arg1_defvalue = wxPyEmptyString ;
32679 wxString *arg1 = (wxString *) &arg1_defvalue ;
32680 wxPyTextDataObject *result = 0 ;
32681 bool temp1 = false ;
32682 PyObject * obj0 = 0 ;
32683 char * kwnames[] = {
32684 (char *) "text", NULL
32685 };
32686
32687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) SWIG_fail;
32688 if (obj0) {
32689 {
32690 arg1 = wxString_in_helper(obj0);
32691 if (arg1 == NULL) SWIG_fail;
32692 temp1 = true;
32693 }
32694 }
32695 {
32696 PyThreadState* __tstate = wxPyBeginAllowThreads();
32697 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
32698 wxPyEndAllowThreads(__tstate);
32699 if (PyErr_Occurred()) SWIG_fail;
32700 }
32701 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_NEW | 0 );
32702 {
32703 if (temp1)
32704 delete arg1;
32705 }
32706 return resultobj;
32707 fail:
32708 {
32709 if (temp1)
32710 delete arg1;
32711 }
32712 return NULL;
32713 }
32714
32715
32716 SWIGINTERN PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32717 PyObject *resultobj = 0;
32718 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
32719 PyObject *arg2 = (PyObject *) 0 ;
32720 PyObject *arg3 = (PyObject *) 0 ;
32721 void *argp1 = 0 ;
32722 int res1 = 0 ;
32723 PyObject * obj0 = 0 ;
32724 PyObject * obj1 = 0 ;
32725 PyObject * obj2 = 0 ;
32726 char * kwnames[] = {
32727 (char *) "self",(char *) "self",(char *) "_class", NULL
32728 };
32729
32730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32731 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDataObject, 0 | 0 );
32732 if (!SWIG_IsOK(res1)) {
32733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTextDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDataObject *""'");
32734 }
32735 arg1 = reinterpret_cast< wxPyTextDataObject * >(argp1);
32736 arg2 = obj1;
32737 arg3 = obj2;
32738 {
32739 PyThreadState* __tstate = wxPyBeginAllowThreads();
32740 (arg1)->_setCallbackInfo(arg2,arg3);
32741 wxPyEndAllowThreads(__tstate);
32742 if (PyErr_Occurred()) SWIG_fail;
32743 }
32744 resultobj = SWIG_Py_Void();
32745 return resultobj;
32746 fail:
32747 return NULL;
32748 }
32749
32750
32751 SWIGINTERN PyObject *PyTextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32752 PyObject *obj;
32753 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32754 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDataObject, SWIG_NewClientData(obj));
32755 return SWIG_Py_Void();
32756 }
32757
32758 SWIGINTERN PyObject *PyTextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32759 return SWIG_Python_InitShadowInstance(args);
32760 }
32761
32762 SWIGINTERN PyObject *_wrap_new_BitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32763 PyObject *resultobj = 0;
32764 wxBitmap const &arg1_defvalue = wxNullBitmap ;
32765 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
32766 wxBitmapDataObject *result = 0 ;
32767 void *argp1 = 0 ;
32768 int res1 = 0 ;
32769 PyObject * obj0 = 0 ;
32770 char * kwnames[] = {
32771 (char *) "bitmap", NULL
32772 };
32773
32774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) SWIG_fail;
32775 if (obj0) {
32776 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
32777 if (!SWIG_IsOK(res1)) {
32778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
32779 }
32780 if (!argp1) {
32781 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
32782 }
32783 arg1 = reinterpret_cast< wxBitmap * >(argp1);
32784 }
32785 {
32786 PyThreadState* __tstate = wxPyBeginAllowThreads();
32787 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
32788 wxPyEndAllowThreads(__tstate);
32789 if (PyErr_Occurred()) SWIG_fail;
32790 }
32791 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_NEW | 0 );
32792 return resultobj;
32793 fail:
32794 return NULL;
32795 }
32796
32797
32798 SWIGINTERN PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32799 PyObject *resultobj = 0;
32800 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
32801 wxBitmap result;
32802 void *argp1 = 0 ;
32803 int res1 = 0 ;
32804 PyObject *swig_obj[1] ;
32805
32806 if (!args) SWIG_fail;
32807 swig_obj[0] = args;
32808 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
32809 if (!SWIG_IsOK(res1)) {
32810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_GetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject const *""'");
32811 }
32812 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
32813 {
32814 PyThreadState* __tstate = wxPyBeginAllowThreads();
32815 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
32816 wxPyEndAllowThreads(__tstate);
32817 if (PyErr_Occurred()) SWIG_fail;
32818 }
32819 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
32820 return resultobj;
32821 fail:
32822 return NULL;
32823 }
32824
32825
32826 SWIGINTERN PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32827 PyObject *resultobj = 0;
32828 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
32829 wxBitmap *arg2 = 0 ;
32830 void *argp1 = 0 ;
32831 int res1 = 0 ;
32832 void *argp2 = 0 ;
32833 int res2 = 0 ;
32834 PyObject * obj0 = 0 ;
32835 PyObject * obj1 = 0 ;
32836 char * kwnames[] = {
32837 (char *) "self",(char *) "bitmap", NULL
32838 };
32839
32840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
32841 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
32842 if (!SWIG_IsOK(res1)) {
32843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject *""'");
32844 }
32845 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
32846 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
32847 if (!SWIG_IsOK(res2)) {
32848 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
32849 }
32850 if (!argp2) {
32851 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
32852 }
32853 arg2 = reinterpret_cast< wxBitmap * >(argp2);
32854 {
32855 PyThreadState* __tstate = wxPyBeginAllowThreads();
32856 (arg1)->SetBitmap((wxBitmap const &)*arg2);
32857 wxPyEndAllowThreads(__tstate);
32858 if (PyErr_Occurred()) SWIG_fail;
32859 }
32860 resultobj = SWIG_Py_Void();
32861 return resultobj;
32862 fail:
32863 return NULL;
32864 }
32865
32866
32867 SWIGINTERN PyObject *BitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32868 PyObject *obj;
32869 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32870 SWIG_TypeNewClientData(SWIGTYPE_p_wxBitmapDataObject, SWIG_NewClientData(obj));
32871 return SWIG_Py_Void();
32872 }
32873
32874 SWIGINTERN PyObject *BitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32875 return SWIG_Python_InitShadowInstance(args);
32876 }
32877
32878 SWIGINTERN PyObject *_wrap_new_PyBitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32879 PyObject *resultobj = 0;
32880 wxBitmap const &arg1_defvalue = wxNullBitmap ;
32881 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
32882 wxPyBitmapDataObject *result = 0 ;
32883 void *argp1 = 0 ;
32884 int res1 = 0 ;
32885 PyObject * obj0 = 0 ;
32886 char * kwnames[] = {
32887 (char *) "bitmap", NULL
32888 };
32889
32890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) SWIG_fail;
32891 if (obj0) {
32892 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
32893 if (!SWIG_IsOK(res1)) {
32894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
32895 }
32896 if (!argp1) {
32897 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
32898 }
32899 arg1 = reinterpret_cast< wxBitmap * >(argp1);
32900 }
32901 {
32902 PyThreadState* __tstate = wxPyBeginAllowThreads();
32903 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
32904 wxPyEndAllowThreads(__tstate);
32905 if (PyErr_Occurred()) SWIG_fail;
32906 }
32907 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_NEW | 0 );
32908 return resultobj;
32909 fail:
32910 return NULL;
32911 }
32912
32913
32914 SWIGINTERN PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32915 PyObject *resultobj = 0;
32916 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
32917 PyObject *arg2 = (PyObject *) 0 ;
32918 PyObject *arg3 = (PyObject *) 0 ;
32919 void *argp1 = 0 ;
32920 int res1 = 0 ;
32921 PyObject * obj0 = 0 ;
32922 PyObject * obj1 = 0 ;
32923 PyObject * obj2 = 0 ;
32924 char * kwnames[] = {
32925 (char *) "self",(char *) "self",(char *) "_class", NULL
32926 };
32927
32928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyBitmapDataObject, 0 | 0 );
32930 if (!SWIG_IsOK(res1)) {
32931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyBitmapDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyBitmapDataObject *""'");
32932 }
32933 arg1 = reinterpret_cast< wxPyBitmapDataObject * >(argp1);
32934 arg2 = obj1;
32935 arg3 = obj2;
32936 {
32937 PyThreadState* __tstate = wxPyBeginAllowThreads();
32938 (arg1)->_setCallbackInfo(arg2,arg3);
32939 wxPyEndAllowThreads(__tstate);
32940 if (PyErr_Occurred()) SWIG_fail;
32941 }
32942 resultobj = SWIG_Py_Void();
32943 return resultobj;
32944 fail:
32945 return NULL;
32946 }
32947
32948
32949 SWIGINTERN PyObject *PyBitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32950 PyObject *obj;
32951 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32952 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyBitmapDataObject, SWIG_NewClientData(obj));
32953 return SWIG_Py_Void();
32954 }
32955
32956 SWIGINTERN PyObject *PyBitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32957 return SWIG_Python_InitShadowInstance(args);
32958 }
32959
32960 SWIGINTERN PyObject *_wrap_new_FileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32961 PyObject *resultobj = 0;
32962 wxFileDataObject *result = 0 ;
32963
32964 if (!SWIG_Python_UnpackTuple(args,"new_FileDataObject",0,0,0)) SWIG_fail;
32965 {
32966 PyThreadState* __tstate = wxPyBeginAllowThreads();
32967 result = (wxFileDataObject *)new wxFileDataObject();
32968 wxPyEndAllowThreads(__tstate);
32969 if (PyErr_Occurred()) SWIG_fail;
32970 }
32971 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_NEW | 0 );
32972 return resultobj;
32973 fail:
32974 return NULL;
32975 }
32976
32977
32978 SWIGINTERN PyObject *_wrap_FileDataObject_GetFilenames(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32979 PyObject *resultobj = 0;
32980 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
32981 wxArrayString *result = 0 ;
32982 void *argp1 = 0 ;
32983 int res1 = 0 ;
32984 PyObject *swig_obj[1] ;
32985
32986 if (!args) SWIG_fail;
32987 swig_obj[0] = args;
32988 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
32989 if (!SWIG_IsOK(res1)) {
32990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_GetFilenames" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
32991 }
32992 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
32993 {
32994 PyThreadState* __tstate = wxPyBeginAllowThreads();
32995 {
32996 wxArrayString const &_result_ref = (arg1)->GetFilenames();
32997 result = (wxArrayString *) &_result_ref;
32998 }
32999 wxPyEndAllowThreads(__tstate);
33000 if (PyErr_Occurred()) SWIG_fail;
33001 }
33002 {
33003 resultobj = wxArrayString2PyList_helper(*result);
33004 }
33005 return resultobj;
33006 fail:
33007 return NULL;
33008 }
33009
33010
33011 SWIGINTERN PyObject *_wrap_FileDataObject_AddFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33012 PyObject *resultobj = 0;
33013 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
33014 wxString *arg2 = 0 ;
33015 void *argp1 = 0 ;
33016 int res1 = 0 ;
33017 bool temp2 = false ;
33018 PyObject * obj0 = 0 ;
33019 PyObject * obj1 = 0 ;
33020 char * kwnames[] = {
33021 (char *) "self",(char *) "filename", NULL
33022 };
33023
33024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) SWIG_fail;
33025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
33026 if (!SWIG_IsOK(res1)) {
33027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_AddFile" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
33028 }
33029 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
33030 {
33031 arg2 = wxString_in_helper(obj1);
33032 if (arg2 == NULL) SWIG_fail;
33033 temp2 = true;
33034 }
33035 {
33036 PyThreadState* __tstate = wxPyBeginAllowThreads();
33037 (arg1)->AddFile((wxString const &)*arg2);
33038 wxPyEndAllowThreads(__tstate);
33039 if (PyErr_Occurred()) SWIG_fail;
33040 }
33041 resultobj = SWIG_Py_Void();
33042 {
33043 if (temp2)
33044 delete arg2;
33045 }
33046 return resultobj;
33047 fail:
33048 {
33049 if (temp2)
33050 delete arg2;
33051 }
33052 return NULL;
33053 }
33054
33055
33056 SWIGINTERN PyObject *FileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33057 PyObject *obj;
33058 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33059 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileDataObject, SWIG_NewClientData(obj));
33060 return SWIG_Py_Void();
33061 }
33062
33063 SWIGINTERN PyObject *FileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33064 return SWIG_Python_InitShadowInstance(args);
33065 }
33066
33067 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
33068 PyObject *resultobj = 0;
33069 wxDataFormat *arg1 = 0 ;
33070 wxCustomDataObject *result = 0 ;
33071 void *argp1 = 0 ;
33072 int res1 = 0 ;
33073
33074 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
33075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
33076 if (!SWIG_IsOK(res1)) {
33077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
33078 }
33079 if (!argp1) {
33080 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
33081 }
33082 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
33083 {
33084 PyThreadState* __tstate = wxPyBeginAllowThreads();
33085 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
33086 wxPyEndAllowThreads(__tstate);
33087 if (PyErr_Occurred()) SWIG_fail;
33088 }
33089 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33090 return resultobj;
33091 fail:
33092 return NULL;
33093 }
33094
33095
33096 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
33097 PyObject *resultobj = 0;
33098 wxString *arg1 = 0 ;
33099 wxCustomDataObject *result = 0 ;
33100 bool temp1 = false ;
33101
33102 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
33103 {
33104 arg1 = wxString_in_helper(swig_obj[0]);
33105 if (arg1 == NULL) SWIG_fail;
33106 temp1 = true;
33107 }
33108 {
33109 PyThreadState* __tstate = wxPyBeginAllowThreads();
33110 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
33111 wxPyEndAllowThreads(__tstate);
33112 if (PyErr_Occurred()) SWIG_fail;
33113 }
33114 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33115 {
33116 if (temp1)
33117 delete arg1;
33118 }
33119 return resultobj;
33120 fail:
33121 {
33122 if (temp1)
33123 delete arg1;
33124 }
33125 return NULL;
33126 }
33127
33128
33129 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
33130 PyObject *resultobj = 0;
33131 wxCustomDataObject *result = 0 ;
33132
33133 if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
33134 {
33135 PyThreadState* __tstate = wxPyBeginAllowThreads();
33136 result = (wxCustomDataObject *)new wxCustomDataObject();
33137 wxPyEndAllowThreads(__tstate);
33138 if (PyErr_Occurred()) SWIG_fail;
33139 }
33140 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33141 return resultobj;
33142 fail:
33143 return NULL;
33144 }
33145
33146
33147 SWIGINTERN PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
33148 int argc;
33149 PyObject *argv[2];
33150
33151 if (!(argc = SWIG_Python_UnpackTuple(args,"new_CustomDataObject",0,1,argv))) SWIG_fail;
33152 --argc;
33153 if (argc == 0) {
33154 return _wrap_new_CustomDataObject__SWIG_2(self, argc, argv);
33155 }
33156 if (argc == 1) {
33157 int _v = 0;
33158 {
33159 {
33160 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
33161 }
33162 }
33163 if (!_v) goto check_2;
33164 return _wrap_new_CustomDataObject__SWIG_1(self, argc, argv);
33165 }
33166 check_2:
33167
33168 if (argc == 1) {
33169 return _wrap_new_CustomDataObject__SWIG_0(self, argc, argv);
33170 }
33171
33172 fail:
33173 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
33174 return NULL;
33175 }
33176
33177
33178 SWIGINTERN PyObject *_wrap_CustomDataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33179 PyObject *resultobj = 0;
33180 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33181 PyObject *arg2 = (PyObject *) 0 ;
33182 bool result;
33183 void *argp1 = 0 ;
33184 int res1 = 0 ;
33185 PyObject * obj0 = 0 ;
33186 PyObject * obj1 = 0 ;
33187 char * kwnames[] = {
33188 (char *) "self",(char *) "data", NULL
33189 };
33190
33191 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
33192 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33193 if (!SWIG_IsOK(res1)) {
33194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_SetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33195 }
33196 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33197 arg2 = obj1;
33198 {
33199 PyThreadState* __tstate = wxPyBeginAllowThreads();
33200 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
33201 wxPyEndAllowThreads(__tstate);
33202 if (PyErr_Occurred()) SWIG_fail;
33203 }
33204 {
33205 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33206 }
33207 return resultobj;
33208 fail:
33209 return NULL;
33210 }
33211
33212
33213 SWIGINTERN PyObject *_wrap_CustomDataObject_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33214 PyObject *resultobj = 0;
33215 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33216 size_t result;
33217 void *argp1 = 0 ;
33218 int res1 = 0 ;
33219 PyObject *swig_obj[1] ;
33220
33221 if (!args) SWIG_fail;
33222 swig_obj[0] = args;
33223 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33224 if (!SWIG_IsOK(res1)) {
33225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetSize" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33226 }
33227 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33228 {
33229 PyThreadState* __tstate = wxPyBeginAllowThreads();
33230 result = (size_t)(arg1)->GetSize();
33231 wxPyEndAllowThreads(__tstate);
33232 if (PyErr_Occurred()) SWIG_fail;
33233 }
33234 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
33235 return resultobj;
33236 fail:
33237 return NULL;
33238 }
33239
33240
33241 SWIGINTERN PyObject *_wrap_CustomDataObject_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33242 PyObject *resultobj = 0;
33243 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33244 PyObject *result = 0 ;
33245 void *argp1 = 0 ;
33246 int res1 = 0 ;
33247 PyObject *swig_obj[1] ;
33248
33249 if (!args) SWIG_fail;
33250 swig_obj[0] = args;
33251 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33252 if (!SWIG_IsOK(res1)) {
33253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33254 }
33255 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33256 {
33257 PyThreadState* __tstate = wxPyBeginAllowThreads();
33258 result = (PyObject *)wxCustomDataObject_GetData(arg1);
33259 wxPyEndAllowThreads(__tstate);
33260 if (PyErr_Occurred()) SWIG_fail;
33261 }
33262 resultobj = result;
33263 return resultobj;
33264 fail:
33265 return NULL;
33266 }
33267
33268
33269 SWIGINTERN PyObject *CustomDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33270 PyObject *obj;
33271 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33272 SWIG_TypeNewClientData(SWIGTYPE_p_wxCustomDataObject, SWIG_NewClientData(obj));
33273 return SWIG_Py_Void();
33274 }
33275
33276 SWIGINTERN PyObject *CustomDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33277 return SWIG_Python_InitShadowInstance(args);
33278 }
33279
33280 SWIGINTERN PyObject *_wrap_new_URLDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33281 PyObject *resultobj = 0;
33282 wxString const &arg1_defvalue = wxPyEmptyString ;
33283 wxString *arg1 = (wxString *) &arg1_defvalue ;
33284 wxURLDataObject *result = 0 ;
33285 bool temp1 = false ;
33286 PyObject * obj0 = 0 ;
33287 char * kwnames[] = {
33288 (char *) "url", NULL
33289 };
33290
33291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_URLDataObject",kwnames,&obj0)) SWIG_fail;
33292 if (obj0) {
33293 {
33294 arg1 = wxString_in_helper(obj0);
33295 if (arg1 == NULL) SWIG_fail;
33296 temp1 = true;
33297 }
33298 }
33299 {
33300 PyThreadState* __tstate = wxPyBeginAllowThreads();
33301 result = (wxURLDataObject *)new wxURLDataObject((wxString const &)*arg1);
33302 wxPyEndAllowThreads(__tstate);
33303 if (PyErr_Occurred()) SWIG_fail;
33304 }
33305 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_NEW | 0 );
33306 {
33307 if (temp1)
33308 delete arg1;
33309 }
33310 return resultobj;
33311 fail:
33312 {
33313 if (temp1)
33314 delete arg1;
33315 }
33316 return NULL;
33317 }
33318
33319
33320 SWIGINTERN PyObject *_wrap_URLDataObject_GetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33321 PyObject *resultobj = 0;
33322 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
33323 wxString result;
33324 void *argp1 = 0 ;
33325 int res1 = 0 ;
33326 PyObject *swig_obj[1] ;
33327
33328 if (!args) SWIG_fail;
33329 swig_obj[0] = args;
33330 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
33331 if (!SWIG_IsOK(res1)) {
33332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_GetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
33333 }
33334 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
33335 {
33336 PyThreadState* __tstate = wxPyBeginAllowThreads();
33337 result = (arg1)->GetURL();
33338 wxPyEndAllowThreads(__tstate);
33339 if (PyErr_Occurred()) SWIG_fail;
33340 }
33341 {
33342 #if wxUSE_UNICODE
33343 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33344 #else
33345 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33346 #endif
33347 }
33348 return resultobj;
33349 fail:
33350 return NULL;
33351 }
33352
33353
33354 SWIGINTERN PyObject *_wrap_URLDataObject_SetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33355 PyObject *resultobj = 0;
33356 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
33357 wxString *arg2 = 0 ;
33358 void *argp1 = 0 ;
33359 int res1 = 0 ;
33360 bool temp2 = false ;
33361 PyObject * obj0 = 0 ;
33362 PyObject * obj1 = 0 ;
33363 char * kwnames[] = {
33364 (char *) "self",(char *) "url", NULL
33365 };
33366
33367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) SWIG_fail;
33368 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
33369 if (!SWIG_IsOK(res1)) {
33370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_SetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
33371 }
33372 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
33373 {
33374 arg2 = wxString_in_helper(obj1);
33375 if (arg2 == NULL) SWIG_fail;
33376 temp2 = true;
33377 }
33378 {
33379 PyThreadState* __tstate = wxPyBeginAllowThreads();
33380 (arg1)->SetURL((wxString const &)*arg2);
33381 wxPyEndAllowThreads(__tstate);
33382 if (PyErr_Occurred()) SWIG_fail;
33383 }
33384 resultobj = SWIG_Py_Void();
33385 {
33386 if (temp2)
33387 delete arg2;
33388 }
33389 return resultobj;
33390 fail:
33391 {
33392 if (temp2)
33393 delete arg2;
33394 }
33395 return NULL;
33396 }
33397
33398
33399 SWIGINTERN PyObject *URLDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33400 PyObject *obj;
33401 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33402 SWIG_TypeNewClientData(SWIGTYPE_p_wxURLDataObject, SWIG_NewClientData(obj));
33403 return SWIG_Py_Void();
33404 }
33405
33406 SWIGINTERN PyObject *URLDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33407 return SWIG_Python_InitShadowInstance(args);
33408 }
33409
33410 SWIGINTERN PyObject *_wrap_new_MetafileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33411 PyObject *resultobj = 0;
33412 wxMetafileDataObject *result = 0 ;
33413
33414 if (!SWIG_Python_UnpackTuple(args,"new_MetafileDataObject",0,0,0)) SWIG_fail;
33415 {
33416 PyThreadState* __tstate = wxPyBeginAllowThreads();
33417 result = (wxMetafileDataObject *)new wxMetafileDataObject();
33418 wxPyEndAllowThreads(__tstate);
33419 if (PyErr_Occurred()) SWIG_fail;
33420 }
33421 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_NEW | 0 );
33422 return resultobj;
33423 fail:
33424 return NULL;
33425 }
33426
33427
33428 SWIGINTERN PyObject *_wrap_MetafileDataObject_SetMetafile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33429 PyObject *resultobj = 0;
33430 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
33431 wxMetafile *arg2 = 0 ;
33432 void *argp1 = 0 ;
33433 int res1 = 0 ;
33434 void *argp2 = 0 ;
33435 int res2 = 0 ;
33436 PyObject * obj0 = 0 ;
33437 PyObject * obj1 = 0 ;
33438 char * kwnames[] = {
33439 (char *) "self",(char *) "metafile", NULL
33440 };
33441
33442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MetafileDataObject_SetMetafile",kwnames,&obj0,&obj1)) SWIG_fail;
33443 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMetafileDataObject, 0 | 0 );
33444 if (!SWIG_IsOK(res1)) {
33445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetafileDataObject_SetMetafile" "', expected argument " "1"" of type '" "wxMetafileDataObject *""'");
33446 }
33447 arg1 = reinterpret_cast< wxMetafileDataObject * >(argp1);
33448 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxMetafile, 0 | 0);
33449 if (!SWIG_IsOK(res2)) {
33450 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MetafileDataObject_SetMetafile" "', expected argument " "2"" of type '" "wxMetafile const &""'");
33451 }
33452 if (!argp2) {
33453 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MetafileDataObject_SetMetafile" "', expected argument " "2"" of type '" "wxMetafile const &""'");
33454 }
33455 arg2 = reinterpret_cast< wxMetafile * >(argp2);
33456 {
33457 PyThreadState* __tstate = wxPyBeginAllowThreads();
33458 (arg1)->SetMetafile((wxMetafile const &)*arg2);
33459 wxPyEndAllowThreads(__tstate);
33460 if (PyErr_Occurred()) SWIG_fail;
33461 }
33462 resultobj = SWIG_Py_Void();
33463 return resultobj;
33464 fail:
33465 return NULL;
33466 }
33467
33468
33469 SWIGINTERN PyObject *_wrap_MetafileDataObject_GetMetafile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33470 PyObject *resultobj = 0;
33471 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
33472 wxMetafile result;
33473 void *argp1 = 0 ;
33474 int res1 = 0 ;
33475 PyObject *swig_obj[1] ;
33476
33477 if (!args) SWIG_fail;
33478 swig_obj[0] = args;
33479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMetafileDataObject, 0 | 0 );
33480 if (!SWIG_IsOK(res1)) {
33481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetafileDataObject_GetMetafile" "', expected argument " "1"" of type '" "wxMetafileDataObject const *""'");
33482 }
33483 arg1 = reinterpret_cast< wxMetafileDataObject * >(argp1);
33484 {
33485 PyThreadState* __tstate = wxPyBeginAllowThreads();
33486 result = ((wxMetafileDataObject const *)arg1)->GetMetafile();
33487 wxPyEndAllowThreads(__tstate);
33488 if (PyErr_Occurred()) SWIG_fail;
33489 }
33490 resultobj = SWIG_NewPointerObj((new wxMetafile(static_cast< const wxMetafile& >(result))), SWIGTYPE_p_wxMetafile, SWIG_POINTER_OWN | 0 );
33491 return resultobj;
33492 fail:
33493 return NULL;
33494 }
33495
33496
33497 SWIGINTERN PyObject *MetafileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33498 PyObject *obj;
33499 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33500 SWIG_TypeNewClientData(SWIGTYPE_p_wxMetafileDataObject, SWIG_NewClientData(obj));
33501 return SWIG_Py_Void();
33502 }
33503
33504 SWIGINTERN PyObject *MetafileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33505 return SWIG_Python_InitShadowInstance(args);
33506 }
33507
33508 SWIGINTERN PyObject *_wrap_IsDragResultOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33509 PyObject *resultobj = 0;
33510 wxDragResult arg1 ;
33511 bool result;
33512 int val1 ;
33513 int ecode1 = 0 ;
33514 PyObject * obj0 = 0 ;
33515 char * kwnames[] = {
33516 (char *) "res", NULL
33517 };
33518
33519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) SWIG_fail;
33520 ecode1 = SWIG_AsVal_int(obj0, &val1);
33521 if (!SWIG_IsOK(ecode1)) {
33522 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsDragResultOk" "', expected argument " "1"" of type '" "wxDragResult""'");
33523 }
33524 arg1 = static_cast< wxDragResult >(val1);
33525 {
33526 PyThreadState* __tstate = wxPyBeginAllowThreads();
33527 result = (bool)wxIsDragResultOk(arg1);
33528 wxPyEndAllowThreads(__tstate);
33529 if (PyErr_Occurred()) SWIG_fail;
33530 }
33531 {
33532 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33533 }
33534 return resultobj;
33535 fail:
33536 return NULL;
33537 }
33538
33539
33540 SWIGINTERN PyObject *_wrap_new_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33541 PyObject *resultobj = 0;
33542 wxWindow *arg1 = (wxWindow *) 0 ;
33543 wxCursor const &arg2_defvalue = wxNullCursor ;
33544 wxCursor *arg2 = (wxCursor *) &arg2_defvalue ;
33545 wxCursor const &arg3_defvalue = wxNullCursor ;
33546 wxCursor *arg3 = (wxCursor *) &arg3_defvalue ;
33547 wxCursor const &arg4_defvalue = wxNullCursor ;
33548 wxCursor *arg4 = (wxCursor *) &arg4_defvalue ;
33549 wxPyDropSource *result = 0 ;
33550 void *argp1 = 0 ;
33551 int res1 = 0 ;
33552 void *argp2 = 0 ;
33553 int res2 = 0 ;
33554 void *argp3 = 0 ;
33555 int res3 = 0 ;
33556 void *argp4 = 0 ;
33557 int res4 = 0 ;
33558 PyObject * obj0 = 0 ;
33559 PyObject * obj1 = 0 ;
33560 PyObject * obj2 = 0 ;
33561 PyObject * obj3 = 0 ;
33562 char * kwnames[] = {
33563 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
33564 };
33565
33566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33567 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33568 if (!SWIG_IsOK(res1)) {
33569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropSource" "', expected argument " "1"" of type '" "wxWindow *""'");
33570 }
33571 arg1 = reinterpret_cast< wxWindow * >(argp1);
33572 if (obj1) {
33573 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
33574 if (!SWIG_IsOK(res2)) {
33575 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxCursor const &""'");
33576 }
33577 if (!argp2) {
33578 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxCursor const &""'");
33579 }
33580 arg2 = reinterpret_cast< wxCursor * >(argp2);
33581 }
33582 if (obj2) {
33583 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxCursor, 0 | 0);
33584 if (!SWIG_IsOK(res3)) {
33585 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxCursor const &""'");
33586 }
33587 if (!argp3) {
33588 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxCursor const &""'");
33589 }
33590 arg3 = reinterpret_cast< wxCursor * >(argp3);
33591 }
33592 if (obj3) {
33593 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxCursor, 0 | 0);
33594 if (!SWIG_IsOK(res4)) {
33595 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxCursor const &""'");
33596 }
33597 if (!argp4) {
33598 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxCursor const &""'");
33599 }
33600 arg4 = reinterpret_cast< wxCursor * >(argp4);
33601 }
33602 {
33603 PyThreadState* __tstate = wxPyBeginAllowThreads();
33604 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxCursor const &)*arg2,(wxCursor const &)*arg3,(wxCursor const &)*arg4);
33605 wxPyEndAllowThreads(__tstate);
33606 if (PyErr_Occurred()) SWIG_fail;
33607 }
33608 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_NEW | 0 );
33609 return resultobj;
33610 fail:
33611 return NULL;
33612 }
33613
33614
33615 SWIGINTERN PyObject *_wrap_DropSource__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33616 PyObject *resultobj = 0;
33617 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33618 PyObject *arg2 = (PyObject *) 0 ;
33619 PyObject *arg3 = (PyObject *) 0 ;
33620 int arg4 ;
33621 void *argp1 = 0 ;
33622 int res1 = 0 ;
33623 int val4 ;
33624 int ecode4 = 0 ;
33625 PyObject * obj0 = 0 ;
33626 PyObject * obj1 = 0 ;
33627 PyObject * obj2 = 0 ;
33628 PyObject * obj3 = 0 ;
33629 char * kwnames[] = {
33630 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
33631 };
33632
33633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33634 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33635 if (!SWIG_IsOK(res1)) {
33636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33637 }
33638 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33639 arg2 = obj1;
33640 arg3 = obj2;
33641 ecode4 = SWIG_AsVal_int(obj3, &val4);
33642 if (!SWIG_IsOK(ecode4)) {
33643 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropSource__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
33644 }
33645 arg4 = static_cast< int >(val4);
33646 {
33647 PyThreadState* __tstate = wxPyBeginAllowThreads();
33648 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
33649 wxPyEndAllowThreads(__tstate);
33650 if (PyErr_Occurred()) SWIG_fail;
33651 }
33652 resultobj = SWIG_Py_Void();
33653 return resultobj;
33654 fail:
33655 return NULL;
33656 }
33657
33658
33659 SWIGINTERN PyObject *_wrap_delete_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33660 PyObject *resultobj = 0;
33661 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33662 void *argp1 = 0 ;
33663 int res1 = 0 ;
33664 PyObject *swig_obj[1] ;
33665
33666 if (!args) SWIG_fail;
33667 swig_obj[0] = args;
33668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_DISOWN | 0 );
33669 if (!SWIG_IsOK(res1)) {
33670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropSource" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33671 }
33672 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33673 {
33674 PyThreadState* __tstate = wxPyBeginAllowThreads();
33675 delete arg1;
33676
33677 wxPyEndAllowThreads(__tstate);
33678 if (PyErr_Occurred()) SWIG_fail;
33679 }
33680 resultobj = SWIG_Py_Void();
33681 return resultobj;
33682 fail:
33683 return NULL;
33684 }
33685
33686
33687 SWIGINTERN PyObject *_wrap_DropSource_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33688 PyObject *resultobj = 0;
33689 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33690 wxDataObject *arg2 = 0 ;
33691 void *argp1 = 0 ;
33692 int res1 = 0 ;
33693 void *argp2 = 0 ;
33694 int res2 = 0 ;
33695 PyObject * obj0 = 0 ;
33696 PyObject * obj1 = 0 ;
33697 char * kwnames[] = {
33698 (char *) "self",(char *) "data", NULL
33699 };
33700
33701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
33702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33703 if (!SWIG_IsOK(res1)) {
33704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetData" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33705 }
33706 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33707 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
33708 if (!SWIG_IsOK(res2)) {
33709 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
33710 }
33711 if (!argp2) {
33712 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
33713 }
33714 arg2 = reinterpret_cast< wxDataObject * >(argp2);
33715 {
33716 PyThreadState* __tstate = wxPyBeginAllowThreads();
33717 (arg1)->SetData(*arg2);
33718 wxPyEndAllowThreads(__tstate);
33719 if (PyErr_Occurred()) SWIG_fail;
33720 }
33721 resultobj = SWIG_Py_Void();
33722 return resultobj;
33723 fail:
33724 return NULL;
33725 }
33726
33727
33728 SWIGINTERN PyObject *_wrap_DropSource_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33729 PyObject *resultobj = 0;
33730 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33731 wxDataObject *result = 0 ;
33732 void *argp1 = 0 ;
33733 int res1 = 0 ;
33734 PyObject *swig_obj[1] ;
33735
33736 if (!args) SWIG_fail;
33737 swig_obj[0] = args;
33738 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33739 if (!SWIG_IsOK(res1)) {
33740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33741 }
33742 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33743 {
33744 PyThreadState* __tstate = wxPyBeginAllowThreads();
33745 result = (wxDataObject *)(arg1)->GetDataObject();
33746 wxPyEndAllowThreads(__tstate);
33747 if (PyErr_Occurred()) SWIG_fail;
33748 }
33749 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
33750 return resultobj;
33751 fail:
33752 return NULL;
33753 }
33754
33755
33756 SWIGINTERN PyObject *_wrap_DropSource_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33757 PyObject *resultobj = 0;
33758 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33759 wxDragResult arg2 ;
33760 wxCursor *arg3 = 0 ;
33761 void *argp1 = 0 ;
33762 int res1 = 0 ;
33763 int val2 ;
33764 int ecode2 = 0 ;
33765 void *argp3 = 0 ;
33766 int res3 = 0 ;
33767 PyObject * obj0 = 0 ;
33768 PyObject * obj1 = 0 ;
33769 PyObject * obj2 = 0 ;
33770 char * kwnames[] = {
33771 (char *) "self",(char *) "res",(char *) "cursor", NULL
33772 };
33773
33774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33775 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33776 if (!SWIG_IsOK(res1)) {
33777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetCursor" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33778 }
33779 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33780 ecode2 = SWIG_AsVal_int(obj1, &val2);
33781 if (!SWIG_IsOK(ecode2)) {
33782 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_SetCursor" "', expected argument " "2"" of type '" "wxDragResult""'");
33783 }
33784 arg2 = static_cast< wxDragResult >(val2);
33785 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxCursor, 0 | 0);
33786 if (!SWIG_IsOK(res3)) {
33787 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
33788 }
33789 if (!argp3) {
33790 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
33791 }
33792 arg3 = reinterpret_cast< wxCursor * >(argp3);
33793 {
33794 PyThreadState* __tstate = wxPyBeginAllowThreads();
33795 (arg1)->SetCursor(arg2,(wxCursor const &)*arg3);
33796 wxPyEndAllowThreads(__tstate);
33797 if (PyErr_Occurred()) SWIG_fail;
33798 }
33799 resultobj = SWIG_Py_Void();
33800 return resultobj;
33801 fail:
33802 return NULL;
33803 }
33804
33805
33806 SWIGINTERN PyObject *_wrap_DropSource_DoDragDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33807 PyObject *resultobj = 0;
33808 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33809 int arg2 = (int) wxDrag_CopyOnly ;
33810 wxDragResult result;
33811 void *argp1 = 0 ;
33812 int res1 = 0 ;
33813 int val2 ;
33814 int ecode2 = 0 ;
33815 PyObject * obj0 = 0 ;
33816 PyObject * obj1 = 0 ;
33817 char * kwnames[] = {
33818 (char *) "self",(char *) "flags", NULL
33819 };
33820
33821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) SWIG_fail;
33822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33823 if (!SWIG_IsOK(res1)) {
33824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_DoDragDrop" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33825 }
33826 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33827 if (obj1) {
33828 ecode2 = SWIG_AsVal_int(obj1, &val2);
33829 if (!SWIG_IsOK(ecode2)) {
33830 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_DoDragDrop" "', expected argument " "2"" of type '" "int""'");
33831 }
33832 arg2 = static_cast< int >(val2);
33833 }
33834 {
33835 PyThreadState* __tstate = wxPyBeginAllowThreads();
33836 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
33837 wxPyEndAllowThreads(__tstate);
33838 if (PyErr_Occurred()) SWIG_fail;
33839 }
33840 resultobj = SWIG_From_int(static_cast< int >(result));
33841 return resultobj;
33842 fail:
33843 return NULL;
33844 }
33845
33846
33847 SWIGINTERN PyObject *_wrap_DropSource_GiveFeedback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33848 PyObject *resultobj = 0;
33849 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33850 wxDragResult arg2 ;
33851 bool result;
33852 void *argp1 = 0 ;
33853 int res1 = 0 ;
33854 int val2 ;
33855 int ecode2 = 0 ;
33856 PyObject * obj0 = 0 ;
33857 PyObject * obj1 = 0 ;
33858 char * kwnames[] = {
33859 (char *) "self",(char *) "effect", NULL
33860 };
33861
33862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_GiveFeedback",kwnames,&obj0,&obj1)) SWIG_fail;
33863 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33864 if (!SWIG_IsOK(res1)) {
33865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GiveFeedback" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33866 }
33867 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33868 ecode2 = SWIG_AsVal_int(obj1, &val2);
33869 if (!SWIG_IsOK(ecode2)) {
33870 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_GiveFeedback" "', expected argument " "2"" of type '" "wxDragResult""'");
33871 }
33872 arg2 = static_cast< wxDragResult >(val2);
33873 {
33874 PyThreadState* __tstate = wxPyBeginAllowThreads();
33875 result = (bool)(arg1)->GiveFeedback(arg2);
33876 wxPyEndAllowThreads(__tstate);
33877 if (PyErr_Occurred()) SWIG_fail;
33878 }
33879 {
33880 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33881 }
33882 return resultobj;
33883 fail:
33884 return NULL;
33885 }
33886
33887
33888 SWIGINTERN PyObject *DropSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33889 PyObject *obj;
33890 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33891 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropSource, SWIG_NewClientData(obj));
33892 return SWIG_Py_Void();
33893 }
33894
33895 SWIGINTERN PyObject *DropSource_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33896 return SWIG_Python_InitShadowInstance(args);
33897 }
33898
33899 SWIGINTERN PyObject *_wrap_new_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33900 PyObject *resultobj = 0;
33901 wxDataObject *arg1 = (wxDataObject *) NULL ;
33902 wxPyDropTarget *result = 0 ;
33903 int res1 = 0 ;
33904 PyObject * obj0 = 0 ;
33905 char * kwnames[] = {
33906 (char *) "dataObject", NULL
33907 };
33908
33909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) SWIG_fail;
33910 if (obj0) {
33911 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
33912 if (!SWIG_IsOK(res1)) {
33913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropTarget" "', expected argument " "1"" of type '" "wxDataObject *""'");
33914 }
33915 }
33916 {
33917 PyThreadState* __tstate = wxPyBeginAllowThreads();
33918 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
33919 wxPyEndAllowThreads(__tstate);
33920 if (PyErr_Occurred()) SWIG_fail;
33921 }
33922 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_NEW | 0 );
33923 return resultobj;
33924 fail:
33925 return NULL;
33926 }
33927
33928
33929 SWIGINTERN PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33930 PyObject *resultobj = 0;
33931 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33932 PyObject *arg2 = (PyObject *) 0 ;
33933 PyObject *arg3 = (PyObject *) 0 ;
33934 void *argp1 = 0 ;
33935 int res1 = 0 ;
33936 PyObject * obj0 = 0 ;
33937 PyObject * obj1 = 0 ;
33938 PyObject * obj2 = 0 ;
33939 char * kwnames[] = {
33940 (char *) "self",(char *) "self",(char *) "_class", NULL
33941 };
33942
33943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33945 if (!SWIG_IsOK(res1)) {
33946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33947 }
33948 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33949 arg2 = obj1;
33950 arg3 = obj2;
33951 {
33952 PyThreadState* __tstate = wxPyBeginAllowThreads();
33953 (arg1)->_setCallbackInfo(arg2,arg3);
33954 wxPyEndAllowThreads(__tstate);
33955 if (PyErr_Occurred()) SWIG_fail;
33956 }
33957 resultobj = SWIG_Py_Void();
33958 return resultobj;
33959 fail:
33960 return NULL;
33961 }
33962
33963
33964 SWIGINTERN PyObject *_wrap_delete_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33965 PyObject *resultobj = 0;
33966 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33967 void *argp1 = 0 ;
33968 int res1 = 0 ;
33969 PyObject *swig_obj[1] ;
33970
33971 if (!args) SWIG_fail;
33972 swig_obj[0] = args;
33973 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
33974 if (!SWIG_IsOK(res1)) {
33975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropTarget" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33976 }
33977 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33978 {
33979 PyThreadState* __tstate = wxPyBeginAllowThreads();
33980 delete arg1;
33981
33982 wxPyEndAllowThreads(__tstate);
33983 if (PyErr_Occurred()) SWIG_fail;
33984 }
33985 resultobj = SWIG_Py_Void();
33986 return resultobj;
33987 fail:
33988 return NULL;
33989 }
33990
33991
33992 SWIGINTERN PyObject *_wrap_DropTarget_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33993 PyObject *resultobj = 0;
33994 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33995 wxDataObject *result = 0 ;
33996 void *argp1 = 0 ;
33997 int res1 = 0 ;
33998 PyObject *swig_obj[1] ;
33999
34000 if (!args) SWIG_fail;
34001 swig_obj[0] = args;
34002 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34003 if (!SWIG_IsOK(res1)) {
34004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34005 }
34006 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34007 {
34008 PyThreadState* __tstate = wxPyBeginAllowThreads();
34009 result = (wxDataObject *)(arg1)->GetDataObject();
34010 wxPyEndAllowThreads(__tstate);
34011 if (PyErr_Occurred()) SWIG_fail;
34012 }
34013 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
34014 return resultobj;
34015 fail:
34016 return NULL;
34017 }
34018
34019
34020 SWIGINTERN PyObject *_wrap_DropTarget_SetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34021 PyObject *resultobj = 0;
34022 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34023 wxDataObject *arg2 = (wxDataObject *) 0 ;
34024 void *argp1 = 0 ;
34025 int res1 = 0 ;
34026 int res2 = 0 ;
34027 PyObject * obj0 = 0 ;
34028 PyObject * obj1 = 0 ;
34029 char * kwnames[] = {
34030 (char *) "self",(char *) "dataObject", NULL
34031 };
34032
34033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) SWIG_fail;
34034 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34035 if (!SWIG_IsOK(res1)) {
34036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34037 }
34038 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34039 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34040 if (!SWIG_IsOK(res2)) {
34041 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropTarget_SetDataObject" "', expected argument " "2"" of type '" "wxDataObject *""'");
34042 }
34043 {
34044 PyThreadState* __tstate = wxPyBeginAllowThreads();
34045 (arg1)->SetDataObject(arg2);
34046 wxPyEndAllowThreads(__tstate);
34047 if (PyErr_Occurred()) SWIG_fail;
34048 }
34049 resultobj = SWIG_Py_Void();
34050 return resultobj;
34051 fail:
34052 return NULL;
34053 }
34054
34055
34056 SWIGINTERN PyObject *_wrap_DropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34057 PyObject *resultobj = 0;
34058 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34059 int arg2 ;
34060 int arg3 ;
34061 wxDragResult arg4 ;
34062 wxDragResult result;
34063 void *argp1 = 0 ;
34064 int res1 = 0 ;
34065 int val2 ;
34066 int ecode2 = 0 ;
34067 int val3 ;
34068 int ecode3 = 0 ;
34069 int val4 ;
34070 int ecode4 = 0 ;
34071 PyObject * obj0 = 0 ;
34072 PyObject * obj1 = 0 ;
34073 PyObject * obj2 = 0 ;
34074 PyObject * obj3 = 0 ;
34075 char * kwnames[] = {
34076 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34077 };
34078
34079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34080 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34081 if (!SWIG_IsOK(res1)) {
34082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34083 }
34084 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34085 ecode2 = SWIG_AsVal_int(obj1, &val2);
34086 if (!SWIG_IsOK(ecode2)) {
34087 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
34088 }
34089 arg2 = static_cast< int >(val2);
34090 ecode3 = SWIG_AsVal_int(obj2, &val3);
34091 if (!SWIG_IsOK(ecode3)) {
34092 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
34093 }
34094 arg3 = static_cast< int >(val3);
34095 ecode4 = SWIG_AsVal_int(obj3, &val4);
34096 if (!SWIG_IsOK(ecode4)) {
34097 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
34098 }
34099 arg4 = static_cast< wxDragResult >(val4);
34100 {
34101 PyThreadState* __tstate = wxPyBeginAllowThreads();
34102 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
34103 wxPyEndAllowThreads(__tstate);
34104 if (PyErr_Occurred()) SWIG_fail;
34105 }
34106 resultobj = SWIG_From_int(static_cast< int >(result));
34107 return resultobj;
34108 fail:
34109 return NULL;
34110 }
34111
34112
34113 SWIGINTERN PyObject *_wrap_DropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34114 PyObject *resultobj = 0;
34115 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34116 int arg2 ;
34117 int arg3 ;
34118 wxDragResult arg4 ;
34119 wxDragResult result;
34120 void *argp1 = 0 ;
34121 int res1 = 0 ;
34122 int val2 ;
34123 int ecode2 = 0 ;
34124 int val3 ;
34125 int ecode3 = 0 ;
34126 int val4 ;
34127 int ecode4 = 0 ;
34128 PyObject * obj0 = 0 ;
34129 PyObject * obj1 = 0 ;
34130 PyObject * obj2 = 0 ;
34131 PyObject * obj3 = 0 ;
34132 char * kwnames[] = {
34133 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34134 };
34135
34136 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34137 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34138 if (!SWIG_IsOK(res1)) {
34139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34140 }
34141 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34142 ecode2 = SWIG_AsVal_int(obj1, &val2);
34143 if (!SWIG_IsOK(ecode2)) {
34144 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
34145 }
34146 arg2 = static_cast< int >(val2);
34147 ecode3 = SWIG_AsVal_int(obj2, &val3);
34148 if (!SWIG_IsOK(ecode3)) {
34149 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
34150 }
34151 arg3 = static_cast< int >(val3);
34152 ecode4 = SWIG_AsVal_int(obj3, &val4);
34153 if (!SWIG_IsOK(ecode4)) {
34154 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
34155 }
34156 arg4 = static_cast< wxDragResult >(val4);
34157 {
34158 PyThreadState* __tstate = wxPyBeginAllowThreads();
34159 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
34160 wxPyEndAllowThreads(__tstate);
34161 if (PyErr_Occurred()) SWIG_fail;
34162 }
34163 resultobj = SWIG_From_int(static_cast< int >(result));
34164 return resultobj;
34165 fail:
34166 return NULL;
34167 }
34168
34169
34170 SWIGINTERN PyObject *_wrap_DropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34171 PyObject *resultobj = 0;
34172 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34173 void *argp1 = 0 ;
34174 int res1 = 0 ;
34175 PyObject *swig_obj[1] ;
34176
34177 if (!args) SWIG_fail;
34178 swig_obj[0] = args;
34179 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34180 if (!SWIG_IsOK(res1)) {
34181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34182 }
34183 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34184 {
34185 PyThreadState* __tstate = wxPyBeginAllowThreads();
34186 (arg1)->OnLeave();
34187 wxPyEndAllowThreads(__tstate);
34188 if (PyErr_Occurred()) SWIG_fail;
34189 }
34190 resultobj = SWIG_Py_Void();
34191 return resultobj;
34192 fail:
34193 return NULL;
34194 }
34195
34196
34197 SWIGINTERN PyObject *_wrap_DropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34198 PyObject *resultobj = 0;
34199 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34200 int arg2 ;
34201 int arg3 ;
34202 bool result;
34203 void *argp1 = 0 ;
34204 int res1 = 0 ;
34205 int val2 ;
34206 int ecode2 = 0 ;
34207 int val3 ;
34208 int ecode3 = 0 ;
34209 PyObject * obj0 = 0 ;
34210 PyObject * obj1 = 0 ;
34211 PyObject * obj2 = 0 ;
34212 char * kwnames[] = {
34213 (char *) "self",(char *) "x",(char *) "y", NULL
34214 };
34215
34216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34218 if (!SWIG_IsOK(res1)) {
34219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34220 }
34221 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34222 ecode2 = SWIG_AsVal_int(obj1, &val2);
34223 if (!SWIG_IsOK(ecode2)) {
34224 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
34225 }
34226 arg2 = static_cast< int >(val2);
34227 ecode3 = SWIG_AsVal_int(obj2, &val3);
34228 if (!SWIG_IsOK(ecode3)) {
34229 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
34230 }
34231 arg3 = static_cast< int >(val3);
34232 {
34233 PyThreadState* __tstate = wxPyBeginAllowThreads();
34234 result = (bool)(arg1)->OnDrop(arg2,arg3);
34235 wxPyEndAllowThreads(__tstate);
34236 if (PyErr_Occurred()) SWIG_fail;
34237 }
34238 {
34239 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34240 }
34241 return resultobj;
34242 fail:
34243 return NULL;
34244 }
34245
34246
34247 SWIGINTERN PyObject *_wrap_DropTarget_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34248 PyObject *resultobj = 0;
34249 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34250 bool result;
34251 void *argp1 = 0 ;
34252 int res1 = 0 ;
34253 PyObject *swig_obj[1] ;
34254
34255 if (!args) SWIG_fail;
34256 swig_obj[0] = args;
34257 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34258 if (!SWIG_IsOK(res1)) {
34259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetData" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34260 }
34261 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34262 {
34263 PyThreadState* __tstate = wxPyBeginAllowThreads();
34264 result = (bool)(arg1)->GetData();
34265 wxPyEndAllowThreads(__tstate);
34266 if (PyErr_Occurred()) SWIG_fail;
34267 }
34268 {
34269 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34270 }
34271 return resultobj;
34272 fail:
34273 return NULL;
34274 }
34275
34276
34277 SWIGINTERN PyObject *_wrap_DropTarget_SetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34278 PyObject *resultobj = 0;
34279 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34280 wxDragResult arg2 ;
34281 void *argp1 = 0 ;
34282 int res1 = 0 ;
34283 int val2 ;
34284 int ecode2 = 0 ;
34285 PyObject * obj0 = 0 ;
34286 PyObject * obj1 = 0 ;
34287 char * kwnames[] = {
34288 (char *) "self",(char *) "action", NULL
34289 };
34290
34291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDefaultAction",kwnames,&obj0,&obj1)) SWIG_fail;
34292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34293 if (!SWIG_IsOK(res1)) {
34294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34295 }
34296 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34297 ecode2 = SWIG_AsVal_int(obj1, &val2);
34298 if (!SWIG_IsOK(ecode2)) {
34299 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "2"" of type '" "wxDragResult""'");
34300 }
34301 arg2 = static_cast< wxDragResult >(val2);
34302 {
34303 PyThreadState* __tstate = wxPyBeginAllowThreads();
34304 (arg1)->SetDefaultAction(arg2);
34305 wxPyEndAllowThreads(__tstate);
34306 if (PyErr_Occurred()) SWIG_fail;
34307 }
34308 resultobj = SWIG_Py_Void();
34309 return resultobj;
34310 fail:
34311 return NULL;
34312 }
34313
34314
34315 SWIGINTERN PyObject *_wrap_DropTarget_GetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34316 PyObject *resultobj = 0;
34317 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34318 wxDragResult result;
34319 void *argp1 = 0 ;
34320 int res1 = 0 ;
34321 PyObject *swig_obj[1] ;
34322
34323 if (!args) SWIG_fail;
34324 swig_obj[0] = args;
34325 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34326 if (!SWIG_IsOK(res1)) {
34327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34328 }
34329 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34330 {
34331 PyThreadState* __tstate = wxPyBeginAllowThreads();
34332 result = (wxDragResult)(arg1)->GetDefaultAction();
34333 wxPyEndAllowThreads(__tstate);
34334 if (PyErr_Occurred()) SWIG_fail;
34335 }
34336 resultobj = SWIG_From_int(static_cast< int >(result));
34337 return resultobj;
34338 fail:
34339 return NULL;
34340 }
34341
34342
34343 SWIGINTERN PyObject *DropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34344 PyObject *obj;
34345 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34346 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropTarget, SWIG_NewClientData(obj));
34347 return SWIG_Py_Void();
34348 }
34349
34350 SWIGINTERN PyObject *DropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34351 return SWIG_Python_InitShadowInstance(args);
34352 }
34353
34354 SWIGINTERN PyObject *_wrap_new_TextDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34355 PyObject *resultobj = 0;
34356 wxPyTextDropTarget *result = 0 ;
34357
34358 if (!SWIG_Python_UnpackTuple(args,"new_TextDropTarget",0,0,0)) SWIG_fail;
34359 {
34360 PyThreadState* __tstate = wxPyBeginAllowThreads();
34361 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
34362 wxPyEndAllowThreads(__tstate);
34363 if (PyErr_Occurred()) SWIG_fail;
34364 }
34365 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_NEW | 0 );
34366 return resultobj;
34367 fail:
34368 return NULL;
34369 }
34370
34371
34372 SWIGINTERN PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34373 PyObject *resultobj = 0;
34374 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34375 PyObject *arg2 = (PyObject *) 0 ;
34376 PyObject *arg3 = (PyObject *) 0 ;
34377 void *argp1 = 0 ;
34378 int res1 = 0 ;
34379 PyObject * obj0 = 0 ;
34380 PyObject * obj1 = 0 ;
34381 PyObject * obj2 = 0 ;
34382 char * kwnames[] = {
34383 (char *) "self",(char *) "self",(char *) "_class", NULL
34384 };
34385
34386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34387 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34388 if (!SWIG_IsOK(res1)) {
34389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34390 }
34391 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34392 arg2 = obj1;
34393 arg3 = obj2;
34394 {
34395 PyThreadState* __tstate = wxPyBeginAllowThreads();
34396 (arg1)->_setCallbackInfo(arg2,arg3);
34397 wxPyEndAllowThreads(__tstate);
34398 if (PyErr_Occurred()) SWIG_fail;
34399 }
34400 resultobj = SWIG_Py_Void();
34401 return resultobj;
34402 fail:
34403 return NULL;
34404 }
34405
34406
34407 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDropText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34408 PyObject *resultobj = 0;
34409 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34410 int arg2 ;
34411 int arg3 ;
34412 wxString *arg4 = 0 ;
34413 bool result;
34414 void *argp1 = 0 ;
34415 int res1 = 0 ;
34416 int val2 ;
34417 int ecode2 = 0 ;
34418 int val3 ;
34419 int ecode3 = 0 ;
34420 bool temp4 = false ;
34421 PyObject * obj0 = 0 ;
34422 PyObject * obj1 = 0 ;
34423 PyObject * obj2 = 0 ;
34424 PyObject * obj3 = 0 ;
34425 char * kwnames[] = {
34426 (char *) "self",(char *) "x",(char *) "y",(char *) "text", NULL
34427 };
34428
34429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDropText",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34430 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34431 if (!SWIG_IsOK(res1)) {
34432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDropText" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34433 }
34434 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34435 ecode2 = SWIG_AsVal_int(obj1, &val2);
34436 if (!SWIG_IsOK(ecode2)) {
34437 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDropText" "', expected argument " "2"" of type '" "int""'");
34438 }
34439 arg2 = static_cast< int >(val2);
34440 ecode3 = SWIG_AsVal_int(obj2, &val3);
34441 if (!SWIG_IsOK(ecode3)) {
34442 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDropText" "', expected argument " "3"" of type '" "int""'");
34443 }
34444 arg3 = static_cast< int >(val3);
34445 {
34446 arg4 = wxString_in_helper(obj3);
34447 if (arg4 == NULL) SWIG_fail;
34448 temp4 = true;
34449 }
34450 {
34451 PyThreadState* __tstate = wxPyBeginAllowThreads();
34452 result = (bool)(arg1)->OnDropText(arg2,arg3,(wxString const &)*arg4);
34453 wxPyEndAllowThreads(__tstate);
34454 if (PyErr_Occurred()) SWIG_fail;
34455 }
34456 {
34457 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34458 }
34459 {
34460 if (temp4)
34461 delete arg4;
34462 }
34463 return resultobj;
34464 fail:
34465 {
34466 if (temp4)
34467 delete arg4;
34468 }
34469 return NULL;
34470 }
34471
34472
34473 SWIGINTERN PyObject *_wrap_TextDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34474 PyObject *resultobj = 0;
34475 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34476 int arg2 ;
34477 int arg3 ;
34478 wxDragResult arg4 ;
34479 wxDragResult result;
34480 void *argp1 = 0 ;
34481 int res1 = 0 ;
34482 int val2 ;
34483 int ecode2 = 0 ;
34484 int val3 ;
34485 int ecode3 = 0 ;
34486 int val4 ;
34487 int ecode4 = 0 ;
34488 PyObject * obj0 = 0 ;
34489 PyObject * obj1 = 0 ;
34490 PyObject * obj2 = 0 ;
34491 PyObject * obj3 = 0 ;
34492 char * kwnames[] = {
34493 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34494 };
34495
34496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34497 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34498 if (!SWIG_IsOK(res1)) {
34499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34500 }
34501 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34502 ecode2 = SWIG_AsVal_int(obj1, &val2);
34503 if (!SWIG_IsOK(ecode2)) {
34504 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
34505 }
34506 arg2 = static_cast< int >(val2);
34507 ecode3 = SWIG_AsVal_int(obj2, &val3);
34508 if (!SWIG_IsOK(ecode3)) {
34509 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
34510 }
34511 arg3 = static_cast< int >(val3);
34512 ecode4 = SWIG_AsVal_int(obj3, &val4);
34513 if (!SWIG_IsOK(ecode4)) {
34514 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
34515 }
34516 arg4 = static_cast< wxDragResult >(val4);
34517 {
34518 PyThreadState* __tstate = wxPyBeginAllowThreads();
34519 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
34520 wxPyEndAllowThreads(__tstate);
34521 if (PyErr_Occurred()) SWIG_fail;
34522 }
34523 resultobj = SWIG_From_int(static_cast< int >(result));
34524 return resultobj;
34525 fail:
34526 return NULL;
34527 }
34528
34529
34530 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34531 PyObject *resultobj = 0;
34532 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34533 int arg2 ;
34534 int arg3 ;
34535 wxDragResult arg4 ;
34536 wxDragResult result;
34537 void *argp1 = 0 ;
34538 int res1 = 0 ;
34539 int val2 ;
34540 int ecode2 = 0 ;
34541 int val3 ;
34542 int ecode3 = 0 ;
34543 int val4 ;
34544 int ecode4 = 0 ;
34545 PyObject * obj0 = 0 ;
34546 PyObject * obj1 = 0 ;
34547 PyObject * obj2 = 0 ;
34548 PyObject * obj3 = 0 ;
34549 char * kwnames[] = {
34550 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34551 };
34552
34553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34554 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34555 if (!SWIG_IsOK(res1)) {
34556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34557 }
34558 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34559 ecode2 = SWIG_AsVal_int(obj1, &val2);
34560 if (!SWIG_IsOK(ecode2)) {
34561 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
34562 }
34563 arg2 = static_cast< int >(val2);
34564 ecode3 = SWIG_AsVal_int(obj2, &val3);
34565 if (!SWIG_IsOK(ecode3)) {
34566 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
34567 }
34568 arg3 = static_cast< int >(val3);
34569 ecode4 = SWIG_AsVal_int(obj3, &val4);
34570 if (!SWIG_IsOK(ecode4)) {
34571 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
34572 }
34573 arg4 = static_cast< wxDragResult >(val4);
34574 {
34575 PyThreadState* __tstate = wxPyBeginAllowThreads();
34576 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
34577 wxPyEndAllowThreads(__tstate);
34578 if (PyErr_Occurred()) SWIG_fail;
34579 }
34580 resultobj = SWIG_From_int(static_cast< int >(result));
34581 return resultobj;
34582 fail:
34583 return NULL;
34584 }
34585
34586
34587 SWIGINTERN PyObject *_wrap_TextDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34588 PyObject *resultobj = 0;
34589 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34590 void *argp1 = 0 ;
34591 int res1 = 0 ;
34592 PyObject *swig_obj[1] ;
34593
34594 if (!args) SWIG_fail;
34595 swig_obj[0] = args;
34596 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34597 if (!SWIG_IsOK(res1)) {
34598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34599 }
34600 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34601 {
34602 PyThreadState* __tstate = wxPyBeginAllowThreads();
34603 (arg1)->OnLeave();
34604 wxPyEndAllowThreads(__tstate);
34605 if (PyErr_Occurred()) SWIG_fail;
34606 }
34607 resultobj = SWIG_Py_Void();
34608 return resultobj;
34609 fail:
34610 return NULL;
34611 }
34612
34613
34614 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34615 PyObject *resultobj = 0;
34616 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34617 int arg2 ;
34618 int arg3 ;
34619 bool result;
34620 void *argp1 = 0 ;
34621 int res1 = 0 ;
34622 int val2 ;
34623 int ecode2 = 0 ;
34624 int val3 ;
34625 int ecode3 = 0 ;
34626 PyObject * obj0 = 0 ;
34627 PyObject * obj1 = 0 ;
34628 PyObject * obj2 = 0 ;
34629 char * kwnames[] = {
34630 (char *) "self",(char *) "x",(char *) "y", NULL
34631 };
34632
34633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34634 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34635 if (!SWIG_IsOK(res1)) {
34636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34637 }
34638 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34639 ecode2 = SWIG_AsVal_int(obj1, &val2);
34640 if (!SWIG_IsOK(ecode2)) {
34641 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
34642 }
34643 arg2 = static_cast< int >(val2);
34644 ecode3 = SWIG_AsVal_int(obj2, &val3);
34645 if (!SWIG_IsOK(ecode3)) {
34646 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
34647 }
34648 arg3 = static_cast< int >(val3);
34649 {
34650 PyThreadState* __tstate = wxPyBeginAllowThreads();
34651 result = (bool)(arg1)->OnDrop(arg2,arg3);
34652 wxPyEndAllowThreads(__tstate);
34653 if (PyErr_Occurred()) SWIG_fail;
34654 }
34655 {
34656 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34657 }
34658 return resultobj;
34659 fail:
34660 return NULL;
34661 }
34662
34663
34664 SWIGINTERN PyObject *_wrap_TextDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34665 PyObject *resultobj = 0;
34666 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34667 int arg2 ;
34668 int arg3 ;
34669 wxDragResult arg4 ;
34670 wxDragResult result;
34671 void *argp1 = 0 ;
34672 int res1 = 0 ;
34673 int val2 ;
34674 int ecode2 = 0 ;
34675 int val3 ;
34676 int ecode3 = 0 ;
34677 int val4 ;
34678 int ecode4 = 0 ;
34679 PyObject * obj0 = 0 ;
34680 PyObject * obj1 = 0 ;
34681 PyObject * obj2 = 0 ;
34682 PyObject * obj3 = 0 ;
34683 char * kwnames[] = {
34684 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34685 };
34686
34687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34688 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34689 if (!SWIG_IsOK(res1)) {
34690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34691 }
34692 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34693 ecode2 = SWIG_AsVal_int(obj1, &val2);
34694 if (!SWIG_IsOK(ecode2)) {
34695 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
34696 }
34697 arg2 = static_cast< int >(val2);
34698 ecode3 = SWIG_AsVal_int(obj2, &val3);
34699 if (!SWIG_IsOK(ecode3)) {
34700 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
34701 }
34702 arg3 = static_cast< int >(val3);
34703 ecode4 = SWIG_AsVal_int(obj3, &val4);
34704 if (!SWIG_IsOK(ecode4)) {
34705 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
34706 }
34707 arg4 = static_cast< wxDragResult >(val4);
34708 {
34709 PyThreadState* __tstate = wxPyBeginAllowThreads();
34710 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
34711 wxPyEndAllowThreads(__tstate);
34712 if (PyErr_Occurred()) SWIG_fail;
34713 }
34714 resultobj = SWIG_From_int(static_cast< int >(result));
34715 return resultobj;
34716 fail:
34717 return NULL;
34718 }
34719
34720
34721 SWIGINTERN PyObject *TextDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34722 PyObject *obj;
34723 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34724 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDropTarget, SWIG_NewClientData(obj));
34725 return SWIG_Py_Void();
34726 }
34727
34728 SWIGINTERN PyObject *TextDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34729 return SWIG_Python_InitShadowInstance(args);
34730 }
34731
34732 SWIGINTERN PyObject *_wrap_new_FileDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34733 PyObject *resultobj = 0;
34734 wxPyFileDropTarget *result = 0 ;
34735
34736 if (!SWIG_Python_UnpackTuple(args,"new_FileDropTarget",0,0,0)) SWIG_fail;
34737 {
34738 PyThreadState* __tstate = wxPyBeginAllowThreads();
34739 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
34740 wxPyEndAllowThreads(__tstate);
34741 if (PyErr_Occurred()) SWIG_fail;
34742 }
34743 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_NEW | 0 );
34744 return resultobj;
34745 fail:
34746 return NULL;
34747 }
34748
34749
34750 SWIGINTERN PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34751 PyObject *resultobj = 0;
34752 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
34753 PyObject *arg2 = (PyObject *) 0 ;
34754 PyObject *arg3 = (PyObject *) 0 ;
34755 void *argp1 = 0 ;
34756 int res1 = 0 ;
34757 PyObject * obj0 = 0 ;
34758 PyObject * obj1 = 0 ;
34759 PyObject * obj2 = 0 ;
34760 char * kwnames[] = {
34761 (char *) "self",(char *) "self",(char *) "_class", NULL
34762 };
34763
34764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
34766 if (!SWIG_IsOK(res1)) {
34767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
34768 }
34769 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
34770 arg2 = obj1;
34771 arg3 = obj2;
34772 {
34773 PyThreadState* __tstate = wxPyBeginAllowThreads();
34774 (arg1)->_setCallbackInfo(arg2,arg3);
34775 wxPyEndAllowThreads(__tstate);
34776 if (PyErr_Occurred()) SWIG_fail;
34777 }
34778 resultobj = SWIG_Py_Void();
34779 return resultobj;
34780 fail:
34781 return NULL;
34782 }
34783
34784
34785 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDropFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34786 PyObject *resultobj = 0;
34787 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
34788 int arg2 ;
34789 int arg3 ;
34790 wxArrayString *arg4 = 0 ;
34791 bool result;
34792 void *argp1 = 0 ;
34793 int res1 = 0 ;
34794 int val2 ;
34795 int ecode2 = 0 ;
34796 int val3 ;
34797 int ecode3 = 0 ;
34798 bool temp4 = false ;
34799 PyObject * obj0 = 0 ;
34800 PyObject * obj1 = 0 ;
34801 PyObject * obj2 = 0 ;
34802 PyObject * obj3 = 0 ;
34803 char * kwnames[] = {
34804 (char *) "self",(char *) "x",(char *) "y",(char *) "filenames", NULL
34805 };
34806
34807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDropFiles",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
34809 if (!SWIG_IsOK(res1)) {
34810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
34811 }
34812 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
34813 ecode2 = SWIG_AsVal_int(obj1, &val2);
34814 if (!SWIG_IsOK(ecode2)) {
34815 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "2"" of type '" "int""'");
34816 }
34817 arg2 = static_cast< int >(val2);
34818 ecode3 = SWIG_AsVal_int(obj2, &val3);
34819 if (!SWIG_IsOK(ecode3)) {
34820 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "3"" of type '" "int""'");
34821 }
34822 arg3 = static_cast< int >(val3);
34823 {
34824 if (! PySequence_Check(obj3)) {
34825 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
34826 SWIG_fail;
34827 }
34828 arg4 = new wxArrayString;
34829 temp4 = true;
34830 int i, len=PySequence_Length(obj3);
34831 for (i=0; i<len; i++) {
34832 PyObject* item = PySequence_GetItem(obj3, i);
34833 wxString* s = wxString_in_helper(item);
34834 if (PyErr_Occurred()) SWIG_fail;
34835 arg4->Add(*s);
34836 delete s;
34837 Py_DECREF(item);
34838 }
34839 }
34840 {
34841 PyThreadState* __tstate = wxPyBeginAllowThreads();
34842 result = (bool)(arg1)->OnDropFiles(arg2,arg3,(wxArrayString const &)*arg4);
34843 wxPyEndAllowThreads(__tstate);
34844 if (PyErr_Occurred()) SWIG_fail;
34845 }
34846 {
34847 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34848 }
34849 {
34850 if (temp4) delete arg4;
34851 }
34852 return resultobj;
34853 fail:
34854 {
34855 if (temp4) delete arg4;
34856 }
34857 return NULL;
34858 }
34859
34860
34861 SWIGINTERN PyObject *_wrap_FileDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34862 PyObject *resultobj = 0;
34863 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
34864 int arg2 ;
34865 int arg3 ;
34866 wxDragResult arg4 ;
34867 wxDragResult result;
34868 void *argp1 = 0 ;
34869 int res1 = 0 ;
34870 int val2 ;
34871 int ecode2 = 0 ;
34872 int val3 ;
34873 int ecode3 = 0 ;
34874 int val4 ;
34875 int ecode4 = 0 ;
34876 PyObject * obj0 = 0 ;
34877 PyObject * obj1 = 0 ;
34878 PyObject * obj2 = 0 ;
34879 PyObject * obj3 = 0 ;
34880 char * kwnames[] = {
34881 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34882 };
34883
34884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34885 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
34886 if (!SWIG_IsOK(res1)) {
34887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
34888 }
34889 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
34890 ecode2 = SWIG_AsVal_int(obj1, &val2);
34891 if (!SWIG_IsOK(ecode2)) {
34892 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
34893 }
34894 arg2 = static_cast< int >(val2);
34895 ecode3 = SWIG_AsVal_int(obj2, &val3);
34896 if (!SWIG_IsOK(ecode3)) {
34897 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
34898 }
34899 arg3 = static_cast< int >(val3);
34900 ecode4 = SWIG_AsVal_int(obj3, &val4);
34901 if (!SWIG_IsOK(ecode4)) {
34902 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
34903 }
34904 arg4 = static_cast< wxDragResult >(val4);
34905 {
34906 PyThreadState* __tstate = wxPyBeginAllowThreads();
34907 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
34908 wxPyEndAllowThreads(__tstate);
34909 if (PyErr_Occurred()) SWIG_fail;
34910 }
34911 resultobj = SWIG_From_int(static_cast< int >(result));
34912 return resultobj;
34913 fail:
34914 return NULL;
34915 }
34916
34917
34918 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34919 PyObject *resultobj = 0;
34920 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
34921 int arg2 ;
34922 int arg3 ;
34923 wxDragResult arg4 ;
34924 wxDragResult result;
34925 void *argp1 = 0 ;
34926 int res1 = 0 ;
34927 int val2 ;
34928 int ecode2 = 0 ;
34929 int val3 ;
34930 int ecode3 = 0 ;
34931 int val4 ;
34932 int ecode4 = 0 ;
34933 PyObject * obj0 = 0 ;
34934 PyObject * obj1 = 0 ;
34935 PyObject * obj2 = 0 ;
34936 PyObject * obj3 = 0 ;
34937 char * kwnames[] = {
34938 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34939 };
34940
34941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34942 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
34943 if (!SWIG_IsOK(res1)) {
34944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
34945 }
34946 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
34947 ecode2 = SWIG_AsVal_int(obj1, &val2);
34948 if (!SWIG_IsOK(ecode2)) {
34949 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
34950 }
34951 arg2 = static_cast< int >(val2);
34952 ecode3 = SWIG_AsVal_int(obj2, &val3);
34953 if (!SWIG_IsOK(ecode3)) {
34954 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
34955 }
34956 arg3 = static_cast< int >(val3);
34957 ecode4 = SWIG_AsVal_int(obj3, &val4);
34958 if (!SWIG_IsOK(ecode4)) {
34959 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
34960 }
34961 arg4 = static_cast< wxDragResult >(val4);
34962 {
34963 PyThreadState* __tstate = wxPyBeginAllowThreads();
34964 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
34965 wxPyEndAllowThreads(__tstate);
34966 if (PyErr_Occurred()) SWIG_fail;
34967 }
34968 resultobj = SWIG_From_int(static_cast< int >(result));
34969 return resultobj;
34970 fail:
34971 return NULL;
34972 }
34973
34974
34975 SWIGINTERN PyObject *_wrap_FileDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34976 PyObject *resultobj = 0;
34977 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
34978 void *argp1 = 0 ;
34979 int res1 = 0 ;
34980 PyObject *swig_obj[1] ;
34981
34982 if (!args) SWIG_fail;
34983 swig_obj[0] = args;
34984 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
34985 if (!SWIG_IsOK(res1)) {
34986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
34987 }
34988 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
34989 {
34990 PyThreadState* __tstate = wxPyBeginAllowThreads();
34991 (arg1)->OnLeave();
34992 wxPyEndAllowThreads(__tstate);
34993 if (PyErr_Occurred()) SWIG_fail;
34994 }
34995 resultobj = SWIG_Py_Void();
34996 return resultobj;
34997 fail:
34998 return NULL;
34999 }
35000
35001
35002 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35003 PyObject *resultobj = 0;
35004 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35005 int arg2 ;
35006 int arg3 ;
35007 bool result;
35008 void *argp1 = 0 ;
35009 int res1 = 0 ;
35010 int val2 ;
35011 int ecode2 = 0 ;
35012 int val3 ;
35013 int ecode3 = 0 ;
35014 PyObject * obj0 = 0 ;
35015 PyObject * obj1 = 0 ;
35016 PyObject * obj2 = 0 ;
35017 char * kwnames[] = {
35018 (char *) "self",(char *) "x",(char *) "y", NULL
35019 };
35020
35021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35022 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35023 if (!SWIG_IsOK(res1)) {
35024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35025 }
35026 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35027 ecode2 = SWIG_AsVal_int(obj1, &val2);
35028 if (!SWIG_IsOK(ecode2)) {
35029 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
35030 }
35031 arg2 = static_cast< int >(val2);
35032 ecode3 = SWIG_AsVal_int(obj2, &val3);
35033 if (!SWIG_IsOK(ecode3)) {
35034 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
35035 }
35036 arg3 = static_cast< int >(val3);
35037 {
35038 PyThreadState* __tstate = wxPyBeginAllowThreads();
35039 result = (bool)(arg1)->OnDrop(arg2,arg3);
35040 wxPyEndAllowThreads(__tstate);
35041 if (PyErr_Occurred()) SWIG_fail;
35042 }
35043 {
35044 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35045 }
35046 return resultobj;
35047 fail:
35048 return NULL;
35049 }
35050
35051
35052 SWIGINTERN PyObject *_wrap_FileDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35053 PyObject *resultobj = 0;
35054 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35055 int arg2 ;
35056 int arg3 ;
35057 wxDragResult arg4 ;
35058 wxDragResult result;
35059 void *argp1 = 0 ;
35060 int res1 = 0 ;
35061 int val2 ;
35062 int ecode2 = 0 ;
35063 int val3 ;
35064 int ecode3 = 0 ;
35065 int val4 ;
35066 int ecode4 = 0 ;
35067 PyObject * obj0 = 0 ;
35068 PyObject * obj1 = 0 ;
35069 PyObject * obj2 = 0 ;
35070 PyObject * obj3 = 0 ;
35071 char * kwnames[] = {
35072 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
35073 };
35074
35075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35077 if (!SWIG_IsOK(res1)) {
35078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35079 }
35080 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35081 ecode2 = SWIG_AsVal_int(obj1, &val2);
35082 if (!SWIG_IsOK(ecode2)) {
35083 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
35084 }
35085 arg2 = static_cast< int >(val2);
35086 ecode3 = SWIG_AsVal_int(obj2, &val3);
35087 if (!SWIG_IsOK(ecode3)) {
35088 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
35089 }
35090 arg3 = static_cast< int >(val3);
35091 ecode4 = SWIG_AsVal_int(obj3, &val4);
35092 if (!SWIG_IsOK(ecode4)) {
35093 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
35094 }
35095 arg4 = static_cast< wxDragResult >(val4);
35096 {
35097 PyThreadState* __tstate = wxPyBeginAllowThreads();
35098 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
35099 wxPyEndAllowThreads(__tstate);
35100 if (PyErr_Occurred()) SWIG_fail;
35101 }
35102 resultobj = SWIG_From_int(static_cast< int >(result));
35103 return resultobj;
35104 fail:
35105 return NULL;
35106 }
35107
35108
35109 SWIGINTERN PyObject *FileDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35110 PyObject *obj;
35111 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35112 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileDropTarget, SWIG_NewClientData(obj));
35113 return SWIG_Py_Void();
35114 }
35115
35116 SWIGINTERN PyObject *FileDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35117 return SWIG_Python_InitShadowInstance(args);
35118 }
35119
35120 SWIGINTERN PyObject *_wrap_new_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35121 PyObject *resultobj = 0;
35122 wxClipboard *result = 0 ;
35123
35124 if (!SWIG_Python_UnpackTuple(args,"new_Clipboard",0,0,0)) SWIG_fail;
35125 {
35126 PyThreadState* __tstate = wxPyBeginAllowThreads();
35127 result = (wxClipboard *)new wxClipboard();
35128 wxPyEndAllowThreads(__tstate);
35129 if (PyErr_Occurred()) SWIG_fail;
35130 }
35131 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, SWIG_POINTER_NEW | 0 );
35132 return resultobj;
35133 fail:
35134 return NULL;
35135 }
35136
35137
35138 SWIGINTERN PyObject *_wrap_delete_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35139 PyObject *resultobj = 0;
35140 wxClipboard *arg1 = (wxClipboard *) 0 ;
35141 void *argp1 = 0 ;
35142 int res1 = 0 ;
35143 PyObject *swig_obj[1] ;
35144
35145 if (!args) SWIG_fail;
35146 swig_obj[0] = args;
35147 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, SWIG_POINTER_DISOWN | 0 );
35148 if (!SWIG_IsOK(res1)) {
35149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Clipboard" "', expected argument " "1"" of type '" "wxClipboard *""'");
35150 }
35151 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35152 {
35153 PyThreadState* __tstate = wxPyBeginAllowThreads();
35154 delete arg1;
35155
35156 wxPyEndAllowThreads(__tstate);
35157 if (PyErr_Occurred()) SWIG_fail;
35158 }
35159 resultobj = SWIG_Py_Void();
35160 return resultobj;
35161 fail:
35162 return NULL;
35163 }
35164
35165
35166 SWIGINTERN PyObject *_wrap_Clipboard_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35167 PyObject *resultobj = 0;
35168 wxClipboard *arg1 = (wxClipboard *) 0 ;
35169 bool result;
35170 void *argp1 = 0 ;
35171 int res1 = 0 ;
35172 PyObject *swig_obj[1] ;
35173
35174 if (!args) SWIG_fail;
35175 swig_obj[0] = args;
35176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35177 if (!SWIG_IsOK(res1)) {
35178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Open" "', expected argument " "1"" of type '" "wxClipboard *""'");
35179 }
35180 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35181 {
35182 PyThreadState* __tstate = wxPyBeginAllowThreads();
35183 result = (bool)(arg1)->Open();
35184 wxPyEndAllowThreads(__tstate);
35185 if (PyErr_Occurred()) SWIG_fail;
35186 }
35187 {
35188 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35189 }
35190 return resultobj;
35191 fail:
35192 return NULL;
35193 }
35194
35195
35196 SWIGINTERN PyObject *_wrap_Clipboard_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35197 PyObject *resultobj = 0;
35198 wxClipboard *arg1 = (wxClipboard *) 0 ;
35199 void *argp1 = 0 ;
35200 int res1 = 0 ;
35201 PyObject *swig_obj[1] ;
35202
35203 if (!args) SWIG_fail;
35204 swig_obj[0] = args;
35205 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35206 if (!SWIG_IsOK(res1)) {
35207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Close" "', expected argument " "1"" of type '" "wxClipboard *""'");
35208 }
35209 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35210 {
35211 PyThreadState* __tstate = wxPyBeginAllowThreads();
35212 (arg1)->Close();
35213 wxPyEndAllowThreads(__tstate);
35214 if (PyErr_Occurred()) SWIG_fail;
35215 }
35216 resultobj = SWIG_Py_Void();
35217 return resultobj;
35218 fail:
35219 return NULL;
35220 }
35221
35222
35223 SWIGINTERN PyObject *_wrap_Clipboard_IsOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35224 PyObject *resultobj = 0;
35225 wxClipboard *arg1 = (wxClipboard *) 0 ;
35226 bool result;
35227 void *argp1 = 0 ;
35228 int res1 = 0 ;
35229 PyObject *swig_obj[1] ;
35230
35231 if (!args) SWIG_fail;
35232 swig_obj[0] = args;
35233 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35234 if (!SWIG_IsOK(res1)) {
35235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsOpened" "', expected argument " "1"" of type '" "wxClipboard const *""'");
35236 }
35237 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35238 {
35239 PyThreadState* __tstate = wxPyBeginAllowThreads();
35240 result = (bool)((wxClipboard const *)arg1)->IsOpened();
35241 wxPyEndAllowThreads(__tstate);
35242 if (PyErr_Occurred()) SWIG_fail;
35243 }
35244 {
35245 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35246 }
35247 return resultobj;
35248 fail:
35249 return NULL;
35250 }
35251
35252
35253 SWIGINTERN PyObject *_wrap_Clipboard_AddData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35254 PyObject *resultobj = 0;
35255 wxClipboard *arg1 = (wxClipboard *) 0 ;
35256 wxDataObject *arg2 = (wxDataObject *) 0 ;
35257 bool result;
35258 void *argp1 = 0 ;
35259 int res1 = 0 ;
35260 int res2 = 0 ;
35261 PyObject * obj0 = 0 ;
35262 PyObject * obj1 = 0 ;
35263 char * kwnames[] = {
35264 (char *) "self",(char *) "data", NULL
35265 };
35266
35267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) SWIG_fail;
35268 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35269 if (!SWIG_IsOK(res1)) {
35270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_AddData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35271 }
35272 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35273 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
35274 if (!SWIG_IsOK(res2)) {
35275 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_AddData" "', expected argument " "2"" of type '" "wxDataObject *""'");
35276 }
35277 {
35278 PyThreadState* __tstate = wxPyBeginAllowThreads();
35279 result = (bool)(arg1)->AddData(arg2);
35280 wxPyEndAllowThreads(__tstate);
35281 if (PyErr_Occurred()) SWIG_fail;
35282 }
35283 {
35284 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35285 }
35286 return resultobj;
35287 fail:
35288 return NULL;
35289 }
35290
35291
35292 SWIGINTERN PyObject *_wrap_Clipboard_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35293 PyObject *resultobj = 0;
35294 wxClipboard *arg1 = (wxClipboard *) 0 ;
35295 wxDataObject *arg2 = (wxDataObject *) 0 ;
35296 bool result;
35297 void *argp1 = 0 ;
35298 int res1 = 0 ;
35299 int res2 = 0 ;
35300 PyObject * obj0 = 0 ;
35301 PyObject * obj1 = 0 ;
35302 char * kwnames[] = {
35303 (char *) "self",(char *) "data", NULL
35304 };
35305
35306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
35307 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35308 if (!SWIG_IsOK(res1)) {
35309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_SetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35310 }
35311 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35312 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
35313 if (!SWIG_IsOK(res2)) {
35314 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_SetData" "', expected argument " "2"" of type '" "wxDataObject *""'");
35315 }
35316 {
35317 PyThreadState* __tstate = wxPyBeginAllowThreads();
35318 result = (bool)(arg1)->SetData(arg2);
35319 wxPyEndAllowThreads(__tstate);
35320 if (PyErr_Occurred()) SWIG_fail;
35321 }
35322 {
35323 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35324 }
35325 return resultobj;
35326 fail:
35327 return NULL;
35328 }
35329
35330
35331 SWIGINTERN PyObject *_wrap_Clipboard_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35332 PyObject *resultobj = 0;
35333 wxClipboard *arg1 = (wxClipboard *) 0 ;
35334 wxDataFormat *arg2 = 0 ;
35335 bool result;
35336 void *argp1 = 0 ;
35337 int res1 = 0 ;
35338 void *argp2 = 0 ;
35339 int res2 = 0 ;
35340 PyObject * obj0 = 0 ;
35341 PyObject * obj1 = 0 ;
35342 char * kwnames[] = {
35343 (char *) "self",(char *) "format", NULL
35344 };
35345
35346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) SWIG_fail;
35347 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35348 if (!SWIG_IsOK(res1)) {
35349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsSupported" "', expected argument " "1"" of type '" "wxClipboard *""'");
35350 }
35351 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35352 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
35353 if (!SWIG_IsOK(res2)) {
35354 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
35355 }
35356 if (!argp2) {
35357 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
35358 }
35359 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
35360 {
35361 PyThreadState* __tstate = wxPyBeginAllowThreads();
35362 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
35363 wxPyEndAllowThreads(__tstate);
35364 if (PyErr_Occurred()) SWIG_fail;
35365 }
35366 {
35367 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35368 }
35369 return resultobj;
35370 fail:
35371 return NULL;
35372 }
35373
35374
35375 SWIGINTERN PyObject *_wrap_Clipboard_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35376 PyObject *resultobj = 0;
35377 wxClipboard *arg1 = (wxClipboard *) 0 ;
35378 wxDataObject *arg2 = 0 ;
35379 bool result;
35380 void *argp1 = 0 ;
35381 int res1 = 0 ;
35382 void *argp2 = 0 ;
35383 int res2 = 0 ;
35384 PyObject * obj0 = 0 ;
35385 PyObject * obj1 = 0 ;
35386 char * kwnames[] = {
35387 (char *) "self",(char *) "data", NULL
35388 };
35389
35390 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) SWIG_fail;
35391 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35392 if (!SWIG_IsOK(res1)) {
35393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_GetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35394 }
35395 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35396 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
35397 if (!SWIG_IsOK(res2)) {
35398 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
35399 }
35400 if (!argp2) {
35401 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
35402 }
35403 arg2 = reinterpret_cast< wxDataObject * >(argp2);
35404 {
35405 PyThreadState* __tstate = wxPyBeginAllowThreads();
35406 result = (bool)(arg1)->GetData(*arg2);
35407 wxPyEndAllowThreads(__tstate);
35408 if (PyErr_Occurred()) SWIG_fail;
35409 }
35410 {
35411 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35412 }
35413 return resultobj;
35414 fail:
35415 return NULL;
35416 }
35417
35418
35419 SWIGINTERN PyObject *_wrap_Clipboard_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35420 PyObject *resultobj = 0;
35421 wxClipboard *arg1 = (wxClipboard *) 0 ;
35422 void *argp1 = 0 ;
35423 int res1 = 0 ;
35424 PyObject *swig_obj[1] ;
35425
35426 if (!args) SWIG_fail;
35427 swig_obj[0] = args;
35428 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35429 if (!SWIG_IsOK(res1)) {
35430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Clear" "', expected argument " "1"" of type '" "wxClipboard *""'");
35431 }
35432 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35433 {
35434 PyThreadState* __tstate = wxPyBeginAllowThreads();
35435 (arg1)->Clear();
35436 wxPyEndAllowThreads(__tstate);
35437 if (PyErr_Occurred()) SWIG_fail;
35438 }
35439 resultobj = SWIG_Py_Void();
35440 return resultobj;
35441 fail:
35442 return NULL;
35443 }
35444
35445
35446 SWIGINTERN PyObject *_wrap_Clipboard_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35447 PyObject *resultobj = 0;
35448 wxClipboard *arg1 = (wxClipboard *) 0 ;
35449 bool result;
35450 void *argp1 = 0 ;
35451 int res1 = 0 ;
35452 PyObject *swig_obj[1] ;
35453
35454 if (!args) SWIG_fail;
35455 swig_obj[0] = args;
35456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35457 if (!SWIG_IsOK(res1)) {
35458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Flush" "', expected argument " "1"" of type '" "wxClipboard *""'");
35459 }
35460 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35461 {
35462 PyThreadState* __tstate = wxPyBeginAllowThreads();
35463 result = (bool)(arg1)->Flush();
35464 wxPyEndAllowThreads(__tstate);
35465 if (PyErr_Occurred()) SWIG_fail;
35466 }
35467 {
35468 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35469 }
35470 return resultobj;
35471 fail:
35472 return NULL;
35473 }
35474
35475
35476 SWIGINTERN PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35477 PyObject *resultobj = 0;
35478 wxClipboard *arg1 = (wxClipboard *) 0 ;
35479 bool arg2 = (bool) true ;
35480 void *argp1 = 0 ;
35481 int res1 = 0 ;
35482 bool val2 ;
35483 int ecode2 = 0 ;
35484 PyObject * obj0 = 0 ;
35485 PyObject * obj1 = 0 ;
35486 char * kwnames[] = {
35487 (char *) "self",(char *) "primary", NULL
35488 };
35489
35490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) SWIG_fail;
35491 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35492 if (!SWIG_IsOK(res1)) {
35493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "1"" of type '" "wxClipboard *""'");
35494 }
35495 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35496 if (obj1) {
35497 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35498 if (!SWIG_IsOK(ecode2)) {
35499 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "2"" of type '" "bool""'");
35500 }
35501 arg2 = static_cast< bool >(val2);
35502 }
35503 {
35504 PyThreadState* __tstate = wxPyBeginAllowThreads();
35505 (arg1)->UsePrimarySelection(arg2);
35506 wxPyEndAllowThreads(__tstate);
35507 if (PyErr_Occurred()) SWIG_fail;
35508 }
35509 resultobj = SWIG_Py_Void();
35510 return resultobj;
35511 fail:
35512 return NULL;
35513 }
35514
35515
35516 SWIGINTERN PyObject *_wrap_Clipboard_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35517 PyObject *resultobj = 0;
35518 wxClipboard *result = 0 ;
35519
35520 if (!SWIG_Python_UnpackTuple(args,"Clipboard_Get",0,0,0)) SWIG_fail;
35521 {
35522 PyThreadState* __tstate = wxPyBeginAllowThreads();
35523 result = (wxClipboard *)wxClipboard::Get();
35524 wxPyEndAllowThreads(__tstate);
35525 if (PyErr_Occurred()) SWIG_fail;
35526 }
35527 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, 0 | 0 );
35528 return resultobj;
35529 fail:
35530 return NULL;
35531 }
35532
35533
35534 SWIGINTERN PyObject *Clipboard_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35535 PyObject *obj;
35536 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35537 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboard, SWIG_NewClientData(obj));
35538 return SWIG_Py_Void();
35539 }
35540
35541 SWIGINTERN PyObject *Clipboard_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35542 return SWIG_Python_InitShadowInstance(args);
35543 }
35544
35545 SWIGINTERN PyObject *_wrap_new_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35546 PyObject *resultobj = 0;
35547 wxClipboard *arg1 = (wxClipboard *) NULL ;
35548 wxClipboardLocker *result = 0 ;
35549 void *argp1 = 0 ;
35550 int res1 = 0 ;
35551 PyObject * obj0 = 0 ;
35552 char * kwnames[] = {
35553 (char *) "clipboard", NULL
35554 };
35555
35556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) SWIG_fail;
35557 if (obj0) {
35558 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35559 if (!SWIG_IsOK(res1)) {
35560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboard *""'");
35561 }
35562 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35563 }
35564 {
35565 PyThreadState* __tstate = wxPyBeginAllowThreads();
35566 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
35567 wxPyEndAllowThreads(__tstate);
35568 if (PyErr_Occurred()) SWIG_fail;
35569 }
35570 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_NEW | 0 );
35571 return resultobj;
35572 fail:
35573 return NULL;
35574 }
35575
35576
35577 SWIGINTERN PyObject *_wrap_delete_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35578 PyObject *resultobj = 0;
35579 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
35580 void *argp1 = 0 ;
35581 int res1 = 0 ;
35582 PyObject *swig_obj[1] ;
35583
35584 if (!args) SWIG_fail;
35585 swig_obj[0] = args;
35586 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_DISOWN | 0 );
35587 if (!SWIG_IsOK(res1)) {
35588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
35589 }
35590 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
35591 {
35592 PyThreadState* __tstate = wxPyBeginAllowThreads();
35593 delete arg1;
35594
35595 wxPyEndAllowThreads(__tstate);
35596 if (PyErr_Occurred()) SWIG_fail;
35597 }
35598 resultobj = SWIG_Py_Void();
35599 return resultobj;
35600 fail:
35601 return NULL;
35602 }
35603
35604
35605 SWIGINTERN PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35606 PyObject *resultobj = 0;
35607 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
35608 bool result;
35609 void *argp1 = 0 ;
35610 int res1 = 0 ;
35611 PyObject *swig_obj[1] ;
35612
35613 if (!args) SWIG_fail;
35614 swig_obj[0] = args;
35615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, 0 | 0 );
35616 if (!SWIG_IsOK(res1)) {
35617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClipboardLocker___nonzero__" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
35618 }
35619 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
35620 {
35621 PyThreadState* __tstate = wxPyBeginAllowThreads();
35622 result = (bool)wxClipboardLocker___nonzero__(arg1);
35623 wxPyEndAllowThreads(__tstate);
35624 if (PyErr_Occurred()) SWIG_fail;
35625 }
35626 {
35627 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35628 }
35629 return resultobj;
35630 fail:
35631 return NULL;
35632 }
35633
35634
35635 SWIGINTERN PyObject *ClipboardLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35636 PyObject *obj;
35637 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35638 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardLocker, SWIG_NewClientData(obj));
35639 return SWIG_Py_Void();
35640 }
35641
35642 SWIGINTERN PyObject *ClipboardLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35643 return SWIG_Python_InitShadowInstance(args);
35644 }
35645
35646 SWIGINTERN PyObject *_wrap_new_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35647 PyObject *resultobj = 0;
35648 int arg1 = (int) 0 ;
35649 int arg2 = (int) 0 ;
35650 int arg3 = (int) 0 ;
35651 int arg4 = (int) 0 ;
35652 wxVideoMode *result = 0 ;
35653 int val1 ;
35654 int ecode1 = 0 ;
35655 int val2 ;
35656 int ecode2 = 0 ;
35657 int val3 ;
35658 int ecode3 = 0 ;
35659 int val4 ;
35660 int ecode4 = 0 ;
35661 PyObject * obj0 = 0 ;
35662 PyObject * obj1 = 0 ;
35663 PyObject * obj2 = 0 ;
35664 PyObject * obj3 = 0 ;
35665 char * kwnames[] = {
35666 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
35667 };
35668
35669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35670 if (obj0) {
35671 ecode1 = SWIG_AsVal_int(obj0, &val1);
35672 if (!SWIG_IsOK(ecode1)) {
35673 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VideoMode" "', expected argument " "1"" of type '" "int""'");
35674 }
35675 arg1 = static_cast< int >(val1);
35676 }
35677 if (obj1) {
35678 ecode2 = SWIG_AsVal_int(obj1, &val2);
35679 if (!SWIG_IsOK(ecode2)) {
35680 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VideoMode" "', expected argument " "2"" of type '" "int""'");
35681 }
35682 arg2 = static_cast< int >(val2);
35683 }
35684 if (obj2) {
35685 ecode3 = SWIG_AsVal_int(obj2, &val3);
35686 if (!SWIG_IsOK(ecode3)) {
35687 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_VideoMode" "', expected argument " "3"" of type '" "int""'");
35688 }
35689 arg3 = static_cast< int >(val3);
35690 }
35691 if (obj3) {
35692 ecode4 = SWIG_AsVal_int(obj3, &val4);
35693 if (!SWIG_IsOK(ecode4)) {
35694 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_VideoMode" "', expected argument " "4"" of type '" "int""'");
35695 }
35696 arg4 = static_cast< int >(val4);
35697 }
35698 {
35699 PyThreadState* __tstate = wxPyBeginAllowThreads();
35700 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
35701 wxPyEndAllowThreads(__tstate);
35702 if (PyErr_Occurred()) SWIG_fail;
35703 }
35704 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_NEW | 0 );
35705 return resultobj;
35706 fail:
35707 return NULL;
35708 }
35709
35710
35711 SWIGINTERN PyObject *_wrap_delete_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35712 PyObject *resultobj = 0;
35713 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35714 void *argp1 = 0 ;
35715 int res1 = 0 ;
35716 PyObject *swig_obj[1] ;
35717
35718 if (!args) SWIG_fail;
35719 swig_obj[0] = args;
35720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, SWIG_POINTER_DISOWN | 0 );
35721 if (!SWIG_IsOK(res1)) {
35722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VideoMode" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35723 }
35724 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35725 {
35726 PyThreadState* __tstate = wxPyBeginAllowThreads();
35727 delete arg1;
35728
35729 wxPyEndAllowThreads(__tstate);
35730 if (PyErr_Occurred()) SWIG_fail;
35731 }
35732 resultobj = SWIG_Py_Void();
35733 return resultobj;
35734 fail:
35735 return NULL;
35736 }
35737
35738
35739 SWIGINTERN PyObject *_wrap_VideoMode_Matches(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35740 PyObject *resultobj = 0;
35741 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35742 wxVideoMode *arg2 = 0 ;
35743 bool result;
35744 void *argp1 = 0 ;
35745 int res1 = 0 ;
35746 void *argp2 = 0 ;
35747 int res2 = 0 ;
35748 PyObject * obj0 = 0 ;
35749 PyObject * obj1 = 0 ;
35750 char * kwnames[] = {
35751 (char *) "self",(char *) "other", NULL
35752 };
35753
35754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) SWIG_fail;
35755 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35756 if (!SWIG_IsOK(res1)) {
35757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_Matches" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
35758 }
35759 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35760 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
35761 if (!SWIG_IsOK(res2)) {
35762 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35763 }
35764 if (!argp2) {
35765 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35766 }
35767 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
35768 {
35769 PyThreadState* __tstate = wxPyBeginAllowThreads();
35770 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
35771 wxPyEndAllowThreads(__tstate);
35772 if (PyErr_Occurred()) SWIG_fail;
35773 }
35774 {
35775 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35776 }
35777 return resultobj;
35778 fail:
35779 return NULL;
35780 }
35781
35782
35783 SWIGINTERN PyObject *_wrap_VideoMode_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35784 PyObject *resultobj = 0;
35785 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35786 int result;
35787 void *argp1 = 0 ;
35788 int res1 = 0 ;
35789 PyObject *swig_obj[1] ;
35790
35791 if (!args) SWIG_fail;
35792 swig_obj[0] = args;
35793 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35794 if (!SWIG_IsOK(res1)) {
35795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetWidth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
35796 }
35797 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35798 {
35799 PyThreadState* __tstate = wxPyBeginAllowThreads();
35800 result = (int)((wxVideoMode const *)arg1)->GetWidth();
35801 wxPyEndAllowThreads(__tstate);
35802 if (PyErr_Occurred()) SWIG_fail;
35803 }
35804 resultobj = SWIG_From_int(static_cast< int >(result));
35805 return resultobj;
35806 fail:
35807 return NULL;
35808 }
35809
35810
35811 SWIGINTERN PyObject *_wrap_VideoMode_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35812 PyObject *resultobj = 0;
35813 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35814 int result;
35815 void *argp1 = 0 ;
35816 int res1 = 0 ;
35817 PyObject *swig_obj[1] ;
35818
35819 if (!args) SWIG_fail;
35820 swig_obj[0] = args;
35821 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35822 if (!SWIG_IsOK(res1)) {
35823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetHeight" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
35824 }
35825 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35826 {
35827 PyThreadState* __tstate = wxPyBeginAllowThreads();
35828 result = (int)((wxVideoMode const *)arg1)->GetHeight();
35829 wxPyEndAllowThreads(__tstate);
35830 if (PyErr_Occurred()) SWIG_fail;
35831 }
35832 resultobj = SWIG_From_int(static_cast< int >(result));
35833 return resultobj;
35834 fail:
35835 return NULL;
35836 }
35837
35838
35839 SWIGINTERN PyObject *_wrap_VideoMode_GetDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35840 PyObject *resultobj = 0;
35841 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35842 int result;
35843 void *argp1 = 0 ;
35844 int res1 = 0 ;
35845 PyObject *swig_obj[1] ;
35846
35847 if (!args) SWIG_fail;
35848 swig_obj[0] = args;
35849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35850 if (!SWIG_IsOK(res1)) {
35851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetDepth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
35852 }
35853 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35854 {
35855 PyThreadState* __tstate = wxPyBeginAllowThreads();
35856 result = (int)((wxVideoMode const *)arg1)->GetDepth();
35857 wxPyEndAllowThreads(__tstate);
35858 if (PyErr_Occurred()) SWIG_fail;
35859 }
35860 resultobj = SWIG_From_int(static_cast< int >(result));
35861 return resultobj;
35862 fail:
35863 return NULL;
35864 }
35865
35866
35867 SWIGINTERN PyObject *_wrap_VideoMode_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35868 PyObject *resultobj = 0;
35869 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35870 bool result;
35871 void *argp1 = 0 ;
35872 int res1 = 0 ;
35873 PyObject *swig_obj[1] ;
35874
35875 if (!args) SWIG_fail;
35876 swig_obj[0] = args;
35877 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35878 if (!SWIG_IsOK(res1)) {
35879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_IsOk" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
35880 }
35881 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35882 {
35883 PyThreadState* __tstate = wxPyBeginAllowThreads();
35884 result = (bool)((wxVideoMode const *)arg1)->IsOk();
35885 wxPyEndAllowThreads(__tstate);
35886 if (PyErr_Occurred()) SWIG_fail;
35887 }
35888 {
35889 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35890 }
35891 return resultobj;
35892 fail:
35893 return NULL;
35894 }
35895
35896
35897 SWIGINTERN PyObject *_wrap_VideoMode___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35898 PyObject *resultobj = 0;
35899 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35900 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
35901 bool result;
35902 void *argp1 = 0 ;
35903 int res1 = 0 ;
35904 void *argp2 = 0 ;
35905 int res2 = 0 ;
35906 PyObject * obj0 = 0 ;
35907 PyObject * obj1 = 0 ;
35908 char * kwnames[] = {
35909 (char *) "self",(char *) "other", NULL
35910 };
35911
35912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
35913 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35914 if (!SWIG_IsOK(res1)) {
35915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___eq__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35916 }
35917 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35918 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35919 if (!SWIG_IsOK(res2)) {
35920 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___eq__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
35921 }
35922 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
35923 {
35924 PyThreadState* __tstate = wxPyBeginAllowThreads();
35925 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
35926 wxPyEndAllowThreads(__tstate);
35927 if (PyErr_Occurred()) SWIG_fail;
35928 }
35929 {
35930 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35931 }
35932 return resultobj;
35933 fail:
35934 return NULL;
35935 }
35936
35937
35938 SWIGINTERN PyObject *_wrap_VideoMode___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35939 PyObject *resultobj = 0;
35940 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35941 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
35942 bool result;
35943 void *argp1 = 0 ;
35944 int res1 = 0 ;
35945 void *argp2 = 0 ;
35946 int res2 = 0 ;
35947 PyObject * obj0 = 0 ;
35948 PyObject * obj1 = 0 ;
35949 char * kwnames[] = {
35950 (char *) "self",(char *) "other", NULL
35951 };
35952
35953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
35954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35955 if (!SWIG_IsOK(res1)) {
35956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___ne__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35957 }
35958 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35959 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35960 if (!SWIG_IsOK(res2)) {
35961 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___ne__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
35962 }
35963 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
35964 {
35965 PyThreadState* __tstate = wxPyBeginAllowThreads();
35966 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
35967 wxPyEndAllowThreads(__tstate);
35968 if (PyErr_Occurred()) SWIG_fail;
35969 }
35970 {
35971 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35972 }
35973 return resultobj;
35974 fail:
35975 return NULL;
35976 }
35977
35978
35979 SWIGINTERN PyObject *_wrap_VideoMode_w_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35980 PyObject *resultobj = 0;
35981 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35982 int arg2 ;
35983 void *argp1 = 0 ;
35984 int res1 = 0 ;
35985 int val2 ;
35986 int ecode2 = 0 ;
35987 PyObject *swig_obj[2] ;
35988
35989 if (!SWIG_Python_UnpackTuple(args,"VideoMode_w_set",2,2,swig_obj)) SWIG_fail;
35990 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35991 if (!SWIG_IsOK(res1)) {
35992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35993 }
35994 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35995 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
35996 if (!SWIG_IsOK(ecode2)) {
35997 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_w_set" "', expected argument " "2"" of type '" "int""'");
35998 }
35999 arg2 = static_cast< int >(val2);
36000 if (arg1) (arg1)->w = arg2;
36001
36002 resultobj = SWIG_Py_Void();
36003 return resultobj;
36004 fail:
36005 return NULL;
36006 }
36007
36008
36009 SWIGINTERN PyObject *_wrap_VideoMode_w_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36010 PyObject *resultobj = 0;
36011 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36012 int result;
36013 void *argp1 = 0 ;
36014 int res1 = 0 ;
36015 PyObject *swig_obj[1] ;
36016
36017 if (!args) SWIG_fail;
36018 swig_obj[0] = args;
36019 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36020 if (!SWIG_IsOK(res1)) {
36021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36022 }
36023 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36024 result = (int) ((arg1)->w);
36025 resultobj = SWIG_From_int(static_cast< int >(result));
36026 return resultobj;
36027 fail:
36028 return NULL;
36029 }
36030
36031
36032 SWIGINTERN PyObject *_wrap_VideoMode_h_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36033 PyObject *resultobj = 0;
36034 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36035 int arg2 ;
36036 void *argp1 = 0 ;
36037 int res1 = 0 ;
36038 int val2 ;
36039 int ecode2 = 0 ;
36040 PyObject *swig_obj[2] ;
36041
36042 if (!SWIG_Python_UnpackTuple(args,"VideoMode_h_set",2,2,swig_obj)) SWIG_fail;
36043 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36044 if (!SWIG_IsOK(res1)) {
36045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36046 }
36047 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36048 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36049 if (!SWIG_IsOK(ecode2)) {
36050 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_h_set" "', expected argument " "2"" of type '" "int""'");
36051 }
36052 arg2 = static_cast< int >(val2);
36053 if (arg1) (arg1)->h = arg2;
36054
36055 resultobj = SWIG_Py_Void();
36056 return resultobj;
36057 fail:
36058 return NULL;
36059 }
36060
36061
36062 SWIGINTERN PyObject *_wrap_VideoMode_h_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36063 PyObject *resultobj = 0;
36064 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36065 int result;
36066 void *argp1 = 0 ;
36067 int res1 = 0 ;
36068 PyObject *swig_obj[1] ;
36069
36070 if (!args) SWIG_fail;
36071 swig_obj[0] = args;
36072 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36073 if (!SWIG_IsOK(res1)) {
36074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36075 }
36076 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36077 result = (int) ((arg1)->h);
36078 resultobj = SWIG_From_int(static_cast< int >(result));
36079 return resultobj;
36080 fail:
36081 return NULL;
36082 }
36083
36084
36085 SWIGINTERN PyObject *_wrap_VideoMode_bpp_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36086 PyObject *resultobj = 0;
36087 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36088 int arg2 ;
36089 void *argp1 = 0 ;
36090 int res1 = 0 ;
36091 int val2 ;
36092 int ecode2 = 0 ;
36093 PyObject *swig_obj[2] ;
36094
36095 if (!SWIG_Python_UnpackTuple(args,"VideoMode_bpp_set",2,2,swig_obj)) SWIG_fail;
36096 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36097 if (!SWIG_IsOK(res1)) {
36098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36099 }
36100 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36101 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36102 if (!SWIG_IsOK(ecode2)) {
36103 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_bpp_set" "', expected argument " "2"" of type '" "int""'");
36104 }
36105 arg2 = static_cast< int >(val2);
36106 if (arg1) (arg1)->bpp = arg2;
36107
36108 resultobj = SWIG_Py_Void();
36109 return resultobj;
36110 fail:
36111 return NULL;
36112 }
36113
36114
36115 SWIGINTERN PyObject *_wrap_VideoMode_bpp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36116 PyObject *resultobj = 0;
36117 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36118 int result;
36119 void *argp1 = 0 ;
36120 int res1 = 0 ;
36121 PyObject *swig_obj[1] ;
36122
36123 if (!args) SWIG_fail;
36124 swig_obj[0] = args;
36125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36126 if (!SWIG_IsOK(res1)) {
36127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36128 }
36129 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36130 result = (int) ((arg1)->bpp);
36131 resultobj = SWIG_From_int(static_cast< int >(result));
36132 return resultobj;
36133 fail:
36134 return NULL;
36135 }
36136
36137
36138 SWIGINTERN PyObject *_wrap_VideoMode_refresh_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36139 PyObject *resultobj = 0;
36140 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36141 int arg2 ;
36142 void *argp1 = 0 ;
36143 int res1 = 0 ;
36144 int val2 ;
36145 int ecode2 = 0 ;
36146 PyObject *swig_obj[2] ;
36147
36148 if (!SWIG_Python_UnpackTuple(args,"VideoMode_refresh_set",2,2,swig_obj)) SWIG_fail;
36149 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36150 if (!SWIG_IsOK(res1)) {
36151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36152 }
36153 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36154 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36155 if (!SWIG_IsOK(ecode2)) {
36156 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_refresh_set" "', expected argument " "2"" of type '" "int""'");
36157 }
36158 arg2 = static_cast< int >(val2);
36159 if (arg1) (arg1)->refresh = arg2;
36160
36161 resultobj = SWIG_Py_Void();
36162 return resultobj;
36163 fail:
36164 return NULL;
36165 }
36166
36167
36168 SWIGINTERN PyObject *_wrap_VideoMode_refresh_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36169 PyObject *resultobj = 0;
36170 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36171 int result;
36172 void *argp1 = 0 ;
36173 int res1 = 0 ;
36174 PyObject *swig_obj[1] ;
36175
36176 if (!args) SWIG_fail;
36177 swig_obj[0] = args;
36178 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36179 if (!SWIG_IsOK(res1)) {
36180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36181 }
36182 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36183 result = (int) ((arg1)->refresh);
36184 resultobj = SWIG_From_int(static_cast< int >(result));
36185 return resultobj;
36186 fail:
36187 return NULL;
36188 }
36189
36190
36191 SWIGINTERN PyObject *VideoMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36192 PyObject *obj;
36193 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
36194 SWIG_TypeNewClientData(SWIGTYPE_p_wxVideoMode, SWIG_NewClientData(obj));
36195 return SWIG_Py_Void();
36196 }
36197
36198 SWIGINTERN PyObject *VideoMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36199 return SWIG_Python_InitShadowInstance(args);
36200 }
36201
36202 SWIGINTERN int DefaultVideoMode_set(PyObject *) {
36203 SWIG_Error(SWIG_AttributeError,"Variable DefaultVideoMode is read-only.");
36204 return 1;
36205 }
36206
36207
36208 SWIGINTERN PyObject *DefaultVideoMode_get(void) {
36209 PyObject *pyobj = 0;
36210
36211 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0 );
36212 return pyobj;
36213 }
36214
36215
36216 SWIGINTERN PyObject *_wrap_new_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36217 PyObject *resultobj = 0;
36218 size_t arg1 = (size_t) 0 ;
36219 wxDisplay *result = 0 ;
36220 size_t val1 ;
36221 int ecode1 = 0 ;
36222 PyObject * obj0 = 0 ;
36223 char * kwnames[] = {
36224 (char *) "index", NULL
36225 };
36226
36227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) SWIG_fail;
36228 if (obj0) {
36229 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
36230 if (!SWIG_IsOK(ecode1)) {
36231 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Display" "', expected argument " "1"" of type '" "size_t""'");
36232 }
36233 arg1 = static_cast< size_t >(val1);
36234 }
36235 {
36236 PyThreadState* __tstate = wxPyBeginAllowThreads();
36237 result = (wxDisplay *)new wxDisplay(arg1);
36238 wxPyEndAllowThreads(__tstate);
36239 if (PyErr_Occurred()) SWIG_fail;
36240 }
36241 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplay, SWIG_POINTER_NEW | 0 );
36242 return resultobj;
36243 fail:
36244 return NULL;
36245 }
36246
36247
36248 SWIGINTERN PyObject *_wrap_delete_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36249 PyObject *resultobj = 0;
36250 wxDisplay *arg1 = (wxDisplay *) 0 ;
36251 void *argp1 = 0 ;
36252 int res1 = 0 ;
36253 PyObject *swig_obj[1] ;
36254
36255 if (!args) SWIG_fail;
36256 swig_obj[0] = args;
36257 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, SWIG_POINTER_DISOWN | 0 );
36258 if (!SWIG_IsOK(res1)) {
36259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Display" "', expected argument " "1"" of type '" "wxDisplay *""'");
36260 }
36261 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36262 {
36263 PyThreadState* __tstate = wxPyBeginAllowThreads();
36264 delete arg1;
36265
36266 wxPyEndAllowThreads(__tstate);
36267 if (PyErr_Occurred()) SWIG_fail;
36268 }
36269 resultobj = SWIG_Py_Void();
36270 return resultobj;
36271 fail:
36272 return NULL;
36273 }
36274
36275
36276 SWIGINTERN PyObject *_wrap_Display_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36277 PyObject *resultobj = 0;
36278 size_t result;
36279
36280 if (!SWIG_Python_UnpackTuple(args,"Display_GetCount",0,0,0)) SWIG_fail;
36281 {
36282 PyThreadState* __tstate = wxPyBeginAllowThreads();
36283 result = (size_t)wxDisplay::GetCount();
36284 wxPyEndAllowThreads(__tstate);
36285 if (PyErr_Occurred()) SWIG_fail;
36286 }
36287 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
36288 return resultobj;
36289 fail:
36290 return NULL;
36291 }
36292
36293
36294 SWIGINTERN PyObject *_wrap_Display_GetFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36295 PyObject *resultobj = 0;
36296 wxPoint *arg1 = 0 ;
36297 int result;
36298 wxPoint temp1 ;
36299 PyObject * obj0 = 0 ;
36300 char * kwnames[] = {
36301 (char *) "pt", NULL
36302 };
36303
36304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) SWIG_fail;
36305 {
36306 arg1 = &temp1;
36307 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
36308 }
36309 {
36310 PyThreadState* __tstate = wxPyBeginAllowThreads();
36311 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
36312 wxPyEndAllowThreads(__tstate);
36313 if (PyErr_Occurred()) SWIG_fail;
36314 }
36315 resultobj = SWIG_From_int(static_cast< int >(result));
36316 return resultobj;
36317 fail:
36318 return NULL;
36319 }
36320
36321
36322 SWIGINTERN PyObject *_wrap_Display_GetFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36323 PyObject *resultobj = 0;
36324 wxWindow *arg1 = (wxWindow *) 0 ;
36325 int result;
36326 void *argp1 = 0 ;
36327 int res1 = 0 ;
36328 PyObject * obj0 = 0 ;
36329 char * kwnames[] = {
36330 (char *) "window", NULL
36331 };
36332
36333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) SWIG_fail;
36334 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36335 if (!SWIG_IsOK(res1)) {
36336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36337 }
36338 arg1 = reinterpret_cast< wxWindow * >(argp1);
36339 {
36340 PyThreadState* __tstate = wxPyBeginAllowThreads();
36341 result = (int)wxDisplay::GetFromWindow(arg1);
36342 wxPyEndAllowThreads(__tstate);
36343 if (PyErr_Occurred()) SWIG_fail;
36344 }
36345 resultobj = SWIG_From_int(static_cast< int >(result));
36346 return resultobj;
36347 fail:
36348 return NULL;
36349 }
36350
36351
36352 SWIGINTERN PyObject *_wrap_Display_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36353 PyObject *resultobj = 0;
36354 wxDisplay *arg1 = (wxDisplay *) 0 ;
36355 bool result;
36356 void *argp1 = 0 ;
36357 int res1 = 0 ;
36358 PyObject *swig_obj[1] ;
36359
36360 if (!args) SWIG_fail;
36361 swig_obj[0] = args;
36362 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36363 if (!SWIG_IsOK(res1)) {
36364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsOk" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36365 }
36366 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36367 {
36368 PyThreadState* __tstate = wxPyBeginAllowThreads();
36369 result = (bool)((wxDisplay const *)arg1)->IsOk();
36370 wxPyEndAllowThreads(__tstate);
36371 if (PyErr_Occurred()) SWIG_fail;
36372 }
36373 {
36374 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36375 }
36376 return resultobj;
36377 fail:
36378 return NULL;
36379 }
36380
36381
36382 SWIGINTERN PyObject *_wrap_Display_GetGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36383 PyObject *resultobj = 0;
36384 wxDisplay *arg1 = (wxDisplay *) 0 ;
36385 wxRect result;
36386 void *argp1 = 0 ;
36387 int res1 = 0 ;
36388 PyObject *swig_obj[1] ;
36389
36390 if (!args) SWIG_fail;
36391 swig_obj[0] = args;
36392 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36393 if (!SWIG_IsOK(res1)) {
36394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetGeometry" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36395 }
36396 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36397 {
36398 PyThreadState* __tstate = wxPyBeginAllowThreads();
36399 result = ((wxDisplay const *)arg1)->GetGeometry();
36400 wxPyEndAllowThreads(__tstate);
36401 if (PyErr_Occurred()) SWIG_fail;
36402 }
36403 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
36404 return resultobj;
36405 fail:
36406 return NULL;
36407 }
36408
36409
36410 SWIGINTERN PyObject *_wrap_Display_GetClientArea(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36411 PyObject *resultobj = 0;
36412 wxDisplay *arg1 = (wxDisplay *) 0 ;
36413 wxRect result;
36414 void *argp1 = 0 ;
36415 int res1 = 0 ;
36416 PyObject *swig_obj[1] ;
36417
36418 if (!args) SWIG_fail;
36419 swig_obj[0] = args;
36420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36421 if (!SWIG_IsOK(res1)) {
36422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetClientArea" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36423 }
36424 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36425 {
36426 PyThreadState* __tstate = wxPyBeginAllowThreads();
36427 result = ((wxDisplay const *)arg1)->GetClientArea();
36428 wxPyEndAllowThreads(__tstate);
36429 if (PyErr_Occurred()) SWIG_fail;
36430 }
36431 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
36432 return resultobj;
36433 fail:
36434 return NULL;
36435 }
36436
36437
36438 SWIGINTERN PyObject *_wrap_Display_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36439 PyObject *resultobj = 0;
36440 wxDisplay *arg1 = (wxDisplay *) 0 ;
36441 wxString result;
36442 void *argp1 = 0 ;
36443 int res1 = 0 ;
36444 PyObject *swig_obj[1] ;
36445
36446 if (!args) SWIG_fail;
36447 swig_obj[0] = args;
36448 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36449 if (!SWIG_IsOK(res1)) {
36450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetName" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36451 }
36452 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36453 {
36454 PyThreadState* __tstate = wxPyBeginAllowThreads();
36455 result = ((wxDisplay const *)arg1)->GetName();
36456 wxPyEndAllowThreads(__tstate);
36457 if (PyErr_Occurred()) SWIG_fail;
36458 }
36459 {
36460 #if wxUSE_UNICODE
36461 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36462 #else
36463 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36464 #endif
36465 }
36466 return resultobj;
36467 fail:
36468 return NULL;
36469 }
36470
36471
36472 SWIGINTERN PyObject *_wrap_Display_IsPrimary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36473 PyObject *resultobj = 0;
36474 wxDisplay *arg1 = (wxDisplay *) 0 ;
36475 bool result;
36476 void *argp1 = 0 ;
36477 int res1 = 0 ;
36478 PyObject *swig_obj[1] ;
36479
36480 if (!args) SWIG_fail;
36481 swig_obj[0] = args;
36482 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36483 if (!SWIG_IsOK(res1)) {
36484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsPrimary" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36485 }
36486 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36487 {
36488 PyThreadState* __tstate = wxPyBeginAllowThreads();
36489 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
36490 wxPyEndAllowThreads(__tstate);
36491 if (PyErr_Occurred()) SWIG_fail;
36492 }
36493 {
36494 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36495 }
36496 return resultobj;
36497 fail:
36498 return NULL;
36499 }
36500
36501
36502 SWIGINTERN PyObject *_wrap_Display_GetModes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36503 PyObject *resultobj = 0;
36504 wxDisplay *arg1 = (wxDisplay *) 0 ;
36505 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
36506 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
36507 PyObject *result = 0 ;
36508 void *argp1 = 0 ;
36509 int res1 = 0 ;
36510 void *argp2 = 0 ;
36511 int res2 = 0 ;
36512 PyObject * obj0 = 0 ;
36513 PyObject * obj1 = 0 ;
36514 char * kwnames[] = {
36515 (char *) "self",(char *) "mode", NULL
36516 };
36517
36518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) SWIG_fail;
36519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36520 if (!SWIG_IsOK(res1)) {
36521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetModes" "', expected argument " "1"" of type '" "wxDisplay *""'");
36522 }
36523 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36524 if (obj1) {
36525 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
36526 if (!SWIG_IsOK(res2)) {
36527 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36528 }
36529 if (!argp2) {
36530 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36531 }
36532 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36533 }
36534 {
36535 PyThreadState* __tstate = wxPyBeginAllowThreads();
36536 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
36537 wxPyEndAllowThreads(__tstate);
36538 if (PyErr_Occurred()) SWIG_fail;
36539 }
36540 resultobj = result;
36541 return resultobj;
36542 fail:
36543 return NULL;
36544 }
36545
36546
36547 SWIGINTERN PyObject *_wrap_Display_GetCurrentMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36548 PyObject *resultobj = 0;
36549 wxDisplay *arg1 = (wxDisplay *) 0 ;
36550 wxVideoMode result;
36551 void *argp1 = 0 ;
36552 int res1 = 0 ;
36553 PyObject *swig_obj[1] ;
36554
36555 if (!args) SWIG_fail;
36556 swig_obj[0] = args;
36557 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36558 if (!SWIG_IsOK(res1)) {
36559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetCurrentMode" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36560 }
36561 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36562 {
36563 PyThreadState* __tstate = wxPyBeginAllowThreads();
36564 result = wxDisplay_GetCurrentMode((wxDisplay const *)arg1);
36565 wxPyEndAllowThreads(__tstate);
36566 if (PyErr_Occurred()) SWIG_fail;
36567 }
36568 resultobj = SWIG_NewPointerObj((new wxVideoMode(static_cast< const wxVideoMode& >(result))), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_OWN | 0 );
36569 return resultobj;
36570 fail:
36571 return NULL;
36572 }
36573
36574
36575 SWIGINTERN PyObject *_wrap_Display_ChangeMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36576 PyObject *resultobj = 0;
36577 wxDisplay *arg1 = (wxDisplay *) 0 ;
36578 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
36579 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
36580 bool result;
36581 void *argp1 = 0 ;
36582 int res1 = 0 ;
36583 void *argp2 = 0 ;
36584 int res2 = 0 ;
36585 PyObject * obj0 = 0 ;
36586 PyObject * obj1 = 0 ;
36587 char * kwnames[] = {
36588 (char *) "self",(char *) "mode", NULL
36589 };
36590
36591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) SWIG_fail;
36592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36593 if (!SWIG_IsOK(res1)) {
36594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ChangeMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
36595 }
36596 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36597 if (obj1) {
36598 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
36599 if (!SWIG_IsOK(res2)) {
36600 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36601 }
36602 if (!argp2) {
36603 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36604 }
36605 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36606 }
36607 {
36608 PyThreadState* __tstate = wxPyBeginAllowThreads();
36609 result = (bool)wxDisplay_ChangeMode(arg1,(wxVideoMode const &)*arg2);
36610 wxPyEndAllowThreads(__tstate);
36611 if (PyErr_Occurred()) SWIG_fail;
36612 }
36613 {
36614 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36615 }
36616 return resultobj;
36617 fail:
36618 return NULL;
36619 }
36620
36621
36622 SWIGINTERN PyObject *_wrap_Display_ResetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36623 PyObject *resultobj = 0;
36624 wxDisplay *arg1 = (wxDisplay *) 0 ;
36625 void *argp1 = 0 ;
36626 int res1 = 0 ;
36627 PyObject *swig_obj[1] ;
36628
36629 if (!args) SWIG_fail;
36630 swig_obj[0] = args;
36631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36632 if (!SWIG_IsOK(res1)) {
36633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ResetMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
36634 }
36635 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36636 {
36637 PyThreadState* __tstate = wxPyBeginAllowThreads();
36638 wxDisplay_ResetMode(arg1);
36639 wxPyEndAllowThreads(__tstate);
36640 if (PyErr_Occurred()) SWIG_fail;
36641 }
36642 resultobj = SWIG_Py_Void();
36643 return resultobj;
36644 fail:
36645 return NULL;
36646 }
36647
36648
36649 SWIGINTERN PyObject *Display_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36650 PyObject *obj;
36651 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
36652 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplay, SWIG_NewClientData(obj));
36653 return SWIG_Py_Void();
36654 }
36655
36656 SWIGINTERN PyObject *Display_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36657 return SWIG_Python_InitShadowInstance(args);
36658 }
36659
36660 SWIGINTERN PyObject *_wrap_StandardPaths_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36661 PyObject *resultobj = 0;
36662 wxStandardPaths *result = 0 ;
36663
36664 if (!SWIG_Python_UnpackTuple(args,"StandardPaths_Get",0,0,0)) SWIG_fail;
36665 {
36666 PyThreadState* __tstate = wxPyBeginAllowThreads();
36667 result = (wxStandardPaths *)wxStandardPaths_Get();
36668 wxPyEndAllowThreads(__tstate);
36669 if (PyErr_Occurred()) SWIG_fail;
36670 }
36671 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36672 return resultobj;
36673 fail:
36674 return NULL;
36675 }
36676
36677
36678 SWIGINTERN PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36679 PyObject *resultobj = 0;
36680 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36681 wxString result;
36682 void *argp1 = 0 ;
36683 int res1 = 0 ;
36684 PyObject *swig_obj[1] ;
36685
36686 if (!args) SWIG_fail;
36687 swig_obj[0] = args;
36688 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36689 if (!SWIG_IsOK(res1)) {
36690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36691 }
36692 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36693 {
36694 PyThreadState* __tstate = wxPyBeginAllowThreads();
36695 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
36696 wxPyEndAllowThreads(__tstate);
36697 if (PyErr_Occurred()) SWIG_fail;
36698 }
36699 {
36700 #if wxUSE_UNICODE
36701 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36702 #else
36703 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36704 #endif
36705 }
36706 return resultobj;
36707 fail:
36708 return NULL;
36709 }
36710
36711
36712 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36713 PyObject *resultobj = 0;
36714 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36715 wxString result;
36716 void *argp1 = 0 ;
36717 int res1 = 0 ;
36718 PyObject *swig_obj[1] ;
36719
36720 if (!args) SWIG_fail;
36721 swig_obj[0] = args;
36722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36723 if (!SWIG_IsOK(res1)) {
36724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36725 }
36726 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36727 {
36728 PyThreadState* __tstate = wxPyBeginAllowThreads();
36729 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
36730 wxPyEndAllowThreads(__tstate);
36731 if (PyErr_Occurred()) SWIG_fail;
36732 }
36733 {
36734 #if wxUSE_UNICODE
36735 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36736 #else
36737 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36738 #endif
36739 }
36740 return resultobj;
36741 fail:
36742 return NULL;
36743 }
36744
36745
36746 SWIGINTERN PyObject *_wrap_StandardPaths_GetDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36747 PyObject *resultobj = 0;
36748 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36749 wxString result;
36750 void *argp1 = 0 ;
36751 int res1 = 0 ;
36752 PyObject *swig_obj[1] ;
36753
36754 if (!args) SWIG_fail;
36755 swig_obj[0] = args;
36756 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36757 if (!SWIG_IsOK(res1)) {
36758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36759 }
36760 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36761 {
36762 PyThreadState* __tstate = wxPyBeginAllowThreads();
36763 result = ((wxStandardPaths const *)arg1)->GetDataDir();
36764 wxPyEndAllowThreads(__tstate);
36765 if (PyErr_Occurred()) SWIG_fail;
36766 }
36767 {
36768 #if wxUSE_UNICODE
36769 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36770 #else
36771 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36772 #endif
36773 }
36774 return resultobj;
36775 fail:
36776 return NULL;
36777 }
36778
36779
36780 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36781 PyObject *resultobj = 0;
36782 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36783 wxString result;
36784 void *argp1 = 0 ;
36785 int res1 = 0 ;
36786 PyObject *swig_obj[1] ;
36787
36788 if (!args) SWIG_fail;
36789 swig_obj[0] = args;
36790 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36791 if (!SWIG_IsOK(res1)) {
36792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36793 }
36794 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36795 {
36796 PyThreadState* __tstate = wxPyBeginAllowThreads();
36797 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
36798 wxPyEndAllowThreads(__tstate);
36799 if (PyErr_Occurred()) SWIG_fail;
36800 }
36801 {
36802 #if wxUSE_UNICODE
36803 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36804 #else
36805 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36806 #endif
36807 }
36808 return resultobj;
36809 fail:
36810 return NULL;
36811 }
36812
36813
36814 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36815 PyObject *resultobj = 0;
36816 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36817 wxString result;
36818 void *argp1 = 0 ;
36819 int res1 = 0 ;
36820 PyObject *swig_obj[1] ;
36821
36822 if (!args) SWIG_fail;
36823 swig_obj[0] = args;
36824 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36825 if (!SWIG_IsOK(res1)) {
36826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36827 }
36828 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36829 {
36830 PyThreadState* __tstate = wxPyBeginAllowThreads();
36831 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
36832 wxPyEndAllowThreads(__tstate);
36833 if (PyErr_Occurred()) SWIG_fail;
36834 }
36835 {
36836 #if wxUSE_UNICODE
36837 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36838 #else
36839 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36840 #endif
36841 }
36842 return resultobj;
36843 fail:
36844 return NULL;
36845 }
36846
36847
36848 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36849 PyObject *resultobj = 0;
36850 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36851 wxString result;
36852 void *argp1 = 0 ;
36853 int res1 = 0 ;
36854 PyObject *swig_obj[1] ;
36855
36856 if (!args) SWIG_fail;
36857 swig_obj[0] = args;
36858 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36859 if (!SWIG_IsOK(res1)) {
36860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36861 }
36862 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36863 {
36864 PyThreadState* __tstate = wxPyBeginAllowThreads();
36865 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
36866 wxPyEndAllowThreads(__tstate);
36867 if (PyErr_Occurred()) SWIG_fail;
36868 }
36869 {
36870 #if wxUSE_UNICODE
36871 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36872 #else
36873 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36874 #endif
36875 }
36876 return resultobj;
36877 fail:
36878 return NULL;
36879 }
36880
36881
36882 SWIGINTERN PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36883 PyObject *resultobj = 0;
36884 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36885 wxString result;
36886 void *argp1 = 0 ;
36887 int res1 = 0 ;
36888 PyObject *swig_obj[1] ;
36889
36890 if (!args) SWIG_fail;
36891 swig_obj[0] = args;
36892 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36893 if (!SWIG_IsOK(res1)) {
36894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetPluginsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36895 }
36896 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36897 {
36898 PyThreadState* __tstate = wxPyBeginAllowThreads();
36899 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
36900 wxPyEndAllowThreads(__tstate);
36901 if (PyErr_Occurred()) SWIG_fail;
36902 }
36903 {
36904 #if wxUSE_UNICODE
36905 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36906 #else
36907 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36908 #endif
36909 }
36910 return resultobj;
36911 fail:
36912 return NULL;
36913 }
36914
36915
36916 SWIGINTERN PyObject *_wrap_StandardPaths_GetResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36917 PyObject *resultobj = 0;
36918 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36919 wxString result;
36920 void *argp1 = 0 ;
36921 int res1 = 0 ;
36922 PyObject *swig_obj[1] ;
36923
36924 if (!args) SWIG_fail;
36925 swig_obj[0] = args;
36926 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36927 if (!SWIG_IsOK(res1)) {
36928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36929 }
36930 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36931 {
36932 PyThreadState* __tstate = wxPyBeginAllowThreads();
36933 result = ((wxStandardPaths const *)arg1)->GetResourcesDir();
36934 wxPyEndAllowThreads(__tstate);
36935 if (PyErr_Occurred()) SWIG_fail;
36936 }
36937 {
36938 #if wxUSE_UNICODE
36939 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36940 #else
36941 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36942 #endif
36943 }
36944 return resultobj;
36945 fail:
36946 return NULL;
36947 }
36948
36949
36950 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalizedResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36951 PyObject *resultobj = 0;
36952 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36953 wxString *arg2 = 0 ;
36954 wxStandardPaths::ResourceCat arg3 = (wxStandardPaths::ResourceCat) wxStandardPaths::ResourceCat_None ;
36955 wxString result;
36956 void *argp1 = 0 ;
36957 int res1 = 0 ;
36958 bool temp2 = false ;
36959 int val3 ;
36960 int ecode3 = 0 ;
36961 PyObject * obj0 = 0 ;
36962 PyObject * obj1 = 0 ;
36963 PyObject * obj2 = 0 ;
36964 char * kwnames[] = {
36965 (char *) "self",(char *) "lang",(char *) "category", NULL
36966 };
36967
36968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:StandardPaths_GetLocalizedResourcesDir",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36970 if (!SWIG_IsOK(res1)) {
36971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36972 }
36973 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36974 {
36975 arg2 = wxString_in_helper(obj1);
36976 if (arg2 == NULL) SWIG_fail;
36977 temp2 = true;
36978 }
36979 if (obj2) {
36980 ecode3 = SWIG_AsVal_int(obj2, &val3);
36981 if (!SWIG_IsOK(ecode3)) {
36982 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "3"" of type '" "wxStandardPaths::ResourceCat""'");
36983 }
36984 arg3 = static_cast< wxStandardPaths::ResourceCat >(val3);
36985 }
36986 {
36987 PyThreadState* __tstate = wxPyBeginAllowThreads();
36988 result = ((wxStandardPaths const *)arg1)->GetLocalizedResourcesDir((wxString const &)*arg2,arg3);
36989 wxPyEndAllowThreads(__tstate);
36990 if (PyErr_Occurred()) SWIG_fail;
36991 }
36992 {
36993 #if wxUSE_UNICODE
36994 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36995 #else
36996 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36997 #endif
36998 }
36999 {
37000 if (temp2)
37001 delete arg2;
37002 }
37003 return resultobj;
37004 fail:
37005 {
37006 if (temp2)
37007 delete arg2;
37008 }
37009 return NULL;
37010 }
37011
37012
37013 SWIGINTERN PyObject *_wrap_StandardPaths_GetDocumentsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37014 PyObject *resultobj = 0;
37015 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37016 wxString result;
37017 void *argp1 = 0 ;
37018 int res1 = 0 ;
37019 PyObject *swig_obj[1] ;
37020
37021 if (!args) SWIG_fail;
37022 swig_obj[0] = args;
37023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37024 if (!SWIG_IsOK(res1)) {
37025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDocumentsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37026 }
37027 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37028 {
37029 PyThreadState* __tstate = wxPyBeginAllowThreads();
37030 result = ((wxStandardPaths const *)arg1)->GetDocumentsDir();
37031 wxPyEndAllowThreads(__tstate);
37032 if (PyErr_Occurred()) SWIG_fail;
37033 }
37034 {
37035 #if wxUSE_UNICODE
37036 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37037 #else
37038 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37039 #endif
37040 }
37041 return resultobj;
37042 fail:
37043 return NULL;
37044 }
37045
37046
37047 SWIGINTERN PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37048 PyObject *resultobj = 0;
37049 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37050 wxString *arg2 = 0 ;
37051 void *argp1 = 0 ;
37052 int res1 = 0 ;
37053 bool temp2 = false ;
37054 PyObject * obj0 = 0 ;
37055 PyObject * obj1 = 0 ;
37056 char * kwnames[] = {
37057 (char *) "self",(char *) "prefix", NULL
37058 };
37059
37060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) SWIG_fail;
37061 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37062 if (!SWIG_IsOK(res1)) {
37063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_SetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths *""'");
37064 }
37065 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37066 {
37067 arg2 = wxString_in_helper(obj1);
37068 if (arg2 == NULL) SWIG_fail;
37069 temp2 = true;
37070 }
37071 {
37072 PyThreadState* __tstate = wxPyBeginAllowThreads();
37073 wxStandardPaths_SetInstallPrefix(arg1,(wxString const &)*arg2);
37074 wxPyEndAllowThreads(__tstate);
37075 if (PyErr_Occurred()) SWIG_fail;
37076 }
37077 resultobj = SWIG_Py_Void();
37078 {
37079 if (temp2)
37080 delete arg2;
37081 }
37082 return resultobj;
37083 fail:
37084 {
37085 if (temp2)
37086 delete arg2;
37087 }
37088 return NULL;
37089 }
37090
37091
37092 SWIGINTERN PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37093 PyObject *resultobj = 0;
37094 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37095 wxString result;
37096 void *argp1 = 0 ;
37097 int res1 = 0 ;
37098 PyObject *swig_obj[1] ;
37099
37100 if (!args) SWIG_fail;
37101 swig_obj[0] = args;
37102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37103 if (!SWIG_IsOK(res1)) {
37104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths *""'");
37105 }
37106 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37107 {
37108 PyThreadState* __tstate = wxPyBeginAllowThreads();
37109 result = wxStandardPaths_GetInstallPrefix(arg1);
37110 wxPyEndAllowThreads(__tstate);
37111 if (PyErr_Occurred()) SWIG_fail;
37112 }
37113 {
37114 #if wxUSE_UNICODE
37115 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37116 #else
37117 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37118 #endif
37119 }
37120 return resultobj;
37121 fail:
37122 return NULL;
37123 }
37124
37125
37126 SWIGINTERN PyObject *StandardPaths_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37127 PyObject *obj;
37128 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37129 SWIG_TypeNewClientData(SWIGTYPE_p_wxStandardPaths, SWIG_NewClientData(obj));
37130 return SWIG_Py_Void();
37131 }
37132
37133 SWIGINTERN PyObject *_wrap_new_PowerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37134 PyObject *resultobj = 0;
37135 wxEventType arg1 ;
37136 wxPowerEvent *result = 0 ;
37137 int val1 ;
37138 int ecode1 = 0 ;
37139 PyObject * obj0 = 0 ;
37140 char * kwnames[] = {
37141 (char *) "evtType", NULL
37142 };
37143
37144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PowerEvent",kwnames,&obj0)) SWIG_fail;
37145 ecode1 = SWIG_AsVal_int(obj0, &val1);
37146 if (!SWIG_IsOK(ecode1)) {
37147 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PowerEvent" "', expected argument " "1"" of type '" "wxEventType""'");
37148 }
37149 arg1 = static_cast< wxEventType >(val1);
37150 {
37151 PyThreadState* __tstate = wxPyBeginAllowThreads();
37152 result = (wxPowerEvent *)new wxPowerEvent(arg1);
37153 wxPyEndAllowThreads(__tstate);
37154 if (PyErr_Occurred()) SWIG_fail;
37155 }
37156 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPowerEvent, SWIG_POINTER_NEW | 0 );
37157 return resultobj;
37158 fail:
37159 return NULL;
37160 }
37161
37162
37163 SWIGINTERN PyObject *_wrap_PowerEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37164 PyObject *resultobj = 0;
37165 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
37166 void *argp1 = 0 ;
37167 int res1 = 0 ;
37168 PyObject *swig_obj[1] ;
37169
37170 if (!args) SWIG_fail;
37171 swig_obj[0] = args;
37172 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPowerEvent, 0 | 0 );
37173 if (!SWIG_IsOK(res1)) {
37174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_Veto" "', expected argument " "1"" of type '" "wxPowerEvent *""'");
37175 }
37176 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
37177 {
37178 PyThreadState* __tstate = wxPyBeginAllowThreads();
37179 (arg1)->Veto();
37180 wxPyEndAllowThreads(__tstate);
37181 if (PyErr_Occurred()) SWIG_fail;
37182 }
37183 resultobj = SWIG_Py_Void();
37184 return resultobj;
37185 fail:
37186 return NULL;
37187 }
37188
37189
37190 SWIGINTERN PyObject *_wrap_PowerEvent_IsVetoed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37191 PyObject *resultobj = 0;
37192 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
37193 bool result;
37194 void *argp1 = 0 ;
37195 int res1 = 0 ;
37196 PyObject *swig_obj[1] ;
37197
37198 if (!args) SWIG_fail;
37199 swig_obj[0] = args;
37200 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPowerEvent, 0 | 0 );
37201 if (!SWIG_IsOK(res1)) {
37202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_IsVetoed" "', expected argument " "1"" of type '" "wxPowerEvent const *""'");
37203 }
37204 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
37205 {
37206 PyThreadState* __tstate = wxPyBeginAllowThreads();
37207 result = (bool)((wxPowerEvent const *)arg1)->IsVetoed();
37208 wxPyEndAllowThreads(__tstate);
37209 if (PyErr_Occurred()) SWIG_fail;
37210 }
37211 {
37212 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37213 }
37214 return resultobj;
37215 fail:
37216 return NULL;
37217 }
37218
37219
37220 SWIGINTERN PyObject *PowerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37221 PyObject *obj;
37222 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37223 SWIG_TypeNewClientData(SWIGTYPE_p_wxPowerEvent, SWIG_NewClientData(obj));
37224 return SWIG_Py_Void();
37225 }
37226
37227 SWIGINTERN PyObject *PowerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37228 return SWIG_Python_InitShadowInstance(args);
37229 }
37230
37231 SWIGINTERN PyObject *_wrap_GetPowerType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37232 PyObject *resultobj = 0;
37233 wxPowerType result;
37234
37235 if (!SWIG_Python_UnpackTuple(args,"GetPowerType",0,0,0)) SWIG_fail;
37236 {
37237 PyThreadState* __tstate = wxPyBeginAllowThreads();
37238 result = (wxPowerType)wxGetPowerType();
37239 wxPyEndAllowThreads(__tstate);
37240 if (PyErr_Occurred()) SWIG_fail;
37241 }
37242 resultobj = SWIG_From_int(static_cast< int >(result));
37243 return resultobj;
37244 fail:
37245 return NULL;
37246 }
37247
37248
37249 SWIGINTERN PyObject *_wrap_GetBatteryState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37250 PyObject *resultobj = 0;
37251 wxBatteryState result;
37252
37253 if (!SWIG_Python_UnpackTuple(args,"GetBatteryState",0,0,0)) SWIG_fail;
37254 {
37255 PyThreadState* __tstate = wxPyBeginAllowThreads();
37256 result = (wxBatteryState)wxGetBatteryState();
37257 wxPyEndAllowThreads(__tstate);
37258 if (PyErr_Occurred()) SWIG_fail;
37259 }
37260 resultobj = SWIG_From_int(static_cast< int >(result));
37261 return resultobj;
37262 fail:
37263 return NULL;
37264 }
37265
37266
37267 static PyMethodDef SwigMethods[] = {
37268 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
37269 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
37270 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
37271 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
37272 { (char *)"SystemSettings_GetScreenType", (PyCFunction)_wrap_SystemSettings_GetScreenType, METH_NOARGS, NULL},
37273 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
37274 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
37275 { (char *)"new_SystemOptions", (PyCFunction)_wrap_new_SystemOptions, METH_NOARGS, NULL},
37276 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
37277 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
37278 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
37279 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
37280 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
37281 { (char *)"SystemOptions_IsFalse", (PyCFunction) _wrap_SystemOptions_IsFalse, METH_VARARGS | METH_KEYWORDS, NULL},
37282 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
37283 { (char *)"SystemOptions_swiginit", SystemOptions_swiginit, METH_VARARGS, NULL},
37284 { (char *)"NewId", (PyCFunction)_wrap_NewId, METH_NOARGS, NULL},
37285 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
37286 { (char *)"GetCurrentId", (PyCFunction)_wrap_GetCurrentId, METH_NOARGS, NULL},
37287 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
37288 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
37289 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
37290 { (char *)"Bell", (PyCFunction)_wrap_Bell, METH_NOARGS, NULL},
37291 { (char *)"EndBusyCursor", (PyCFunction)_wrap_EndBusyCursor, METH_NOARGS, NULL},
37292 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
37293 { (char *)"IsBusy", (PyCFunction)_wrap_IsBusy, METH_NOARGS, NULL},
37294 { (char *)"Now", (PyCFunction)_wrap_Now, METH_NOARGS, NULL},
37295 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
37296 { (char *)"StartTimer", (PyCFunction)_wrap_StartTimer, METH_NOARGS, NULL},
37297 { (char *)"GetOsVersion", (PyCFunction)_wrap_GetOsVersion, METH_NOARGS, NULL},
37298 { (char *)"GetOsDescription", (PyCFunction)_wrap_GetOsDescription, METH_NOARGS, NULL},
37299 { (char *)"IsPlatformLittleEndian", (PyCFunction)_wrap_IsPlatformLittleEndian, METH_NOARGS, NULL},
37300 { (char *)"IsPlatform64Bit", (PyCFunction)_wrap_IsPlatform64Bit, METH_NOARGS, NULL},
37301 { (char *)"GetFreeMemory", (PyCFunction)_wrap_GetFreeMemory, METH_NOARGS, NULL},
37302 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
37303 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
37304 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
37305 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
37306 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
37307 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
37308 { (char *)"GetEmailAddress", (PyCFunction)_wrap_GetEmailAddress, METH_NOARGS, NULL},
37309 { (char *)"GetHostName", (PyCFunction)_wrap_GetHostName, METH_NOARGS, NULL},
37310 { (char *)"GetFullHostName", (PyCFunction)_wrap_GetFullHostName, METH_NOARGS, NULL},
37311 { (char *)"GetUserId", (PyCFunction)_wrap_GetUserId, METH_NOARGS, NULL},
37312 { (char *)"GetUserName", (PyCFunction)_wrap_GetUserName, METH_NOARGS, NULL},
37313 { (char *)"GetHomeDir", (PyCFunction)_wrap_GetHomeDir, METH_NOARGS, NULL},
37314 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
37315 { (char *)"GetProcessId", (PyCFunction)_wrap_GetProcessId, METH_NOARGS, NULL},
37316 { (char *)"Trap", (PyCFunction)_wrap_Trap, METH_NOARGS, NULL},
37317 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
37318 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
37319 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
37320 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
37321 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
37322 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
37323 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
37324 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
37325 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
37326 { (char *)"GetNumberFromUser", (PyCFunction) _wrap_GetNumberFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
37327 { (char *)"ColourDisplay", (PyCFunction)_wrap_ColourDisplay, METH_NOARGS, NULL},
37328 { (char *)"DisplayDepth", (PyCFunction)_wrap_DisplayDepth, METH_NOARGS, NULL},
37329 { (char *)"GetDisplayDepth", (PyCFunction)_wrap_GetDisplayDepth, METH_NOARGS, NULL},
37330 { (char *)"DisplaySize", (PyCFunction)_wrap_DisplaySize, METH_NOARGS, NULL},
37331 { (char *)"GetDisplaySize", (PyCFunction)_wrap_GetDisplaySize, METH_NOARGS, NULL},
37332 { (char *)"DisplaySizeMM", (PyCFunction)_wrap_DisplaySizeMM, METH_NOARGS, NULL},
37333 { (char *)"GetDisplaySizeMM", (PyCFunction)_wrap_GetDisplaySizeMM, METH_NOARGS, NULL},
37334 { (char *)"ClientDisplayRect", (PyCFunction)_wrap_ClientDisplayRect, METH_NOARGS, NULL},
37335 { (char *)"GetClientDisplayRect", (PyCFunction)_wrap_GetClientDisplayRect, METH_NOARGS, NULL},
37336 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
37337 { (char *)"GetXDisplay", (PyCFunction)_wrap_GetXDisplay, METH_NOARGS, NULL},
37338 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
37339 { (char *)"GetMousePosition", (PyCFunction)_wrap_GetMousePosition, METH_NOARGS, NULL},
37340 { (char *)"FindWindowAtPointer", (PyCFunction)_wrap_FindWindowAtPointer, METH_NOARGS, NULL},
37341 { (char *)"GetActiveWindow", (PyCFunction)_wrap_GetActiveWindow, METH_NOARGS, NULL},
37342 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
37343 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
37344 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
37345 { (char *)"LaunchDefaultBrowser", (PyCFunction) _wrap_LaunchDefaultBrowser, METH_VARARGS | METH_KEYWORDS, NULL},
37346 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
37347 { (char *)"new_MouseState", (PyCFunction)_wrap_new_MouseState, METH_NOARGS, NULL},
37348 { (char *)"delete_MouseState", (PyCFunction)_wrap_delete_MouseState, METH_O, NULL},
37349 { (char *)"MouseState_GetX", (PyCFunction)_wrap_MouseState_GetX, METH_O, NULL},
37350 { (char *)"MouseState_GetY", (PyCFunction)_wrap_MouseState_GetY, METH_O, NULL},
37351 { (char *)"MouseState_LeftDown", (PyCFunction)_wrap_MouseState_LeftDown, METH_O, NULL},
37352 { (char *)"MouseState_MiddleDown", (PyCFunction)_wrap_MouseState_MiddleDown, METH_O, NULL},
37353 { (char *)"MouseState_RightDown", (PyCFunction)_wrap_MouseState_RightDown, METH_O, NULL},
37354 { (char *)"MouseState_ControlDown", (PyCFunction)_wrap_MouseState_ControlDown, METH_O, NULL},
37355 { (char *)"MouseState_ShiftDown", (PyCFunction)_wrap_MouseState_ShiftDown, METH_O, NULL},
37356 { (char *)"MouseState_AltDown", (PyCFunction)_wrap_MouseState_AltDown, METH_O, NULL},
37357 { (char *)"MouseState_MetaDown", (PyCFunction)_wrap_MouseState_MetaDown, METH_O, NULL},
37358 { (char *)"MouseState_CmdDown", (PyCFunction)_wrap_MouseState_CmdDown, METH_O, NULL},
37359 { (char *)"MouseState_SetX", (PyCFunction) _wrap_MouseState_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
37360 { (char *)"MouseState_SetY", (PyCFunction) _wrap_MouseState_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
37361 { (char *)"MouseState_SetLeftDown", (PyCFunction) _wrap_MouseState_SetLeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
37362 { (char *)"MouseState_SetMiddleDown", (PyCFunction) _wrap_MouseState_SetMiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
37363 { (char *)"MouseState_SetRightDown", (PyCFunction) _wrap_MouseState_SetRightDown, METH_VARARGS | METH_KEYWORDS, NULL},
37364 { (char *)"MouseState_SetControlDown", (PyCFunction) _wrap_MouseState_SetControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
37365 { (char *)"MouseState_SetShiftDown", (PyCFunction) _wrap_MouseState_SetShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
37366 { (char *)"MouseState_SetAltDown", (PyCFunction) _wrap_MouseState_SetAltDown, METH_VARARGS | METH_KEYWORDS, NULL},
37367 { (char *)"MouseState_SetMetaDown", (PyCFunction) _wrap_MouseState_SetMetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
37368 { (char *)"MouseState_swigregister", MouseState_swigregister, METH_VARARGS, NULL},
37369 { (char *)"MouseState_swiginit", MouseState_swiginit, METH_VARARGS, NULL},
37370 { (char *)"GetMouseState", (PyCFunction)_wrap_GetMouseState, METH_NOARGS, NULL},
37371 { (char *)"WakeUpMainThread", (PyCFunction)_wrap_WakeUpMainThread, METH_NOARGS, NULL},
37372 { (char *)"MutexGuiEnter", (PyCFunction)_wrap_MutexGuiEnter, METH_NOARGS, NULL},
37373 { (char *)"MutexGuiLeave", (PyCFunction)_wrap_MutexGuiLeave, METH_NOARGS, NULL},
37374 { (char *)"new_MutexGuiLocker", (PyCFunction)_wrap_new_MutexGuiLocker, METH_NOARGS, NULL},
37375 { (char *)"delete_MutexGuiLocker", (PyCFunction)_wrap_delete_MutexGuiLocker, METH_O, NULL},
37376 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
37377 { (char *)"MutexGuiLocker_swiginit", MutexGuiLocker_swiginit, METH_VARARGS, NULL},
37378 { (char *)"Thread_IsMain", (PyCFunction)_wrap_Thread_IsMain, METH_NOARGS, NULL},
37379 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
37380 { (char *)"delete_ToolTip", (PyCFunction)_wrap_delete_ToolTip, METH_O, NULL},
37381 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
37382 { (char *)"ToolTip_GetTip", (PyCFunction)_wrap_ToolTip_GetTip, METH_O, NULL},
37383 { (char *)"ToolTip_GetWindow", (PyCFunction)_wrap_ToolTip_GetWindow, METH_O, NULL},
37384 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
37385 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
37386 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
37387 { (char *)"ToolTip_swiginit", ToolTip_swiginit, METH_VARARGS, NULL},
37388 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
37389 { (char *)"delete_Caret", (PyCFunction)_wrap_delete_Caret, METH_O, NULL},
37390 { (char *)"Caret_Destroy", (PyCFunction)_wrap_Caret_Destroy, METH_O, NULL},
37391 { (char *)"Caret_IsOk", (PyCFunction)_wrap_Caret_IsOk, METH_O, NULL},
37392 { (char *)"Caret_IsVisible", (PyCFunction)_wrap_Caret_IsVisible, METH_O, NULL},
37393 { (char *)"Caret_GetPosition", (PyCFunction)_wrap_Caret_GetPosition, METH_O, NULL},
37394 { (char *)"Caret_GetPositionTuple", (PyCFunction)_wrap_Caret_GetPositionTuple, METH_O, NULL},
37395 { (char *)"Caret_GetSize", (PyCFunction)_wrap_Caret_GetSize, METH_O, NULL},
37396 { (char *)"Caret_GetSizeTuple", (PyCFunction)_wrap_Caret_GetSizeTuple, METH_O, NULL},
37397 { (char *)"Caret_GetWindow", (PyCFunction)_wrap_Caret_GetWindow, METH_O, NULL},
37398 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
37399 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
37400 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
37401 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
37402 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
37403 { (char *)"Caret_Hide", (PyCFunction)_wrap_Caret_Hide, METH_O, NULL},
37404 { (char *)"Caret_GetBlinkTime", (PyCFunction)_wrap_Caret_GetBlinkTime, METH_NOARGS, NULL},
37405 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
37406 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
37407 { (char *)"Caret_swiginit", Caret_swiginit, METH_VARARGS, NULL},
37408 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
37409 { (char *)"delete_BusyCursor", (PyCFunction)_wrap_delete_BusyCursor, METH_O, NULL},
37410 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
37411 { (char *)"BusyCursor_swiginit", BusyCursor_swiginit, METH_VARARGS, NULL},
37412 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
37413 { (char *)"delete_WindowDisabler", (PyCFunction)_wrap_delete_WindowDisabler, METH_O, NULL},
37414 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
37415 { (char *)"WindowDisabler_swiginit", WindowDisabler_swiginit, METH_VARARGS, NULL},
37416 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37417 { (char *)"delete_BusyInfo", (PyCFunction)_wrap_delete_BusyInfo, METH_O, NULL},
37418 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
37419 { (char *)"BusyInfo_swiginit", BusyInfo_swiginit, METH_VARARGS, NULL},
37420 { (char *)"new_StopWatch", (PyCFunction)_wrap_new_StopWatch, METH_NOARGS, NULL},
37421 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
37422 { (char *)"StopWatch_Pause", (PyCFunction)_wrap_StopWatch_Pause, METH_O, NULL},
37423 { (char *)"StopWatch_Resume", (PyCFunction)_wrap_StopWatch_Resume, METH_O, NULL},
37424 { (char *)"StopWatch_Time", (PyCFunction)_wrap_StopWatch_Time, METH_O, NULL},
37425 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
37426 { (char *)"StopWatch_swiginit", StopWatch_swiginit, METH_VARARGS, NULL},
37427 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
37428 { (char *)"delete_FileHistory", (PyCFunction)_wrap_delete_FileHistory, METH_O, NULL},
37429 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
37430 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
37431 { (char *)"FileHistory_GetMaxFiles", (PyCFunction)_wrap_FileHistory_GetMaxFiles, METH_O, NULL},
37432 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
37433 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
37434 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
37435 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
37436 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction)_wrap_FileHistory_AddFilesToMenu, METH_O, NULL},
37437 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
37438 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
37439 { (char *)"FileHistory_GetCount", (PyCFunction)_wrap_FileHistory_GetCount, METH_O, NULL},
37440 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
37441 { (char *)"FileHistory_swiginit", FileHistory_swiginit, METH_VARARGS, NULL},
37442 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
37443 { (char *)"new_PreSingleInstanceChecker", (PyCFunction)_wrap_new_PreSingleInstanceChecker, METH_NOARGS, NULL},
37444 { (char *)"delete_SingleInstanceChecker", (PyCFunction)_wrap_delete_SingleInstanceChecker, METH_O, NULL},
37445 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
37446 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction)_wrap_SingleInstanceChecker_IsAnotherRunning, METH_O, NULL},
37447 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
37448 { (char *)"SingleInstanceChecker_swiginit", SingleInstanceChecker_swiginit, METH_VARARGS, NULL},
37449 { (char *)"new_PlatformInformation", (PyCFunction)_wrap_new_PlatformInformation, METH_NOARGS, NULL},
37450 { (char *)"PlatformInformation___eq__", (PyCFunction) _wrap_PlatformInformation___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
37451 { (char *)"PlatformInformation___ne__", (PyCFunction) _wrap_PlatformInformation___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
37452 { (char *)"PlatformInformation_GetOSMajorVersion", (PyCFunction)_wrap_PlatformInformation_GetOSMajorVersion, METH_O, NULL},
37453 { (char *)"PlatformInformation_GetOSMinorVersion", (PyCFunction)_wrap_PlatformInformation_GetOSMinorVersion, METH_O, NULL},
37454 { (char *)"PlatformInformation_GetToolkitMajorVersion", (PyCFunction)_wrap_PlatformInformation_GetToolkitMajorVersion, METH_O, NULL},
37455 { (char *)"PlatformInformation_GetToolkitMinorVersion", (PyCFunction)_wrap_PlatformInformation_GetToolkitMinorVersion, METH_O, NULL},
37456 { (char *)"PlatformInformation_IsUsingUniversalWidgets", (PyCFunction)_wrap_PlatformInformation_IsUsingUniversalWidgets, METH_O, NULL},
37457 { (char *)"PlatformInformation_GetOperatingSystemId", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemId, METH_O, NULL},
37458 { (char *)"PlatformInformation_GetPortId", (PyCFunction)_wrap_PlatformInformation_GetPortId, METH_O, NULL},
37459 { (char *)"PlatformInformation_GetArchitecture", (PyCFunction)_wrap_PlatformInformation_GetArchitecture, METH_O, NULL},
37460 { (char *)"PlatformInformation_GetEndianness", (PyCFunction)_wrap_PlatformInformation_GetEndianness, METH_O, NULL},
37461 { (char *)"PlatformInformation_GetOperatingSystemFamilyName", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemFamilyName, METH_O, NULL},
37462 { (char *)"PlatformInformation_GetOperatingSystemIdName", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemIdName, METH_O, NULL},
37463 { (char *)"PlatformInformation_GetPortIdName", (PyCFunction)_wrap_PlatformInformation_GetPortIdName, METH_O, NULL},
37464 { (char *)"PlatformInformation_GetPortIdShortName", (PyCFunction)_wrap_PlatformInformation_GetPortIdShortName, METH_O, NULL},
37465 { (char *)"PlatformInformation_GetArchName", (PyCFunction)_wrap_PlatformInformation_GetArchName, METH_O, NULL},
37466 { (char *)"PlatformInformation_GetEndiannessName", (PyCFunction)_wrap_PlatformInformation_GetEndiannessName, METH_O, NULL},
37467 { (char *)"PlatformInformation_SetOSVersion", (PyCFunction) _wrap_PlatformInformation_SetOSVersion, METH_VARARGS | METH_KEYWORDS, NULL},
37468 { (char *)"PlatformInformation_SetToolkitVersion", (PyCFunction) _wrap_PlatformInformation_SetToolkitVersion, METH_VARARGS | METH_KEYWORDS, NULL},
37469 { (char *)"PlatformInformation_SetOperatingSystemId", (PyCFunction) _wrap_PlatformInformation_SetOperatingSystemId, METH_VARARGS | METH_KEYWORDS, NULL},
37470 { (char *)"PlatformInformation_SetPortId", (PyCFunction) _wrap_PlatformInformation_SetPortId, METH_VARARGS | METH_KEYWORDS, NULL},
37471 { (char *)"PlatformInformation_SetArchitecture", (PyCFunction) _wrap_PlatformInformation_SetArchitecture, METH_VARARGS | METH_KEYWORDS, NULL},
37472 { (char *)"PlatformInformation_SetEndianness", (PyCFunction) _wrap_PlatformInformation_SetEndianness, METH_VARARGS | METH_KEYWORDS, NULL},
37473 { (char *)"PlatformInformation_IsOk", (PyCFunction)_wrap_PlatformInformation_IsOk, METH_O, NULL},
37474 { (char *)"PlatformInformation_swigregister", PlatformInformation_swigregister, METH_VARARGS, NULL},
37475 { (char *)"PlatformInformation_swiginit", PlatformInformation_swiginit, METH_VARARGS, NULL},
37476 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
37477 { (char *)"delete_TipProvider", (PyCFunction)_wrap_delete_TipProvider, METH_O, NULL},
37478 { (char *)"TipProvider_GetTip", (PyCFunction)_wrap_TipProvider_GetTip, METH_O, NULL},
37479 { (char *)"TipProvider_GetCurrentTip", (PyCFunction)_wrap_TipProvider_GetCurrentTip, METH_O, NULL},
37480 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
37481 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
37482 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
37483 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37484 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
37485 { (char *)"PyTipProvider_swiginit", PyTipProvider_swiginit, METH_VARARGS, NULL},
37486 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
37487 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
37488 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
37489 { (char *)"delete_Timer", (PyCFunction)_wrap_delete_Timer, METH_O, NULL},
37490 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37491 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
37492 { (char *)"Timer_GetOwner", (PyCFunction)_wrap_Timer_GetOwner, METH_O, NULL},
37493 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
37494 { (char *)"Timer_Stop", (PyCFunction)_wrap_Timer_Stop, METH_O, NULL},
37495 { (char *)"Timer_Notify", (PyCFunction)_wrap_Timer_Notify, METH_O, NULL},
37496 { (char *)"Timer_IsRunning", (PyCFunction)_wrap_Timer_IsRunning, METH_O, NULL},
37497 { (char *)"Timer_GetInterval", (PyCFunction)_wrap_Timer_GetInterval, METH_O, NULL},
37498 { (char *)"Timer_GetId", (PyCFunction)_wrap_Timer_GetId, METH_O, NULL},
37499 { (char *)"Timer_IsOneShot", (PyCFunction)_wrap_Timer_IsOneShot, METH_O, NULL},
37500 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
37501 { (char *)"Timer_swiginit", Timer_swiginit, METH_VARARGS, NULL},
37502 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
37503 { (char *)"TimerEvent_GetInterval", (PyCFunction)_wrap_TimerEvent_GetInterval, METH_O, NULL},
37504 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
37505 { (char *)"TimerEvent_swiginit", TimerEvent_swiginit, METH_VARARGS, NULL},
37506 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
37507 { (char *)"delete_TimerRunner", (PyCFunction)_wrap_delete_TimerRunner, METH_O, NULL},
37508 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
37509 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
37510 { (char *)"TimerRunner_swiginit", TimerRunner_swiginit, METH_VARARGS, NULL},
37511 { (char *)"new_Log", (PyCFunction)_wrap_new_Log, METH_NOARGS, NULL},
37512 { (char *)"delete_Log", (PyCFunction)_wrap_delete_Log, METH_O, NULL},
37513 { (char *)"Log_IsEnabled", (PyCFunction)_wrap_Log_IsEnabled, METH_NOARGS, NULL},
37514 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
37515 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
37516 { (char *)"Log_Flush", (PyCFunction)_wrap_Log_Flush, METH_O, NULL},
37517 { (char *)"Log_FlushActive", (PyCFunction)_wrap_Log_FlushActive, METH_NOARGS, NULL},
37518 { (char *)"Log_GetActiveTarget", (PyCFunction)_wrap_Log_GetActiveTarget, METH_NOARGS, NULL},
37519 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
37520 { (char *)"Log_Suspend", (PyCFunction)_wrap_Log_Suspend, METH_NOARGS, NULL},
37521 { (char *)"Log_Resume", (PyCFunction)_wrap_Log_Resume, METH_NOARGS, NULL},
37522 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
37523 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
37524 { (char *)"Log_DontCreateOnDemand", (PyCFunction)_wrap_Log_DontCreateOnDemand, METH_NOARGS, NULL},
37525 { (char *)"Log_SetRepetitionCounting", (PyCFunction) _wrap_Log_SetRepetitionCounting, METH_VARARGS | METH_KEYWORDS, NULL},
37526 { (char *)"Log_GetRepetitionCounting", (PyCFunction)_wrap_Log_GetRepetitionCounting, METH_NOARGS, NULL},
37527 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
37528 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
37529 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
37530 { (char *)"Log_ClearTraceMasks", (PyCFunction)_wrap_Log_ClearTraceMasks, METH_NOARGS, NULL},
37531 { (char *)"Log_GetTraceMasks", (PyCFunction)_wrap_Log_GetTraceMasks, METH_NOARGS, NULL},
37532 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
37533 { (char *)"Log_GetVerbose", (PyCFunction)_wrap_Log_GetVerbose, METH_NOARGS, NULL},
37534 { (char *)"Log_GetTraceMask", (PyCFunction)_wrap_Log_GetTraceMask, METH_NOARGS, NULL},
37535 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
37536 { (char *)"Log_GetLogLevel", (PyCFunction)_wrap_Log_GetLogLevel, METH_NOARGS, NULL},
37537 { (char *)"Log_GetTimestamp", (PyCFunction)_wrap_Log_GetTimestamp, METH_NOARGS, NULL},
37538 { (char *)"Log_TimeStamp", (PyCFunction)_wrap_Log_TimeStamp, METH_NOARGS, NULL},
37539 { (char *)"Log_Destroy", (PyCFunction)_wrap_Log_Destroy, METH_O, NULL},
37540 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
37541 { (char *)"Log_swiginit", Log_swiginit, METH_VARARGS, NULL},
37542 { (char *)"new_LogStderr", (PyCFunction)_wrap_new_LogStderr, METH_NOARGS, NULL},
37543 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
37544 { (char *)"LogStderr_swiginit", LogStderr_swiginit, METH_VARARGS, NULL},
37545 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
37546 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
37547 { (char *)"LogTextCtrl_swiginit", LogTextCtrl_swiginit, METH_VARARGS, NULL},
37548 { (char *)"new_LogGui", (PyCFunction)_wrap_new_LogGui, METH_NOARGS, NULL},
37549 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
37550 { (char *)"LogGui_swiginit", LogGui_swiginit, METH_VARARGS, NULL},
37551 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
37552 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
37553 { (char *)"LogWindow_GetFrame", (PyCFunction)_wrap_LogWindow_GetFrame, METH_O, NULL},
37554 { (char *)"LogWindow_GetOldLog", (PyCFunction)_wrap_LogWindow_GetOldLog, METH_O, NULL},
37555 { (char *)"LogWindow_IsPassingMessages", (PyCFunction)_wrap_LogWindow_IsPassingMessages, METH_O, NULL},
37556 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
37557 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
37558 { (char *)"LogWindow_swiginit", LogWindow_swiginit, METH_VARARGS, NULL},
37559 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
37560 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
37561 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
37562 { (char *)"LogChain_IsPassingMessages", (PyCFunction)_wrap_LogChain_IsPassingMessages, METH_O, NULL},
37563 { (char *)"LogChain_GetOldLog", (PyCFunction)_wrap_LogChain_GetOldLog, METH_O, NULL},
37564 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
37565 { (char *)"LogChain_swiginit", LogChain_swiginit, METH_VARARGS, NULL},
37566 { (char *)"new_LogBuffer", (PyCFunction)_wrap_new_LogBuffer, METH_NOARGS, NULL},
37567 { (char *)"LogBuffer_GetBuffer", (PyCFunction)_wrap_LogBuffer_GetBuffer, METH_O, NULL},
37568 { (char *)"LogBuffer_swigregister", LogBuffer_swigregister, METH_VARARGS, NULL},
37569 { (char *)"LogBuffer_swiginit", LogBuffer_swiginit, METH_VARARGS, NULL},
37570 { (char *)"SysErrorCode", (PyCFunction)_wrap_SysErrorCode, METH_NOARGS, NULL},
37571 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
37572 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
37573 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
37574 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
37575 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
37576 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37577 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
37578 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
37579 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
37580 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
37581 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
37582 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
37583 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
37584 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
37585 { (char *)"new_LogNull", (PyCFunction)_wrap_new_LogNull, METH_NOARGS, NULL},
37586 { (char *)"delete_LogNull", (PyCFunction)_wrap_delete_LogNull, METH_O, NULL},
37587 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
37588 { (char *)"LogNull_swiginit", LogNull_swiginit, METH_VARARGS, NULL},
37589 { (char *)"new_PyLog", (PyCFunction)_wrap_new_PyLog, METH_NOARGS, NULL},
37590 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37591 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
37592 { (char *)"PyLog_swiginit", PyLog_swiginit, METH_VARARGS, NULL},
37593 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
37594 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
37595 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
37596 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
37597 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37598 { (char *)"Process_OnTerminate", (PyCFunction) _wrap_Process_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
37599 { (char *)"Process_Redirect", (PyCFunction)_wrap_Process_Redirect, METH_O, NULL},
37600 { (char *)"Process_IsRedirected", (PyCFunction)_wrap_Process_IsRedirected, METH_O, NULL},
37601 { (char *)"Process_Detach", (PyCFunction)_wrap_Process_Detach, METH_O, NULL},
37602 { (char *)"Process_GetInputStream", (PyCFunction)_wrap_Process_GetInputStream, METH_O, NULL},
37603 { (char *)"Process_GetErrorStream", (PyCFunction)_wrap_Process_GetErrorStream, METH_O, NULL},
37604 { (char *)"Process_GetOutputStream", (PyCFunction)_wrap_Process_GetOutputStream, METH_O, NULL},
37605 { (char *)"Process_CloseOutput", (PyCFunction)_wrap_Process_CloseOutput, METH_O, NULL},
37606 { (char *)"Process_IsInputOpened", (PyCFunction)_wrap_Process_IsInputOpened, METH_O, NULL},
37607 { (char *)"Process_IsInputAvailable", (PyCFunction)_wrap_Process_IsInputAvailable, METH_O, NULL},
37608 { (char *)"Process_IsErrorAvailable", (PyCFunction)_wrap_Process_IsErrorAvailable, METH_O, NULL},
37609 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
37610 { (char *)"Process_swiginit", Process_swiginit, METH_VARARGS, NULL},
37611 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
37612 { (char *)"ProcessEvent_GetPid", (PyCFunction)_wrap_ProcessEvent_GetPid, METH_O, NULL},
37613 { (char *)"ProcessEvent_GetExitCode", (PyCFunction)_wrap_ProcessEvent_GetExitCode, METH_O, NULL},
37614 { (char *)"ProcessEvent_m_pid_set", _wrap_ProcessEvent_m_pid_set, METH_VARARGS, NULL},
37615 { (char *)"ProcessEvent_m_pid_get", (PyCFunction)_wrap_ProcessEvent_m_pid_get, METH_O, NULL},
37616 { (char *)"ProcessEvent_m_exitcode_set", _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS, NULL},
37617 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction)_wrap_ProcessEvent_m_exitcode_get, METH_O, NULL},
37618 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
37619 { (char *)"ProcessEvent_swiginit", ProcessEvent_swiginit, METH_VARARGS, NULL},
37620 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
37621 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
37622 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
37623 { (char *)"delete_Joystick", (PyCFunction)_wrap_delete_Joystick, METH_O, NULL},
37624 { (char *)"Joystick_GetPosition", (PyCFunction)_wrap_Joystick_GetPosition, METH_O, NULL},
37625 { (char *)"Joystick_GetZPosition", (PyCFunction)_wrap_Joystick_GetZPosition, METH_O, NULL},
37626 { (char *)"Joystick_GetButtonState", (PyCFunction)_wrap_Joystick_GetButtonState, METH_O, NULL},
37627 { (char *)"Joystick_GetPOVPosition", (PyCFunction)_wrap_Joystick_GetPOVPosition, METH_O, NULL},
37628 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction)_wrap_Joystick_GetPOVCTSPosition, METH_O, NULL},
37629 { (char *)"Joystick_GetRudderPosition", (PyCFunction)_wrap_Joystick_GetRudderPosition, METH_O, NULL},
37630 { (char *)"Joystick_GetUPosition", (PyCFunction)_wrap_Joystick_GetUPosition, METH_O, NULL},
37631 { (char *)"Joystick_GetVPosition", (PyCFunction)_wrap_Joystick_GetVPosition, METH_O, NULL},
37632 { (char *)"Joystick_GetMovementThreshold", (PyCFunction)_wrap_Joystick_GetMovementThreshold, METH_O, NULL},
37633 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
37634 { (char *)"Joystick_IsOk", (PyCFunction)_wrap_Joystick_IsOk, METH_O, NULL},
37635 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction)_wrap_Joystick_GetNumberJoysticks, METH_O, NULL},
37636 { (char *)"Joystick_GetManufacturerId", (PyCFunction)_wrap_Joystick_GetManufacturerId, METH_O, NULL},
37637 { (char *)"Joystick_GetProductId", (PyCFunction)_wrap_Joystick_GetProductId, METH_O, NULL},
37638 { (char *)"Joystick_GetProductName", (PyCFunction)_wrap_Joystick_GetProductName, METH_O, NULL},
37639 { (char *)"Joystick_GetXMin", (PyCFunction)_wrap_Joystick_GetXMin, METH_O, NULL},
37640 { (char *)"Joystick_GetYMin", (PyCFunction)_wrap_Joystick_GetYMin, METH_O, NULL},
37641 { (char *)"Joystick_GetZMin", (PyCFunction)_wrap_Joystick_GetZMin, METH_O, NULL},
37642 { (char *)"Joystick_GetXMax", (PyCFunction)_wrap_Joystick_GetXMax, METH_O, NULL},
37643 { (char *)"Joystick_GetYMax", (PyCFunction)_wrap_Joystick_GetYMax, METH_O, NULL},
37644 { (char *)"Joystick_GetZMax", (PyCFunction)_wrap_Joystick_GetZMax, METH_O, NULL},
37645 { (char *)"Joystick_GetNumberButtons", (PyCFunction)_wrap_Joystick_GetNumberButtons, METH_O, NULL},
37646 { (char *)"Joystick_GetNumberAxes", (PyCFunction)_wrap_Joystick_GetNumberAxes, METH_O, NULL},
37647 { (char *)"Joystick_GetMaxButtons", (PyCFunction)_wrap_Joystick_GetMaxButtons, METH_O, NULL},
37648 { (char *)"Joystick_GetMaxAxes", (PyCFunction)_wrap_Joystick_GetMaxAxes, METH_O, NULL},
37649 { (char *)"Joystick_GetPollingMin", (PyCFunction)_wrap_Joystick_GetPollingMin, METH_O, NULL},
37650 { (char *)"Joystick_GetPollingMax", (PyCFunction)_wrap_Joystick_GetPollingMax, METH_O, NULL},
37651 { (char *)"Joystick_GetRudderMin", (PyCFunction)_wrap_Joystick_GetRudderMin, METH_O, NULL},
37652 { (char *)"Joystick_GetRudderMax", (PyCFunction)_wrap_Joystick_GetRudderMax, METH_O, NULL},
37653 { (char *)"Joystick_GetUMin", (PyCFunction)_wrap_Joystick_GetUMin, METH_O, NULL},
37654 { (char *)"Joystick_GetUMax", (PyCFunction)_wrap_Joystick_GetUMax, METH_O, NULL},
37655 { (char *)"Joystick_GetVMin", (PyCFunction)_wrap_Joystick_GetVMin, METH_O, NULL},
37656 { (char *)"Joystick_GetVMax", (PyCFunction)_wrap_Joystick_GetVMax, METH_O, NULL},
37657 { (char *)"Joystick_HasRudder", (PyCFunction)_wrap_Joystick_HasRudder, METH_O, NULL},
37658 { (char *)"Joystick_HasZ", (PyCFunction)_wrap_Joystick_HasZ, METH_O, NULL},
37659 { (char *)"Joystick_HasU", (PyCFunction)_wrap_Joystick_HasU, METH_O, NULL},
37660 { (char *)"Joystick_HasV", (PyCFunction)_wrap_Joystick_HasV, METH_O, NULL},
37661 { (char *)"Joystick_HasPOV", (PyCFunction)_wrap_Joystick_HasPOV, METH_O, NULL},
37662 { (char *)"Joystick_HasPOV4Dir", (PyCFunction)_wrap_Joystick_HasPOV4Dir, METH_O, NULL},
37663 { (char *)"Joystick_HasPOVCTS", (PyCFunction)_wrap_Joystick_HasPOVCTS, METH_O, NULL},
37664 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
37665 { (char *)"Joystick_ReleaseCapture", (PyCFunction)_wrap_Joystick_ReleaseCapture, METH_O, NULL},
37666 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
37667 { (char *)"Joystick_swiginit", Joystick_swiginit, METH_VARARGS, NULL},
37668 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
37669 { (char *)"JoystickEvent_GetPosition", (PyCFunction)_wrap_JoystickEvent_GetPosition, METH_O, NULL},
37670 { (char *)"JoystickEvent_GetZPosition", (PyCFunction)_wrap_JoystickEvent_GetZPosition, METH_O, NULL},
37671 { (char *)"JoystickEvent_GetButtonState", (PyCFunction)_wrap_JoystickEvent_GetButtonState, METH_O, NULL},
37672 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction)_wrap_JoystickEvent_GetButtonChange, METH_O, NULL},
37673 { (char *)"JoystickEvent_GetJoystick", (PyCFunction)_wrap_JoystickEvent_GetJoystick, METH_O, NULL},
37674 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
37675 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
37676 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
37677 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
37678 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
37679 { (char *)"JoystickEvent_IsButton", (PyCFunction)_wrap_JoystickEvent_IsButton, METH_O, NULL},
37680 { (char *)"JoystickEvent_IsMove", (PyCFunction)_wrap_JoystickEvent_IsMove, METH_O, NULL},
37681 { (char *)"JoystickEvent_IsZMove", (PyCFunction)_wrap_JoystickEvent_IsZMove, METH_O, NULL},
37682 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
37683 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
37684 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
37685 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
37686 { (char *)"JoystickEvent_swiginit", JoystickEvent_swiginit, METH_VARARGS, NULL},
37687 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
37688 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
37689 { (char *)"delete_Sound", (PyCFunction)_wrap_delete_Sound, METH_O, NULL},
37690 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
37691 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
37692 { (char *)"Sound_IsOk", (PyCFunction)_wrap_Sound_IsOk, METH_O, NULL},
37693 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
37694 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
37695 { (char *)"Sound_Stop", (PyCFunction)_wrap_Sound_Stop, METH_NOARGS, NULL},
37696 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
37697 { (char *)"Sound_swiginit", Sound_swiginit, METH_VARARGS, NULL},
37698 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37699 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
37700 { (char *)"new_NullFileTypeInfo", (PyCFunction)_wrap_new_NullFileTypeInfo, METH_NOARGS, NULL},
37701 { (char *)"FileTypeInfo_IsValid", (PyCFunction)_wrap_FileTypeInfo_IsValid, METH_O, NULL},
37702 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
37703 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
37704 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction)_wrap_FileTypeInfo_GetMimeType, METH_O, NULL},
37705 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction)_wrap_FileTypeInfo_GetOpenCommand, METH_O, NULL},
37706 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction)_wrap_FileTypeInfo_GetPrintCommand, METH_O, NULL},
37707 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction)_wrap_FileTypeInfo_GetShortDesc, METH_O, NULL},
37708 { (char *)"FileTypeInfo_GetDescription", (PyCFunction)_wrap_FileTypeInfo_GetDescription, METH_O, NULL},
37709 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction)_wrap_FileTypeInfo_GetExtensions, METH_O, NULL},
37710 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction)_wrap_FileTypeInfo_GetExtensionsCount, METH_O, NULL},
37711 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction)_wrap_FileTypeInfo_GetIconFile, METH_O, NULL},
37712 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction)_wrap_FileTypeInfo_GetIconIndex, METH_O, NULL},
37713 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
37714 { (char *)"FileTypeInfo_swiginit", FileTypeInfo_swiginit, METH_VARARGS, NULL},
37715 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
37716 { (char *)"delete_FileType", (PyCFunction)_wrap_delete_FileType, METH_O, NULL},
37717 { (char *)"FileType_GetMimeType", (PyCFunction)_wrap_FileType_GetMimeType, METH_O, NULL},
37718 { (char *)"FileType_GetMimeTypes", (PyCFunction)_wrap_FileType_GetMimeTypes, METH_O, NULL},
37719 { (char *)"FileType_GetExtensions", (PyCFunction)_wrap_FileType_GetExtensions, METH_O, NULL},
37720 { (char *)"FileType_GetIcon", (PyCFunction)_wrap_FileType_GetIcon, METH_O, NULL},
37721 { (char *)"FileType_GetIconInfo", (PyCFunction)_wrap_FileType_GetIconInfo, METH_O, NULL},
37722 { (char *)"FileType_GetDescription", (PyCFunction)_wrap_FileType_GetDescription, METH_O, NULL},
37723 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
37724 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
37725 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
37726 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
37727 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
37728 { (char *)"FileType_Unassociate", (PyCFunction)_wrap_FileType_Unassociate, METH_O, NULL},
37729 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
37730 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
37731 { (char *)"FileType_swiginit", FileType_swiginit, METH_VARARGS, NULL},
37732 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
37733 { (char *)"new_MimeTypesManager", (PyCFunction)_wrap_new_MimeTypesManager, METH_NOARGS, NULL},
37734 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
37735 { (char *)"MimeTypesManager_ClearData", (PyCFunction)_wrap_MimeTypesManager_ClearData, METH_O, NULL},
37736 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
37737 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
37738 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
37739 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
37740 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction)_wrap_MimeTypesManager_EnumAllFileTypes, METH_O, NULL},
37741 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
37742 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
37743 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
37744 { (char *)"delete_MimeTypesManager", (PyCFunction)_wrap_delete_MimeTypesManager, METH_O, NULL},
37745 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
37746 { (char *)"MimeTypesManager_swiginit", MimeTypesManager_swiginit, METH_VARARGS, NULL},
37747 { (char *)"new_ArtProvider", (PyCFunction)_wrap_new_ArtProvider, METH_NOARGS, NULL},
37748 { (char *)"delete_ArtProvider", (PyCFunction)_wrap_delete_ArtProvider, METH_O, NULL},
37749 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37750 { (char *)"ArtProvider_PushProvider", (PyCFunction) _wrap_ArtProvider_PushProvider, METH_VARARGS | METH_KEYWORDS, NULL},
37751 { (char *)"ArtProvider_InsertProvider", (PyCFunction) _wrap_ArtProvider_InsertProvider, METH_VARARGS | METH_KEYWORDS, NULL},
37752 { (char *)"ArtProvider_PopProvider", (PyCFunction)_wrap_ArtProvider_PopProvider, METH_NOARGS, NULL},
37753 { (char *)"ArtProvider_RemoveProvider", (PyCFunction) _wrap_ArtProvider_RemoveProvider, METH_VARARGS | METH_KEYWORDS, NULL},
37754 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
37755 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
37756 { (char *)"ArtProvider_GetSizeHint", (PyCFunction) _wrap_ArtProvider_GetSizeHint, METH_VARARGS | METH_KEYWORDS, NULL},
37757 { (char *)"ArtProvider_Destroy", (PyCFunction)_wrap_ArtProvider_Destroy, METH_O, NULL},
37758 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
37759 { (char *)"ArtProvider_swiginit", ArtProvider_swiginit, METH_VARARGS, NULL},
37760 { (char *)"delete_ConfigBase", (PyCFunction)_wrap_delete_ConfigBase, METH_O, NULL},
37761 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
37762 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
37763 { (char *)"ConfigBase_Create", (PyCFunction)_wrap_ConfigBase_Create, METH_NOARGS, NULL},
37764 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction)_wrap_ConfigBase_DontCreateOnDemand, METH_NOARGS, NULL},
37765 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
37766 { (char *)"ConfigBase_GetPath", (PyCFunction)_wrap_ConfigBase_GetPath, METH_O, NULL},
37767 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction)_wrap_ConfigBase_GetFirstGroup, METH_O, NULL},
37768 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
37769 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction)_wrap_ConfigBase_GetFirstEntry, METH_O, NULL},
37770 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
37771 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
37772 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
37773 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
37774 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
37775 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
37776 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
37777 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
37778 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
37779 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
37780 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
37781 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
37782 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
37783 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
37784 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
37785 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
37786 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
37787 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
37788 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
37789 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
37790 { (char *)"ConfigBase_DeleteAll", (PyCFunction)_wrap_ConfigBase_DeleteAll, METH_O, NULL},
37791 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
37792 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction)_wrap_ConfigBase_IsExpandingEnvVars, METH_O, NULL},
37793 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
37794 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction)_wrap_ConfigBase_IsRecordingDefaults, METH_O, NULL},
37795 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
37796 { (char *)"ConfigBase_GetAppName", (PyCFunction)_wrap_ConfigBase_GetAppName, METH_O, NULL},
37797 { (char *)"ConfigBase_GetVendorName", (PyCFunction)_wrap_ConfigBase_GetVendorName, METH_O, NULL},
37798 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
37799 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
37800 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
37801 { (char *)"ConfigBase_GetStyle", (PyCFunction)_wrap_ConfigBase_GetStyle, METH_O, NULL},
37802 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
37803 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
37804 { (char *)"delete_Config", (PyCFunction)_wrap_delete_Config, METH_O, NULL},
37805 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
37806 { (char *)"Config_swiginit", Config_swiginit, METH_VARARGS, NULL},
37807 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
37808 { (char *)"delete_FileConfig", (PyCFunction)_wrap_delete_FileConfig, METH_O, NULL},
37809 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
37810 { (char *)"FileConfig_swiginit", FileConfig_swiginit, METH_VARARGS, NULL},
37811 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
37812 { (char *)"delete_ConfigPathChanger", (PyCFunction)_wrap_delete_ConfigPathChanger, METH_O, NULL},
37813 { (char *)"ConfigPathChanger_Name", (PyCFunction)_wrap_ConfigPathChanger_Name, METH_O, NULL},
37814 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
37815 { (char *)"ConfigPathChanger_swiginit", ConfigPathChanger_swiginit, METH_VARARGS, NULL},
37816 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
37817 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
37818 { (char *)"DateTime_GetCountry", (PyCFunction)_wrap_DateTime_GetCountry, METH_NOARGS, NULL},
37819 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
37820 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
37821 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
37822 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
37823 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
37824 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
37825 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
37826 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
37827 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
37828 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
37829 { (char *)"DateTime_GetAmPmStrings", (PyCFunction)_wrap_DateTime_GetAmPmStrings, METH_NOARGS, NULL},
37830 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
37831 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
37832 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
37833 { (char *)"DateTime_Now", (PyCFunction)_wrap_DateTime_Now, METH_NOARGS, NULL},
37834 { (char *)"DateTime_UNow", (PyCFunction)_wrap_DateTime_UNow, METH_NOARGS, NULL},
37835 { (char *)"DateTime_Today", (PyCFunction)_wrap_DateTime_Today, METH_NOARGS, NULL},
37836 { (char *)"new_DateTime", (PyCFunction)_wrap_new_DateTime, METH_NOARGS, NULL},
37837 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
37838 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
37839 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
37840 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
37841 { (char *)"new_DateTimeFromDateTime", (PyCFunction) _wrap_new_DateTimeFromDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
37842 { (char *)"delete_DateTime", (PyCFunction)_wrap_delete_DateTime, METH_O, NULL},
37843 { (char *)"DateTime_SetToCurrent", (PyCFunction)_wrap_DateTime_SetToCurrent, METH_O, NULL},
37844 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
37845 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
37846 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
37847 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
37848 { (char *)"DateTime_ResetTime", (PyCFunction)_wrap_DateTime_ResetTime, METH_O, NULL},
37849 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
37850 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
37851 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
37852 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
37853 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
37854 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
37855 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
37856 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
37857 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
37858 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
37859 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
37860 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
37861 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
37862 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
37863 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
37864 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
37865 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
37866 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
37867 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
37868 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
37869 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
37870 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
37871 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
37872 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction)_wrap_DateTime_GetJulianDayNumber, METH_O, NULL},
37873 { (char *)"DateTime_GetJDN", (PyCFunction)_wrap_DateTime_GetJDN, METH_O, NULL},
37874 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction)_wrap_DateTime_GetModifiedJulianDayNumber, METH_O, NULL},
37875 { (char *)"DateTime_GetMJD", (PyCFunction)_wrap_DateTime_GetMJD, METH_O, NULL},
37876 { (char *)"DateTime_GetRataDie", (PyCFunction)_wrap_DateTime_GetRataDie, METH_O, NULL},
37877 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
37878 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
37879 { (char *)"DateTime_FromTimezone", (PyCFunction) _wrap_DateTime_FromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
37880 { (char *)"DateTime_MakeFromTimezone", (PyCFunction) _wrap_DateTime_MakeFromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
37881 { (char *)"DateTime_ToUTC", (PyCFunction) _wrap_DateTime_ToUTC, METH_VARARGS | METH_KEYWORDS, NULL},
37882 { (char *)"DateTime_MakeUTC", (PyCFunction) _wrap_DateTime_MakeUTC, METH_VARARGS | METH_KEYWORDS, NULL},
37883 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
37884 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
37885 { (char *)"DateTime_FromUTC", (PyCFunction) _wrap_DateTime_FromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
37886 { (char *)"DateTime_MakeFromUTC", (PyCFunction) _wrap_DateTime_MakeFromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
37887 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
37888 { (char *)"DateTime_IsValid", (PyCFunction)_wrap_DateTime_IsValid, METH_O, NULL},
37889 { (char *)"DateTime_GetTicks", (PyCFunction)_wrap_DateTime_GetTicks, METH_O, NULL},
37890 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
37891 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
37892 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
37893 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
37894 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
37895 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
37896 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
37897 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
37898 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
37899 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
37900 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
37901 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
37902 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
37903 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
37904 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
37905 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
37906 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
37907 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
37908 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
37909 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
37910 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
37911 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
37912 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
37913 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
37914 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
37915 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
37916 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
37917 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
37918 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
37919 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
37920 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
37921 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
37922 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
37923 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
37924 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
37925 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
37926 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
37927 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
37928 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
37929 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
37930 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
37931 { (char *)"DateTime_FormatDate", (PyCFunction)_wrap_DateTime_FormatDate, METH_O, NULL},
37932 { (char *)"DateTime_FormatTime", (PyCFunction)_wrap_DateTime_FormatTime, METH_O, NULL},
37933 { (char *)"DateTime_FormatISODate", (PyCFunction)_wrap_DateTime_FormatISODate, METH_O, NULL},
37934 { (char *)"DateTime_FormatISOTime", (PyCFunction)_wrap_DateTime_FormatISOTime, METH_O, NULL},
37935 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
37936 { (char *)"DateTime_swiginit", DateTime_swiginit, METH_VARARGS, NULL},
37937 { (char *)"TimeSpan_Milliseconds", (PyCFunction) _wrap_TimeSpan_Milliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
37938 { (char *)"TimeSpan_Millisecond", (PyCFunction)_wrap_TimeSpan_Millisecond, METH_NOARGS, NULL},
37939 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
37940 { (char *)"TimeSpan_Second", (PyCFunction)_wrap_TimeSpan_Second, METH_NOARGS, NULL},
37941 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
37942 { (char *)"TimeSpan_Minute", (PyCFunction)_wrap_TimeSpan_Minute, METH_NOARGS, NULL},
37943 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
37944 { (char *)"TimeSpan_Hour", (PyCFunction)_wrap_TimeSpan_Hour, METH_NOARGS, NULL},
37945 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
37946 { (char *)"TimeSpan_Day", (PyCFunction)_wrap_TimeSpan_Day, METH_NOARGS, NULL},
37947 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
37948 { (char *)"TimeSpan_Week", (PyCFunction)_wrap_TimeSpan_Week, METH_NOARGS, NULL},
37949 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
37950 { (char *)"delete_TimeSpan", (PyCFunction)_wrap_delete_TimeSpan, METH_O, NULL},
37951 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
37952 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
37953 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
37954 { (char *)"TimeSpan_Neg", (PyCFunction)_wrap_TimeSpan_Neg, METH_O, NULL},
37955 { (char *)"TimeSpan_Abs", (PyCFunction)_wrap_TimeSpan_Abs, METH_O, NULL},
37956 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
37957 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
37958 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
37959 { (char *)"TimeSpan___neg__", (PyCFunction)_wrap_TimeSpan___neg__, METH_O, NULL},
37960 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
37961 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
37962 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
37963 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
37964 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
37965 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
37966 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
37967 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
37968 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
37969 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
37970 { (char *)"TimeSpan_IsNull", (PyCFunction)_wrap_TimeSpan_IsNull, METH_O, NULL},
37971 { (char *)"TimeSpan_IsPositive", (PyCFunction)_wrap_TimeSpan_IsPositive, METH_O, NULL},
37972 { (char *)"TimeSpan_IsNegative", (PyCFunction)_wrap_TimeSpan_IsNegative, METH_O, NULL},
37973 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
37974 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
37975 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
37976 { (char *)"TimeSpan_GetWeeks", (PyCFunction)_wrap_TimeSpan_GetWeeks, METH_O, NULL},
37977 { (char *)"TimeSpan_GetDays", (PyCFunction)_wrap_TimeSpan_GetDays, METH_O, NULL},
37978 { (char *)"TimeSpan_GetHours", (PyCFunction)_wrap_TimeSpan_GetHours, METH_O, NULL},
37979 { (char *)"TimeSpan_GetMinutes", (PyCFunction)_wrap_TimeSpan_GetMinutes, METH_O, NULL},
37980 { (char *)"TimeSpan_GetSeconds", (PyCFunction)_wrap_TimeSpan_GetSeconds, METH_O, NULL},
37981 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction)_wrap_TimeSpan_GetMilliseconds, METH_O, NULL},
37982 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
37983 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
37984 { (char *)"TimeSpan_swiginit", TimeSpan_swiginit, METH_VARARGS, NULL},
37985 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
37986 { (char *)"delete_DateSpan", (PyCFunction)_wrap_delete_DateSpan, METH_O, NULL},
37987 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
37988 { (char *)"DateSpan_Day", (PyCFunction)_wrap_DateSpan_Day, METH_NOARGS, NULL},
37989 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
37990 { (char *)"DateSpan_Week", (PyCFunction)_wrap_DateSpan_Week, METH_NOARGS, NULL},
37991 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
37992 { (char *)"DateSpan_Month", (PyCFunction)_wrap_DateSpan_Month, METH_NOARGS, NULL},
37993 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
37994 { (char *)"DateSpan_Year", (PyCFunction)_wrap_DateSpan_Year, METH_NOARGS, NULL},
37995 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
37996 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
37997 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
37998 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
37999 { (char *)"DateSpan_GetYears", (PyCFunction)_wrap_DateSpan_GetYears, METH_O, NULL},
38000 { (char *)"DateSpan_GetMonths", (PyCFunction)_wrap_DateSpan_GetMonths, METH_O, NULL},
38001 { (char *)"DateSpan_GetWeeks", (PyCFunction)_wrap_DateSpan_GetWeeks, METH_O, NULL},
38002 { (char *)"DateSpan_GetDays", (PyCFunction)_wrap_DateSpan_GetDays, METH_O, NULL},
38003 { (char *)"DateSpan_GetTotalDays", (PyCFunction)_wrap_DateSpan_GetTotalDays, METH_O, NULL},
38004 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
38005 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
38006 { (char *)"DateSpan_Neg", (PyCFunction)_wrap_DateSpan_Neg, METH_O, NULL},
38007 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
38008 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
38009 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
38010 { (char *)"DateSpan___neg__", (PyCFunction)_wrap_DateSpan___neg__, METH_O, NULL},
38011 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
38012 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
38013 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
38014 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
38015 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
38016 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
38017 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
38018 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
38019 { (char *)"DateSpan_swiginit", DateSpan_swiginit, METH_VARARGS, NULL},
38020 { (char *)"GetLocalTime", (PyCFunction)_wrap_GetLocalTime, METH_NOARGS, NULL},
38021 { (char *)"GetUTCTime", (PyCFunction)_wrap_GetUTCTime, METH_NOARGS, NULL},
38022 { (char *)"GetCurrentTime", (PyCFunction)_wrap_GetCurrentTime, METH_NOARGS, NULL},
38023 { (char *)"GetLocalTimeMillis", (PyCFunction)_wrap_GetLocalTimeMillis, METH_NOARGS, NULL},
38024 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
38025 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
38026 { (char *)"delete_DataFormat", (PyCFunction)_wrap_delete_DataFormat, METH_O, NULL},
38027 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
38028 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
38029 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
38030 { (char *)"DataFormat_GetType", (PyCFunction)_wrap_DataFormat_GetType, METH_O, NULL},
38031 { (char *)"DataFormat_GetId", (PyCFunction)_wrap_DataFormat_GetId, METH_O, NULL},
38032 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
38033 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
38034 { (char *)"DataFormat_swiginit", DataFormat_swiginit, METH_VARARGS, NULL},
38035 { (char *)"delete_DataObject", (PyCFunction)_wrap_delete_DataObject, METH_O, NULL},
38036 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
38037 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
38038 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
38039 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
38040 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
38041 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
38042 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
38043 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
38044 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
38045 { (char *)"DataObjectSimple_GetFormat", (PyCFunction)_wrap_DataObjectSimple_GetFormat, METH_O, NULL},
38046 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
38047 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction)_wrap_DataObjectSimple_GetDataSize, METH_O, NULL},
38048 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction)_wrap_DataObjectSimple_GetDataHere, METH_O, NULL},
38049 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
38050 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
38051 { (char *)"DataObjectSimple_swiginit", DataObjectSimple_swiginit, METH_VARARGS, NULL},
38052 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
38053 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
38054 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
38055 { (char *)"PyDataObjectSimple_swiginit", PyDataObjectSimple_swiginit, METH_VARARGS, NULL},
38056 { (char *)"new_DataObjectComposite", (PyCFunction)_wrap_new_DataObjectComposite, METH_NOARGS, NULL},
38057 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
38058 { (char *)"DataObjectComposite_GetReceivedFormat", (PyCFunction)_wrap_DataObjectComposite_GetReceivedFormat, METH_O, NULL},
38059 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
38060 { (char *)"DataObjectComposite_swiginit", DataObjectComposite_swiginit, METH_VARARGS, NULL},
38061 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
38062 { (char *)"TextDataObject_GetTextLength", (PyCFunction)_wrap_TextDataObject_GetTextLength, METH_O, NULL},
38063 { (char *)"TextDataObject_GetText", (PyCFunction)_wrap_TextDataObject_GetText, METH_O, NULL},
38064 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
38065 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
38066 { (char *)"TextDataObject_swiginit", TextDataObject_swiginit, METH_VARARGS, NULL},
38067 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
38068 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
38069 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
38070 { (char *)"PyTextDataObject_swiginit", PyTextDataObject_swiginit, METH_VARARGS, NULL},
38071 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
38072 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction)_wrap_BitmapDataObject_GetBitmap, METH_O, NULL},
38073 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
38074 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
38075 { (char *)"BitmapDataObject_swiginit", BitmapDataObject_swiginit, METH_VARARGS, NULL},
38076 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
38077 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
38078 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
38079 { (char *)"PyBitmapDataObject_swiginit", PyBitmapDataObject_swiginit, METH_VARARGS, NULL},
38080 { (char *)"new_FileDataObject", (PyCFunction)_wrap_new_FileDataObject, METH_NOARGS, NULL},
38081 { (char *)"FileDataObject_GetFilenames", (PyCFunction)_wrap_FileDataObject_GetFilenames, METH_O, NULL},
38082 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
38083 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
38084 { (char *)"FileDataObject_swiginit", FileDataObject_swiginit, METH_VARARGS, NULL},
38085 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
38086 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
38087 { (char *)"CustomDataObject_GetSize", (PyCFunction)_wrap_CustomDataObject_GetSize, METH_O, NULL},
38088 { (char *)"CustomDataObject_GetData", (PyCFunction)_wrap_CustomDataObject_GetData, METH_O, NULL},
38089 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
38090 { (char *)"CustomDataObject_swiginit", CustomDataObject_swiginit, METH_VARARGS, NULL},
38091 { (char *)"new_URLDataObject", (PyCFunction) _wrap_new_URLDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
38092 { (char *)"URLDataObject_GetURL", (PyCFunction)_wrap_URLDataObject_GetURL, METH_O, NULL},
38093 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
38094 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
38095 { (char *)"URLDataObject_swiginit", URLDataObject_swiginit, METH_VARARGS, NULL},
38096 { (char *)"new_MetafileDataObject", (PyCFunction)_wrap_new_MetafileDataObject, METH_NOARGS, NULL},
38097 { (char *)"MetafileDataObject_SetMetafile", (PyCFunction) _wrap_MetafileDataObject_SetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
38098 { (char *)"MetafileDataObject_GetMetafile", (PyCFunction)_wrap_MetafileDataObject_GetMetafile, METH_O, NULL},
38099 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
38100 { (char *)"MetafileDataObject_swiginit", MetafileDataObject_swiginit, METH_VARARGS, NULL},
38101 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
38102 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
38103 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
38104 { (char *)"delete_DropSource", (PyCFunction)_wrap_delete_DropSource, METH_O, NULL},
38105 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
38106 { (char *)"DropSource_GetDataObject", (PyCFunction)_wrap_DropSource_GetDataObject, METH_O, NULL},
38107 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
38108 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
38109 { (char *)"DropSource_GiveFeedback", (PyCFunction) _wrap_DropSource_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
38110 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
38111 { (char *)"DropSource_swiginit", DropSource_swiginit, METH_VARARGS, NULL},
38112 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
38113 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
38114 { (char *)"delete_DropTarget", (PyCFunction)_wrap_delete_DropTarget, METH_O, NULL},
38115 { (char *)"DropTarget_GetDataObject", (PyCFunction)_wrap_DropTarget_GetDataObject, METH_O, NULL},
38116 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
38117 { (char *)"DropTarget_OnEnter", (PyCFunction) _wrap_DropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
38118 { (char *)"DropTarget_OnDragOver", (PyCFunction) _wrap_DropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
38119 { (char *)"DropTarget_OnLeave", (PyCFunction)_wrap_DropTarget_OnLeave, METH_O, NULL},
38120 { (char *)"DropTarget_OnDrop", (PyCFunction) _wrap_DropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
38121 { (char *)"DropTarget_GetData", (PyCFunction)_wrap_DropTarget_GetData, METH_O, NULL},
38122 { (char *)"DropTarget_SetDefaultAction", (PyCFunction) _wrap_DropTarget_SetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
38123 { (char *)"DropTarget_GetDefaultAction", (PyCFunction)_wrap_DropTarget_GetDefaultAction, METH_O, NULL},
38124 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
38125 { (char *)"DropTarget_swiginit", DropTarget_swiginit, METH_VARARGS, NULL},
38126 { (char *)"new_TextDropTarget", (PyCFunction)_wrap_new_TextDropTarget, METH_NOARGS, NULL},
38127 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
38128 { (char *)"TextDropTarget_OnDropText", (PyCFunction) _wrap_TextDropTarget_OnDropText, METH_VARARGS | METH_KEYWORDS, NULL},
38129 { (char *)"TextDropTarget_OnEnter", (PyCFunction) _wrap_TextDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
38130 { (char *)"TextDropTarget_OnDragOver", (PyCFunction) _wrap_TextDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
38131 { (char *)"TextDropTarget_OnLeave", (PyCFunction)_wrap_TextDropTarget_OnLeave, METH_O, NULL},
38132 { (char *)"TextDropTarget_OnDrop", (PyCFunction) _wrap_TextDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
38133 { (char *)"TextDropTarget_OnData", (PyCFunction) _wrap_TextDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
38134 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
38135 { (char *)"TextDropTarget_swiginit", TextDropTarget_swiginit, METH_VARARGS, NULL},
38136 { (char *)"new_FileDropTarget", (PyCFunction)_wrap_new_FileDropTarget, METH_NOARGS, NULL},
38137 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
38138 { (char *)"FileDropTarget_OnDropFiles", (PyCFunction) _wrap_FileDropTarget_OnDropFiles, METH_VARARGS | METH_KEYWORDS, NULL},
38139 { (char *)"FileDropTarget_OnEnter", (PyCFunction) _wrap_FileDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
38140 { (char *)"FileDropTarget_OnDragOver", (PyCFunction) _wrap_FileDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
38141 { (char *)"FileDropTarget_OnLeave", (PyCFunction)_wrap_FileDropTarget_OnLeave, METH_O, NULL},
38142 { (char *)"FileDropTarget_OnDrop", (PyCFunction) _wrap_FileDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
38143 { (char *)"FileDropTarget_OnData", (PyCFunction) _wrap_FileDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
38144 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
38145 { (char *)"FileDropTarget_swiginit", FileDropTarget_swiginit, METH_VARARGS, NULL},
38146 { (char *)"new_Clipboard", (PyCFunction)_wrap_new_Clipboard, METH_NOARGS, NULL},
38147 { (char *)"delete_Clipboard", (PyCFunction)_wrap_delete_Clipboard, METH_O, NULL},
38148 { (char *)"Clipboard_Open", (PyCFunction)_wrap_Clipboard_Open, METH_O, NULL},
38149 { (char *)"Clipboard_Close", (PyCFunction)_wrap_Clipboard_Close, METH_O, NULL},
38150 { (char *)"Clipboard_IsOpened", (PyCFunction)_wrap_Clipboard_IsOpened, METH_O, NULL},
38151 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
38152 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
38153 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
38154 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
38155 { (char *)"Clipboard_Clear", (PyCFunction)_wrap_Clipboard_Clear, METH_O, NULL},
38156 { (char *)"Clipboard_Flush", (PyCFunction)_wrap_Clipboard_Flush, METH_O, NULL},
38157 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
38158 { (char *)"Clipboard_Get", (PyCFunction)_wrap_Clipboard_Get, METH_NOARGS, NULL},
38159 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
38160 { (char *)"Clipboard_swiginit", Clipboard_swiginit, METH_VARARGS, NULL},
38161 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
38162 { (char *)"delete_ClipboardLocker", (PyCFunction)_wrap_delete_ClipboardLocker, METH_O, NULL},
38163 { (char *)"ClipboardLocker___nonzero__", (PyCFunction)_wrap_ClipboardLocker___nonzero__, METH_O, NULL},
38164 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
38165 { (char *)"ClipboardLocker_swiginit", ClipboardLocker_swiginit, METH_VARARGS, NULL},
38166 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
38167 { (char *)"delete_VideoMode", (PyCFunction)_wrap_delete_VideoMode, METH_O, NULL},
38168 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
38169 { (char *)"VideoMode_GetWidth", (PyCFunction)_wrap_VideoMode_GetWidth, METH_O, NULL},
38170 { (char *)"VideoMode_GetHeight", (PyCFunction)_wrap_VideoMode_GetHeight, METH_O, NULL},
38171 { (char *)"VideoMode_GetDepth", (PyCFunction)_wrap_VideoMode_GetDepth, METH_O, NULL},
38172 { (char *)"VideoMode_IsOk", (PyCFunction)_wrap_VideoMode_IsOk, METH_O, NULL},
38173 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
38174 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
38175 { (char *)"VideoMode_w_set", _wrap_VideoMode_w_set, METH_VARARGS, NULL},
38176 { (char *)"VideoMode_w_get", (PyCFunction)_wrap_VideoMode_w_get, METH_O, NULL},
38177 { (char *)"VideoMode_h_set", _wrap_VideoMode_h_set, METH_VARARGS, NULL},
38178 { (char *)"VideoMode_h_get", (PyCFunction)_wrap_VideoMode_h_get, METH_O, NULL},
38179 { (char *)"VideoMode_bpp_set", _wrap_VideoMode_bpp_set, METH_VARARGS, NULL},
38180 { (char *)"VideoMode_bpp_get", (PyCFunction)_wrap_VideoMode_bpp_get, METH_O, NULL},
38181 { (char *)"VideoMode_refresh_set", _wrap_VideoMode_refresh_set, METH_VARARGS, NULL},
38182 { (char *)"VideoMode_refresh_get", (PyCFunction)_wrap_VideoMode_refresh_get, METH_O, NULL},
38183 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
38184 { (char *)"VideoMode_swiginit", VideoMode_swiginit, METH_VARARGS, NULL},
38185 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
38186 { (char *)"delete_Display", (PyCFunction)_wrap_delete_Display, METH_O, NULL},
38187 { (char *)"Display_GetCount", (PyCFunction)_wrap_Display_GetCount, METH_NOARGS, NULL},
38188 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
38189 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
38190 { (char *)"Display_IsOk", (PyCFunction)_wrap_Display_IsOk, METH_O, NULL},
38191 { (char *)"Display_GetGeometry", (PyCFunction)_wrap_Display_GetGeometry, METH_O, NULL},
38192 { (char *)"Display_GetClientArea", (PyCFunction)_wrap_Display_GetClientArea, METH_O, NULL},
38193 { (char *)"Display_GetName", (PyCFunction)_wrap_Display_GetName, METH_O, NULL},
38194 { (char *)"Display_IsPrimary", (PyCFunction)_wrap_Display_IsPrimary, METH_O, NULL},
38195 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
38196 { (char *)"Display_GetCurrentMode", (PyCFunction)_wrap_Display_GetCurrentMode, METH_O, NULL},
38197 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
38198 { (char *)"Display_ResetMode", (PyCFunction)_wrap_Display_ResetMode, METH_O, NULL},
38199 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
38200 { (char *)"Display_swiginit", Display_swiginit, METH_VARARGS, NULL},
38201 { (char *)"StandardPaths_Get", (PyCFunction)_wrap_StandardPaths_Get, METH_NOARGS, NULL},
38202 { (char *)"StandardPaths_GetConfigDir", (PyCFunction)_wrap_StandardPaths_GetConfigDir, METH_O, NULL},
38203 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction)_wrap_StandardPaths_GetUserConfigDir, METH_O, NULL},
38204 { (char *)"StandardPaths_GetDataDir", (PyCFunction)_wrap_StandardPaths_GetDataDir, METH_O, NULL},
38205 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetLocalDataDir, METH_O, NULL},
38206 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction)_wrap_StandardPaths_GetUserDataDir, METH_O, NULL},
38207 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetUserLocalDataDir, METH_O, NULL},
38208 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction)_wrap_StandardPaths_GetPluginsDir, METH_O, NULL},
38209 { (char *)"StandardPaths_GetResourcesDir", (PyCFunction)_wrap_StandardPaths_GetResourcesDir, METH_O, NULL},
38210 { (char *)"StandardPaths_GetLocalizedResourcesDir", (PyCFunction) _wrap_StandardPaths_GetLocalizedResourcesDir, METH_VARARGS | METH_KEYWORDS, NULL},
38211 { (char *)"StandardPaths_GetDocumentsDir", (PyCFunction)_wrap_StandardPaths_GetDocumentsDir, METH_O, NULL},
38212 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
38213 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction)_wrap_StandardPaths_GetInstallPrefix, METH_O, NULL},
38214 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
38215 { (char *)"new_PowerEvent", (PyCFunction) _wrap_new_PowerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
38216 { (char *)"PowerEvent_Veto", (PyCFunction)_wrap_PowerEvent_Veto, METH_O, NULL},
38217 { (char *)"PowerEvent_IsVetoed", (PyCFunction)_wrap_PowerEvent_IsVetoed, METH_O, NULL},
38218 { (char *)"PowerEvent_swigregister", PowerEvent_swigregister, METH_VARARGS, NULL},
38219 { (char *)"PowerEvent_swiginit", PowerEvent_swiginit, METH_VARARGS, NULL},
38220 { (char *)"GetPowerType", (PyCFunction)_wrap_GetPowerType, METH_NOARGS, NULL},
38221 { (char *)"GetBatteryState", (PyCFunction)_wrap_GetBatteryState, METH_NOARGS, NULL},
38222 { NULL, NULL, 0, NULL }
38223 };
38224
38225
38226 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
38227
38228 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
38229 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
38230 }
38231 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
38232 return (void *)((wxEvent *) ((wxMenuEvent *) x));
38233 }
38234 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
38235 return (void *)((wxEvent *) ((wxCloseEvent *) x));
38236 }
38237 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
38238 return (void *)((wxEvent *) ((wxMouseEvent *) x));
38239 }
38240 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
38241 return (void *)((wxEvent *) ((wxEraseEvent *) x));
38242 }
38243 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
38244 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
38245 }
38246 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
38247 return (void *)((wxEvent *) ((wxTimerEvent *) x));
38248 }
38249 static void *_p_wxPowerEventTo_p_wxEvent(void *x) {
38250 return (void *)((wxEvent *) ((wxPowerEvent *) x));
38251 }
38252 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
38253 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
38254 }
38255 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
38256 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
38257 }
38258 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
38259 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
38260 }
38261 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
38262 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
38263 }
38264 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
38265 return (void *)((wxEvent *) ((wxPyEvent *) x));
38266 }
38267 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
38268 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
38269 }
38270 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
38271 return (void *)((wxEvent *) ((wxIdleEvent *) x));
38272 }
38273 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
38274 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
38275 }
38276 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
38277 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
38278 }
38279 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
38280 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
38281 }
38282 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
38283 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
38284 }
38285 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
38286 return (void *)((wxEvent *) ((wxActivateEvent *) x));
38287 }
38288 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
38289 return (void *)((wxEvent *) ((wxSizeEvent *) x));
38290 }
38291 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
38292 return (void *)((wxEvent *) ((wxMoveEvent *) x));
38293 }
38294 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
38295 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
38296 }
38297 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
38298 return (void *)((wxEvent *) ((wxPaintEvent *) x));
38299 }
38300 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
38301 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
38302 }
38303 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
38304 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
38305 }
38306 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
38307 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
38308 }
38309 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
38310 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
38311 }
38312 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
38313 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
38314 }
38315 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
38316 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
38317 }
38318 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
38319 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
38320 }
38321 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
38322 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
38323 }
38324 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
38325 return (void *)((wxEvent *) ((wxFocusEvent *) x));
38326 }
38327 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
38328 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
38329 }
38330 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
38331 return (void *)((wxEvent *) ((wxProcessEvent *) x));
38332 }
38333 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
38334 return (void *)((wxEvent *) ((wxShowEvent *) x));
38335 }
38336 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
38337 return (void *)((wxEvent *) ((wxCommandEvent *) x));
38338 }
38339 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
38340 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
38341 }
38342 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
38343 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
38344 }
38345 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
38346 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
38347 }
38348 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
38349 return (void *)((wxEvent *) ((wxKeyEvent *) x));
38350 }
38351 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
38352 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
38353 }
38354 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
38355 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
38356 }
38357 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
38358 return (void *)((wxConfigBase *) ((wxConfig *) x));
38359 }
38360 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
38361 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
38362 }
38363 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
38364 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
38365 }
38366 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
38367 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
38368 }
38369 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
38370 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
38371 }
38372 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
38373 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
38374 }
38375 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
38376 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
38377 }
38378 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
38379 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
38380 }
38381 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
38382 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
38383 }
38384 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
38385 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
38386 }
38387 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
38388 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
38389 }
38390 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
38391 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
38392 }
38393 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
38394 return (void *)((wxDataObject *) ((wxURLDataObject *) x));
38395 }
38396 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
38397 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
38398 }
38399 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
38400 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
38401 }
38402 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
38403 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
38404 }
38405 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
38406 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
38407 }
38408 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
38409 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
38410 }
38411 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
38412 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
38413 }
38414 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
38415 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
38416 }
38417 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
38418 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
38419 }
38420 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
38421 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
38422 }
38423 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
38424 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
38425 }
38426 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
38427 return (void *)((wxEvtHandler *) ((wxWindow *) x));
38428 }
38429 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
38430 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
38431 }
38432 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
38433 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
38434 }
38435 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
38436 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
38437 }
38438 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
38439 return (void *)((wxEvtHandler *) ((wxValidator *) x));
38440 }
38441 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
38442 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
38443 }
38444 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
38445 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
38446 }
38447 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
38448 return (void *)((wxEvtHandler *) ((wxMenu *) x));
38449 }
38450 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
38451 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
38452 }
38453 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
38454 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
38455 }
38456 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
38457 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
38458 }
38459 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
38460 return (void *)((wxObject *) ((wxSizerItem *) x));
38461 }
38462 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
38463 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
38464 }
38465 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
38466 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
38467 }
38468 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
38469 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
38470 }
38471 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
38472 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
38473 }
38474 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
38475 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
38476 }
38477 static void *_p_wxSizerTo_p_wxObject(void *x) {
38478 return (void *)((wxObject *) ((wxSizer *) x));
38479 }
38480 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
38481 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
38482 }
38483 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
38484 return (void *)((wxObject *) ((wxFileHistory *) x));
38485 }
38486 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
38487 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
38488 }
38489 static void *_p_wxEventTo_p_wxObject(void *x) {
38490 return (void *)((wxObject *) ((wxEvent *) x));
38491 }
38492 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
38493 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
38494 }
38495 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
38496 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
38497 }
38498 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
38499 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
38500 }
38501 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
38502 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
38503 }
38504 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
38505 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
38506 }
38507 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
38508 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
38509 }
38510 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
38511 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
38512 }
38513 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
38514 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
38515 }
38516 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
38517 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
38518 }
38519 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
38520 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
38521 }
38522 static void *_p_wxControlTo_p_wxObject(void *x) {
38523 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
38524 }
38525 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
38526 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
38527 }
38528 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
38529 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
38530 }
38531 static void *_p_wxPowerEventTo_p_wxObject(void *x) {
38532 return (void *)((wxObject *) (wxEvent *) ((wxPowerEvent *) x));
38533 }
38534 static void *_p_wxFSFileTo_p_wxObject(void *x) {
38535 return (void *)((wxObject *) ((wxFSFile *) x));
38536 }
38537 static void *_p_wxClipboardTo_p_wxObject(void *x) {
38538 return (void *)((wxObject *) ((wxClipboard *) x));
38539 }
38540 static void *_p_wxPySizerTo_p_wxObject(void *x) {
38541 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
38542 }
38543 static void *_p_wxPyEventTo_p_wxObject(void *x) {
38544 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
38545 }
38546 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
38547 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
38548 }
38549 static void *_p_wxShowEventTo_p_wxObject(void *x) {
38550 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
38551 }
38552 static void *_p_wxToolTipTo_p_wxObject(void *x) {
38553 return (void *)((wxObject *) ((wxToolTip *) x));
38554 }
38555 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
38556 return (void *)((wxObject *) ((wxMenuItem *) x));
38557 }
38558 static void *_p_wxDateEventTo_p_wxObject(void *x) {
38559 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
38560 }
38561 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
38562 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
38563 }
38564 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
38565 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
38566 }
38567 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
38568 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
38569 }
38570 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
38571 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
38572 }
38573 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
38574 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
38575 }
38576 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
38577 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
38578 }
38579 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
38580 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
38581 }
38582 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
38583 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
38584 }
38585 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
38586 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
38587 }
38588 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
38589 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
38590 }
38591 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
38592 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
38593 }
38594 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
38595 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
38596 }
38597 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
38598 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
38599 }
38600 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
38601 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
38602 }
38603 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
38604 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
38605 }
38606 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
38607 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
38608 }
38609 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
38610 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
38611 }
38612 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
38613 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
38614 }
38615 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
38616 return (void *)((wxObject *) ((wxImageHandler *) x));
38617 }
38618 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
38619 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
38620 }
38621 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
38622 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
38623 }
38624 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
38625 return (void *)((wxObject *) ((wxEvtHandler *) x));
38626 }
38627 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
38628 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
38629 }
38630 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
38631 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
38632 }
38633 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
38634 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
38635 }
38636 static void *_p_wxImageTo_p_wxObject(void *x) {
38637 return (void *)((wxObject *) ((wxImage *) x));
38638 }
38639 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
38640 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
38641 }
38642 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
38643 return (void *)((wxObject *) ((wxSystemOptions *) x));
38644 }
38645 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
38646 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
38647 }
38648 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
38649 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
38650 }
38651 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
38652 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
38653 }
38654 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
38655 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
38656 }
38657 static void *_p_wxWindowTo_p_wxObject(void *x) {
38658 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
38659 }
38660 static void *_p_wxMenuTo_p_wxObject(void *x) {
38661 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
38662 }
38663 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
38664 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
38665 }
38666 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
38667 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
38668 }
38669 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
38670 return (void *)((wxObject *) ((wxFileSystem *) x));
38671 }
38672 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
38673 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
38674 }
38675 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
38676 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
38677 }
38678 static void *_p_wxPyAppTo_p_wxObject(void *x) {
38679 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
38680 }
38681 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
38682 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
38683 }
38684 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
38685 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
38686 }
38687 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
38688 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
38689 }
38690 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
38691 return (void *)((wxObject *) ((wxBusyInfo *) x));
38692 }
38693 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
38694 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
38695 }
38696 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
38697 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
38698 }
38699 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
38700 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
38701 }
38702 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
38703 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
38704 }
38705 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
38706 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
38707 }
38708 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
38709 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
38710 }
38711 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
38712 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
38713 }
38714 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
38715 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
38716 }
38717 static void *_p_wxValidatorTo_p_wxObject(void *x) {
38718 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
38719 }
38720 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
38721 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
38722 }
38723 static void *_p_wxLogBufferTo_p_wxLog(void *x) {
38724 return (void *)((wxLog *) ((wxLogBuffer *) x));
38725 }
38726 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
38727 return (void *)((wxLog *) ((wxLogStderr *) x));
38728 }
38729 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
38730 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
38731 }
38732 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
38733 return (void *)((wxLog *) ((wxLogWindow *) x));
38734 }
38735 static void *_p_wxLogChainTo_p_wxLog(void *x) {
38736 return (void *)((wxLog *) ((wxLogChain *) x));
38737 }
38738 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
38739 return (void *)((wxLog *) ((wxLogGui *) x));
38740 }
38741 static void *_p_wxPyLogTo_p_wxLog(void *x) {
38742 return (void *)((wxLog *) ((wxPyLog *) x));
38743 }
38744 static void *_p_wxControlTo_p_wxWindow(void *x) {
38745 return (void *)((wxWindow *) ((wxControl *) x));
38746 }
38747 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
38748 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
38749 }
38750 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
38751 return (void *)((wxWindow *) ((wxMenuBar *) x));
38752 }
38753 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
38754 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
38755 }
38756 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
38757 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
38758 }
38759 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
38760 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};
38761 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
38762 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
38763 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
38764 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxLogLevel *", 0, 0, (void*)0, 0};
38765 static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
38766 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
38767 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
38768 static swig_type_info _swigt__p_wxBitmapDataObject = {"_p_wxBitmapDataObject", "wxBitmapDataObject *", 0, 0, (void*)0, 0};
38769 static swig_type_info _swigt__p_wxBusyCursor = {"_p_wxBusyCursor", "wxBusyCursor *", 0, 0, (void*)0, 0};
38770 static swig_type_info _swigt__p_wxBusyInfo = {"_p_wxBusyInfo", "wxBusyInfo *", 0, 0, (void*)0, 0};
38771 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
38772 static swig_type_info _swigt__p_wxChar = {"_p_wxChar", "wxChar *", 0, 0, (void*)0, 0};
38773 static swig_type_info _swigt__p_wxClipboard = {"_p_wxClipboard", "wxClipboard *", 0, 0, (void*)0, 0};
38774 static swig_type_info _swigt__p_wxClipboardLocker = {"_p_wxClipboardLocker", "wxClipboardLocker *", 0, 0, (void*)0, 0};
38775 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
38776 static swig_type_info _swigt__p_wxConfig = {"_p_wxConfig", "wxConfig *", 0, 0, (void*)0, 0};
38777 static swig_type_info _swigt__p_wxConfigBase = {"_p_wxConfigBase", "wxConfigBase *", 0, 0, (void*)0, 0};
38778 static swig_type_info _swigt__p_wxConfigPathChanger = {"_p_wxConfigPathChanger", "wxConfigPathChanger *", 0, 0, (void*)0, 0};
38779 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
38780 static swig_type_info _swigt__p_wxCustomDataObject = {"_p_wxCustomDataObject", "wxCustomDataObject *", 0, 0, (void*)0, 0};
38781 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
38782 static swig_type_info _swigt__p_wxDataFormat = {"_p_wxDataFormat", "wxDataFormat *", 0, 0, (void*)0, 0};
38783 static swig_type_info _swigt__p_wxDataObject = {"_p_wxDataObject", "wxDataObject *", 0, 0, (void*)0, 0};
38784 static swig_type_info _swigt__p_wxDataObjectComposite = {"_p_wxDataObjectComposite", "wxDataObjectComposite *", 0, 0, (void*)0, 0};
38785 static swig_type_info _swigt__p_wxDataObjectSimple = {"_p_wxDataObjectSimple", "wxDataObjectSimple *", 0, 0, (void*)0, 0};
38786 static swig_type_info _swigt__p_wxDateSpan = {"_p_wxDateSpan", "wxDateSpan *", 0, 0, (void*)0, 0};
38787 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
38788 static swig_type_info _swigt__p_wxDateTime__TimeZone = {"_p_wxDateTime__TimeZone", "wxDateTime::TimeZone *", 0, 0, (void*)0, 0};
38789 static swig_type_info _swigt__p_wxDisplay = {"_p_wxDisplay", "wxDisplay *", 0, 0, (void*)0, 0};
38790 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
38791 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
38792 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0, 0};
38793 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0, 0};
38794 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0, 0};
38795 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0, 0};
38796 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0, 0};
38797 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0, 0};
38798 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0, 0};
38799 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0, 0};
38800 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", 0, 0, 0, 0, 0};
38801 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0, 0};
38802 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", 0, 0, 0, 0, 0};
38803 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0, 0};
38804 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0};
38805 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0};
38806 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0, 0};
38807 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0, 0};
38808 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0, 0};
38809 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0, 0};
38810 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0, 0};
38811 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0, 0};
38812 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0, 0};
38813 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0, 0};
38814 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", 0, 0, 0, 0, 0};
38815 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0};
38816 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0};
38817 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0};
38818 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0};
38819 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0};
38820 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0, 0};
38821 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0, 0};
38822 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0, 0};
38823 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0, 0};
38824 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", 0, 0, 0, 0, 0};
38825 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0, 0};
38826 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0};
38827 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0};
38828 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", 0, 0, 0, 0, 0};
38829 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0, 0};
38830 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
38831 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", 0, 0, 0, 0, 0};
38832 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0, 0};
38833 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0, 0};
38834 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0, 0};
38835 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0, 0};
38836 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0, 0};
38837 static swig_type_info _swigt__p_wxFileConfig = {"_p_wxFileConfig", "wxFileConfig *", 0, 0, (void*)0, 0};
38838 static swig_type_info _swigt__p_wxFileDataObject = {"_p_wxFileDataObject", "wxFileDataObject *", 0, 0, (void*)0, 0};
38839 static swig_type_info _swigt__p_wxFileHistory = {"_p_wxFileHistory", "wxFileHistory *", 0, 0, (void*)0, 0};
38840 static swig_type_info _swigt__p_wxFileType = {"_p_wxFileType", "wxFileType *", 0, 0, (void*)0, 0};
38841 static swig_type_info _swigt__p_wxFileTypeInfo = {"_p_wxFileTypeInfo", "wxFileTypeInfo *", 0, 0, (void*)0, 0};
38842 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
38843 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
38844 static swig_type_info _swigt__p_wxIcon = {"_p_wxIcon", "wxIcon *", 0, 0, (void*)0, 0};
38845 static swig_type_info _swigt__p_wxJoystick = {"_p_wxJoystick", "wxJoystick *", 0, 0, (void*)0, 0};
38846 static swig_type_info _swigt__p_wxJoystickEvent = {"_p_wxJoystickEvent", "wxJoystickEvent *", 0, 0, (void*)0, 0};
38847 static swig_type_info _swigt__p_wxKillError = {"_p_wxKillError", "enum wxKillError *|wxKillError *", 0, 0, (void*)0, 0};
38848 static swig_type_info _swigt__p_wxLog = {"_p_wxLog", "wxLog *", 0, 0, (void*)0, 0};
38849 static swig_type_info _swigt__p_wxLogBuffer = {"_p_wxLogBuffer", "wxLogBuffer *", 0, 0, (void*)0, 0};
38850 static swig_type_info _swigt__p_wxLogChain = {"_p_wxLogChain", "wxLogChain *", 0, 0, (void*)0, 0};
38851 static swig_type_info _swigt__p_wxLogGui = {"_p_wxLogGui", "wxLogGui *", 0, 0, (void*)0, 0};
38852 static swig_type_info _swigt__p_wxLogNull = {"_p_wxLogNull", "wxLogNull *", 0, 0, (void*)0, 0};
38853 static swig_type_info _swigt__p_wxLogStderr = {"_p_wxLogStderr", "wxLogStderr *", 0, 0, (void*)0, 0};
38854 static swig_type_info _swigt__p_wxLogTextCtrl = {"_p_wxLogTextCtrl", "wxLogTextCtrl *", 0, 0, (void*)0, 0};
38855 static swig_type_info _swigt__p_wxLogWindow = {"_p_wxLogWindow", "wxLogWindow *", 0, 0, (void*)0, 0};
38856 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
38857 static swig_type_info _swigt__p_wxMetafile = {"_p_wxMetafile", "wxMetafile *", 0, 0, (void*)0, 0};
38858 static swig_type_info _swigt__p_wxMetafileDataObject = {"_p_wxMetafileDataObject", "wxMetafileDataObject *", 0, 0, (void*)0, 0};
38859 static swig_type_info _swigt__p_wxMimeTypesManager = {"_p_wxMimeTypesManager", "wxMimeTypesManager *", 0, 0, (void*)0, 0};
38860 static swig_type_info _swigt__p_wxMouseState = {"_p_wxMouseState", "wxMouseState *", 0, 0, (void*)0, 0};
38861 static swig_type_info _swigt__p_wxMutexGuiLocker = {"_p_wxMutexGuiLocker", "wxMutexGuiLocker *", 0, 0, (void*)0, 0};
38862 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
38863 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0, 0};
38864 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0, 0};
38865 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0, 0};
38866 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0};
38867 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0};
38868 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0, 0};
38869 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0, 0};
38870 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0, 0};
38871 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0, 0};
38872 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0, 0};
38873 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0, 0};
38874 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0, 0};
38875 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0, 0};
38876 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0, 0};
38877 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0, 0};
38878 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0, 0};
38879 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0, 0};
38880 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0, 0};
38881 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0, 0};
38882 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0, 0};
38883 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0, 0};
38884 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0, 0};
38885 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0, 0};
38886 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0, 0};
38887 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0, 0};
38888 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0, 0};
38889 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0};
38890 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0, 0};
38891 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", 0, 0, 0, 0, 0};
38892 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0, 0};
38893 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
38894 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
38895 static swig_type_info _swigt__p_wxPlatformInfo = {"_p_wxPlatformInfo", "wxPlatformInfo *", 0, 0, (void*)0, 0};
38896 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
38897 static swig_type_info _swigt__p_wxPowerEvent = {"_p_wxPowerEvent", "wxPowerEvent *", 0, 0, (void*)0, 0};
38898 static swig_type_info _swigt__p_wxProcessEvent = {"_p_wxProcessEvent", "wxProcessEvent *", 0, 0, (void*)0, 0};
38899 static swig_type_info _swigt__p_wxPyArtProvider = {"_p_wxPyArtProvider", "wxPyArtProvider *", 0, 0, (void*)0, 0};
38900 static swig_type_info _swigt__p_wxPyBitmapDataObject = {"_p_wxPyBitmapDataObject", "wxPyBitmapDataObject *", 0, 0, (void*)0, 0};
38901 static swig_type_info _swigt__p_wxPyDataObjectSimple = {"_p_wxPyDataObjectSimple", "wxPyDataObjectSimple *", 0, 0, (void*)0, 0};
38902 static swig_type_info _swigt__p_wxPyDropSource = {"_p_wxPyDropSource", "wxPyDropSource *", 0, 0, (void*)0, 0};
38903 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
38904 static swig_type_info _swigt__p_wxPyFileDropTarget = {"_p_wxPyFileDropTarget", "wxPyFileDropTarget *", 0, 0, (void*)0, 0};
38905 static swig_type_info _swigt__p_wxPyLog = {"_p_wxPyLog", "wxPyLog *", 0, 0, (void*)0, 0};
38906 static swig_type_info _swigt__p_wxPyProcess = {"_p_wxPyProcess", "wxPyProcess *", 0, 0, (void*)0, 0};
38907 static swig_type_info _swigt__p_wxPyTextDataObject = {"_p_wxPyTextDataObject", "wxPyTextDataObject *", 0, 0, (void*)0, 0};
38908 static swig_type_info _swigt__p_wxPyTextDropTarget = {"_p_wxPyTextDropTarget", "wxPyTextDropTarget *", 0, 0, (void*)0, 0};
38909 static swig_type_info _swigt__p_wxPyTimer = {"_p_wxPyTimer", "wxPyTimer *", 0, 0, (void*)0, 0};
38910 static swig_type_info _swigt__p_wxPyTipProvider = {"_p_wxPyTipProvider", "wxPyTipProvider *", 0, 0, (void*)0, 0};
38911 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
38912 static swig_type_info _swigt__p_wxSingleInstanceChecker = {"_p_wxSingleInstanceChecker", "wxSingleInstanceChecker *", 0, 0, (void*)0, 0};
38913 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
38914 static swig_type_info _swigt__p_wxSound = {"_p_wxSound", "wxSound *", 0, 0, (void*)0, 0};
38915 static swig_type_info _swigt__p_wxStandardPaths = {"_p_wxStandardPaths", "wxStandardPaths *", 0, 0, (void*)0, 0};
38916 static swig_type_info _swigt__p_wxStopWatch = {"_p_wxStopWatch", "wxStopWatch *", 0, 0, (void*)0, 0};
38917 static swig_type_info _swigt__p_wxString = {"_p_wxString", "wxString *", 0, 0, (void*)0, 0};
38918 static swig_type_info _swigt__p_wxSystemOptions = {"_p_wxSystemOptions", "wxSystemOptions *", 0, 0, (void*)0, 0};
38919 static swig_type_info _swigt__p_wxSystemSettings = {"_p_wxSystemSettings", "wxSystemSettings *", 0, 0, (void*)0, 0};
38920 static swig_type_info _swigt__p_wxTextCtrl = {"_p_wxTextCtrl", "wxTextCtrl *", 0, 0, (void*)0, 0};
38921 static swig_type_info _swigt__p_wxTextDataObject = {"_p_wxTextDataObject", "wxTextDataObject *", 0, 0, (void*)0, 0};
38922 static swig_type_info _swigt__p_wxTimeSpan = {"_p_wxTimeSpan", "wxTimeSpan *", 0, 0, (void*)0, 0};
38923 static swig_type_info _swigt__p_wxTimer = {"_p_wxTimer", "wxTimer *", 0, 0, (void*)0, 0};
38924 static swig_type_info _swigt__p_wxTimerEvent = {"_p_wxTimerEvent", "wxTimerEvent *", 0, 0, (void*)0, 0};
38925 static swig_type_info _swigt__p_wxTimerRunner = {"_p_wxTimerRunner", "wxTimerRunner *", 0, 0, (void*)0, 0};
38926 static swig_type_info _swigt__p_wxTipProvider = {"_p_wxTipProvider", "wxTipProvider *", 0, 0, (void*)0, 0};
38927 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
38928 static swig_type_info _swigt__p_wxURLDataObject = {"_p_wxURLDataObject", "wxURLDataObject *", 0, 0, (void*)0, 0};
38929 static swig_type_info _swigt__p_wxVideoMode = {"_p_wxVideoMode", "wxVideoMode *", 0, 0, (void*)0, 0};
38930 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
38931 static swig_type_info _swigt__p_wxWindowDisabler = {"_p_wxWindowDisabler", "wxWindowDisabler *", 0, 0, (void*)0, 0};
38932
38933 static swig_type_info *swig_type_initial[] = {
38934 &_swigt__p_char,
38935 &_swigt__p_form_ops_t,
38936 &_swigt__p_int,
38937 &_swigt__p_unsigned_char,
38938 &_swigt__p_unsigned_int,
38939 &_swigt__p_unsigned_long,
38940 &_swigt__p_void,
38941 &_swigt__p_wxANIHandler,
38942 &_swigt__p_wxAcceleratorTable,
38943 &_swigt__p_wxActivateEvent,
38944 &_swigt__p_wxArrayString,
38945 &_swigt__p_wxBMPHandler,
38946 &_swigt__p_wxBitmap,
38947 &_swigt__p_wxBitmapDataObject,
38948 &_swigt__p_wxBoxSizer,
38949 &_swigt__p_wxBusyCursor,
38950 &_swigt__p_wxBusyInfo,
38951 &_swigt__p_wxCURHandler,
38952 &_swigt__p_wxCaret,
38953 &_swigt__p_wxChar,
38954 &_swigt__p_wxChildFocusEvent,
38955 &_swigt__p_wxClipboard,
38956 &_swigt__p_wxClipboardLocker,
38957 &_swigt__p_wxClipboardTextEvent,
38958 &_swigt__p_wxCloseEvent,
38959 &_swigt__p_wxColour,
38960 &_swigt__p_wxCommandEvent,
38961 &_swigt__p_wxConfig,
38962 &_swigt__p_wxConfigBase,
38963 &_swigt__p_wxConfigPathChanger,
38964 &_swigt__p_wxContextMenuEvent,
38965 &_swigt__p_wxControl,
38966 &_swigt__p_wxControlWithItems,
38967 &_swigt__p_wxCursor,
38968 &_swigt__p_wxCustomDataObject,
38969 &_swigt__p_wxDC,
38970 &_swigt__p_wxDataFormat,
38971 &_swigt__p_wxDataObject,
38972 &_swigt__p_wxDataObjectComposite,
38973 &_swigt__p_wxDataObjectSimple,
38974 &_swigt__p_wxDateEvent,
38975 &_swigt__p_wxDateSpan,
38976 &_swigt__p_wxDateTime,
38977 &_swigt__p_wxDateTime__TimeZone,
38978 &_swigt__p_wxDisplay,
38979 &_swigt__p_wxDisplayChangedEvent,
38980 &_swigt__p_wxDropFilesEvent,
38981 &_swigt__p_wxDuplexMode,
38982 &_swigt__p_wxEraseEvent,
38983 &_swigt__p_wxEvent,
38984 &_swigt__p_wxEvtHandler,
38985 &_swigt__p_wxFSFile,
38986 &_swigt__p_wxFileConfig,
38987 &_swigt__p_wxFileDataObject,
38988 &_swigt__p_wxFileHistory,
38989 &_swigt__p_wxFileSystem,
38990 &_swigt__p_wxFileType,
38991 &_swigt__p_wxFileTypeInfo,
38992 &_swigt__p_wxFlexGridSizer,
38993 &_swigt__p_wxFocusEvent,
38994 &_swigt__p_wxFont,
38995 &_swigt__p_wxFrame,
38996 &_swigt__p_wxGBSizerItem,
38997 &_swigt__p_wxGIFHandler,
38998 &_swigt__p_wxGridBagSizer,
38999 &_swigt__p_wxGridSizer,
39000 &_swigt__p_wxICOHandler,
39001 &_swigt__p_wxIcon,
39002 &_swigt__p_wxIconizeEvent,
39003 &_swigt__p_wxIdleEvent,
39004 &_swigt__p_wxImage,
39005 &_swigt__p_wxImageHandler,
39006 &_swigt__p_wxIndividualLayoutConstraint,
39007 &_swigt__p_wxInitDialogEvent,
39008 &_swigt__p_wxJPEGHandler,
39009 &_swigt__p_wxJoystick,
39010 &_swigt__p_wxJoystickEvent,
39011 &_swigt__p_wxKeyEvent,
39012 &_swigt__p_wxKillError,
39013 &_swigt__p_wxLayoutConstraints,
39014 &_swigt__p_wxLog,
39015 &_swigt__p_wxLogBuffer,
39016 &_swigt__p_wxLogChain,
39017 &_swigt__p_wxLogGui,
39018 &_swigt__p_wxLogNull,
39019 &_swigt__p_wxLogStderr,
39020 &_swigt__p_wxLogTextCtrl,
39021 &_swigt__p_wxLogWindow,
39022 &_swigt__p_wxMaximizeEvent,
39023 &_swigt__p_wxMenu,
39024 &_swigt__p_wxMenuBar,
39025 &_swigt__p_wxMenuEvent,
39026 &_swigt__p_wxMenuItem,
39027 &_swigt__p_wxMetafile,
39028 &_swigt__p_wxMetafileDataObject,
39029 &_swigt__p_wxMimeTypesManager,
39030 &_swigt__p_wxMouseCaptureChangedEvent,
39031 &_swigt__p_wxMouseCaptureLostEvent,
39032 &_swigt__p_wxMouseEvent,
39033 &_swigt__p_wxMouseState,
39034 &_swigt__p_wxMoveEvent,
39035 &_swigt__p_wxMutexGuiLocker,
39036 &_swigt__p_wxNavigationKeyEvent,
39037 &_swigt__p_wxNcPaintEvent,
39038 &_swigt__p_wxNotifyEvent,
39039 &_swigt__p_wxObject,
39040 &_swigt__p_wxOutputStream,
39041 &_swigt__p_wxPCXHandler,
39042 &_swigt__p_wxPNGHandler,
39043 &_swigt__p_wxPNMHandler,
39044 &_swigt__p_wxPaintEvent,
39045 &_swigt__p_wxPaletteChangedEvent,
39046 &_swigt__p_wxPaperSize,
39047 &_swigt__p_wxPlatformInfo,
39048 &_swigt__p_wxPoint,
39049 &_swigt__p_wxPowerEvent,
39050 &_swigt__p_wxProcessEvent,
39051 &_swigt__p_wxPyApp,
39052 &_swigt__p_wxPyArtProvider,
39053 &_swigt__p_wxPyBitmapDataObject,
39054 &_swigt__p_wxPyCommandEvent,
39055 &_swigt__p_wxPyDataObjectSimple,
39056 &_swigt__p_wxPyDropSource,
39057 &_swigt__p_wxPyDropTarget,
39058 &_swigt__p_wxPyEvent,
39059 &_swigt__p_wxPyFileDropTarget,
39060 &_swigt__p_wxPyImageHandler,
39061 &_swigt__p_wxPyLog,
39062 &_swigt__p_wxPyProcess,
39063 &_swigt__p_wxPySizer,
39064 &_swigt__p_wxPyTextDataObject,
39065 &_swigt__p_wxPyTextDropTarget,
39066 &_swigt__p_wxPyTimer,
39067 &_swigt__p_wxPyTipProvider,
39068 &_swigt__p_wxPyValidator,
39069 &_swigt__p_wxQueryNewPaletteEvent,
39070 &_swigt__p_wxRect,
39071 &_swigt__p_wxScrollEvent,
39072 &_swigt__p_wxScrollWinEvent,
39073 &_swigt__p_wxSetCursorEvent,
39074 &_swigt__p_wxShowEvent,
39075 &_swigt__p_wxSingleInstanceChecker,
39076 &_swigt__p_wxSize,
39077 &_swigt__p_wxSizeEvent,
39078 &_swigt__p_wxSizer,
39079 &_swigt__p_wxSizerItem,
39080 &_swigt__p_wxSound,
39081 &_swigt__p_wxStandardPaths,
39082 &_swigt__p_wxStaticBoxSizer,
39083 &_swigt__p_wxStdDialogButtonSizer,
39084 &_swigt__p_wxStopWatch,
39085 &_swigt__p_wxString,
39086 &_swigt__p_wxSysColourChangedEvent,
39087 &_swigt__p_wxSystemOptions,
39088 &_swigt__p_wxSystemSettings,
39089 &_swigt__p_wxTIFFHandler,
39090 &_swigt__p_wxTextCtrl,
39091 &_swigt__p_wxTextDataObject,
39092 &_swigt__p_wxTimeSpan,
39093 &_swigt__p_wxTimer,
39094 &_swigt__p_wxTimerEvent,
39095 &_swigt__p_wxTimerRunner,
39096 &_swigt__p_wxTipProvider,
39097 &_swigt__p_wxToolTip,
39098 &_swigt__p_wxURLDataObject,
39099 &_swigt__p_wxUpdateUIEvent,
39100 &_swigt__p_wxValidator,
39101 &_swigt__p_wxVideoMode,
39102 &_swigt__p_wxWindow,
39103 &_swigt__p_wxWindowCreateEvent,
39104 &_swigt__p_wxWindowDestroyEvent,
39105 &_swigt__p_wxWindowDisabler,
39106 &_swigt__p_wxXPMHandler,
39107 };
39108
39109 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
39110 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
39111 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
39112 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
39113 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
39114 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
39115 static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
39116 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
39117 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
39118 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}};
39119 static swig_cast_info _swigc__p_wxBusyCursor[] = { {&_swigt__p_wxBusyCursor, 0, 0, 0},{0, 0, 0, 0}};
39120 static swig_cast_info _swigc__p_wxBusyInfo[] = { {&_swigt__p_wxBusyInfo, 0, 0, 0},{0, 0, 0, 0}};
39121 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
39122 static swig_cast_info _swigc__p_wxChar[] = { {&_swigt__p_wxChar, 0, 0, 0},{0, 0, 0, 0}};
39123 static swig_cast_info _swigc__p_wxClipboard[] = { {&_swigt__p_wxClipboard, 0, 0, 0},{0, 0, 0, 0}};
39124 static swig_cast_info _swigc__p_wxClipboardLocker[] = { {&_swigt__p_wxClipboardLocker, 0, 0, 0},{0, 0, 0, 0}};
39125 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
39126 static swig_cast_info _swigc__p_wxConfig[] = { {&_swigt__p_wxConfig, 0, 0, 0},{0, 0, 0, 0}};
39127 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}};
39128 static swig_cast_info _swigc__p_wxConfigPathChanger[] = { {&_swigt__p_wxConfigPathChanger, 0, 0, 0},{0, 0, 0, 0}};
39129 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
39130 static swig_cast_info _swigc__p_wxCustomDataObject[] = { {&_swigt__p_wxCustomDataObject, 0, 0, 0},{0, 0, 0, 0}};
39131 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
39132 static swig_cast_info _swigc__p_wxDataFormat[] = { {&_swigt__p_wxDataFormat, 0, 0, 0},{0, 0, 0, 0}};
39133 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}};
39134 static swig_cast_info _swigc__p_wxDataObjectComposite[] = { {&_swigt__p_wxDataObjectComposite, 0, 0, 0},{0, 0, 0, 0}};
39135 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}};
39136 static swig_cast_info _swigc__p_wxDateSpan[] = { {&_swigt__p_wxDateSpan, 0, 0, 0},{0, 0, 0, 0}};
39137 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
39138 static swig_cast_info _swigc__p_wxDateTime__TimeZone[] = { {&_swigt__p_wxDateTime__TimeZone, 0, 0, 0},{0, 0, 0, 0}};
39139 static swig_cast_info _swigc__p_wxDisplay[] = { {&_swigt__p_wxDisplay, 0, 0, 0},{0, 0, 0, 0}};
39140 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
39141 static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
39142 static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
39143 static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
39144 static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
39145 static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
39146 static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
39147 static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
39148 static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
39149 static swig_cast_info _swigc__p_wxNotifyEvent[] = {{&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
39150 static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
39151 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = {{&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
39152 static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
39153 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
39154 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
39155 static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
39156 static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
39157 static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
39158 static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
39159 static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
39160 static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
39161 static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
39162 static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
39163 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = {{&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
39164 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
39165 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
39166 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
39167 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
39168 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
39169 static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
39170 static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
39171 static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
39172 static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
39173 static swig_cast_info _swigc__p_wxCommandEvent[] = {{&_swigt__p_wxCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
39174 static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
39175 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
39176 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
39177 static swig_cast_info _swigc__p_wxKeyEvent[] = {{&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
39178 static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
39179 static swig_cast_info _swigc__p_wxEvent[] = { {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxTimerEvent, _p_wxTimerEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPowerEvent, _p_wxPowerEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_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_wxClipboardTextEvent, _p_wxClipboardTextEventTo_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}};
39180 static swig_cast_info _swigc__p_wxControl[] = {{&_swigt__p_wxControl, 0, 0, 0},{0, 0, 0, 0}};
39181 static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
39182 static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
39183 static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
39184 static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};
39185 static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
39186 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}};
39187 static swig_cast_info _swigc__p_wxFileConfig[] = { {&_swigt__p_wxFileConfig, 0, 0, 0},{0, 0, 0, 0}};
39188 static swig_cast_info _swigc__p_wxFileDataObject[] = { {&_swigt__p_wxFileDataObject, 0, 0, 0},{0, 0, 0, 0}};
39189 static swig_cast_info _swigc__p_wxFileHistory[] = { {&_swigt__p_wxFileHistory, 0, 0, 0},{0, 0, 0, 0}};
39190 static swig_cast_info _swigc__p_wxFileType[] = { {&_swigt__p_wxFileType, 0, 0, 0},{0, 0, 0, 0}};
39191 static swig_cast_info _swigc__p_wxFileTypeInfo[] = { {&_swigt__p_wxFileTypeInfo, 0, 0, 0},{0, 0, 0, 0}};
39192 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
39193 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
39194 static swig_cast_info _swigc__p_wxIcon[] = { {&_swigt__p_wxIcon, 0, 0, 0},{0, 0, 0, 0}};
39195 static swig_cast_info _swigc__p_wxJoystick[] = { {&_swigt__p_wxJoystick, 0, 0, 0},{0, 0, 0, 0}};
39196 static swig_cast_info _swigc__p_wxJoystickEvent[] = { {&_swigt__p_wxJoystickEvent, 0, 0, 0},{0, 0, 0, 0}};
39197 static swig_cast_info _swigc__p_wxKillError[] = { {&_swigt__p_wxKillError, 0, 0, 0},{0, 0, 0, 0}};
39198 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}};
39199 static swig_cast_info _swigc__p_wxLogBuffer[] = { {&_swigt__p_wxLogBuffer, 0, 0, 0},{0, 0, 0, 0}};
39200 static swig_cast_info _swigc__p_wxLogChain[] = { {&_swigt__p_wxLogChain, 0, 0, 0},{0, 0, 0, 0}};
39201 static swig_cast_info _swigc__p_wxLogGui[] = { {&_swigt__p_wxLogGui, 0, 0, 0},{0, 0, 0, 0}};
39202 static swig_cast_info _swigc__p_wxLogNull[] = { {&_swigt__p_wxLogNull, 0, 0, 0},{0, 0, 0, 0}};
39203 static swig_cast_info _swigc__p_wxLogStderr[] = { {&_swigt__p_wxLogStderr, 0, 0, 0},{0, 0, 0, 0}};
39204 static swig_cast_info _swigc__p_wxLogTextCtrl[] = { {&_swigt__p_wxLogTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
39205 static swig_cast_info _swigc__p_wxLogWindow[] = { {&_swigt__p_wxLogWindow, 0, 0, 0},{0, 0, 0, 0}};
39206 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
39207 static swig_cast_info _swigc__p_wxMetafile[] = { {&_swigt__p_wxMetafile, 0, 0, 0},{0, 0, 0, 0}};
39208 static swig_cast_info _swigc__p_wxMetafileDataObject[] = { {&_swigt__p_wxMetafileDataObject, 0, 0, 0},{0, 0, 0, 0}};
39209 static swig_cast_info _swigc__p_wxMimeTypesManager[] = { {&_swigt__p_wxMimeTypesManager, 0, 0, 0},{0, 0, 0, 0}};
39210 static swig_cast_info _swigc__p_wxMouseState[] = { {&_swigt__p_wxMouseState, 0, 0, 0},{0, 0, 0, 0}};
39211 static swig_cast_info _swigc__p_wxMutexGuiLocker[] = { {&_swigt__p_wxMutexGuiLocker, 0, 0, 0},{0, 0, 0, 0}};
39212 static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
39213 static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
39214 static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
39215 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
39216 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
39217 static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
39218 static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
39219 static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
39220 static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
39221 static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
39222 static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
39223 static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
39224 static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
39225 static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
39226 static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
39227 static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
39228 static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
39229 static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
39230 static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
39231 static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
39232 static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
39233 static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
39234 static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
39235 static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
39236 static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
39237 static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
39238 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
39239 static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
39240 static swig_cast_info _swigc__p_wxImage[] = {{&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
39241 static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
39242 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_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_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxTimerEvent, _p_wxTimerEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPowerEvent, _p_wxPowerEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboard, _p_wxClipboardTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxToolTip, _p_wxToolTipTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_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_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_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSystemOptions, _p_wxSystemOptionsTo_p_wxObject, 0, 0}, {&_swigt__p_wxJoystickEvent, _p_wxJoystickEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyProcess, _p_wxPyProcessTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxBusyInfo, _p_wxBusyInfoTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxProcessEvent, _p_wxProcessEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_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}};
39243 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
39244 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
39245 static swig_cast_info _swigc__p_wxPlatformInfo[] = { {&_swigt__p_wxPlatformInfo, 0, 0, 0},{0, 0, 0, 0}};
39246 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
39247 static swig_cast_info _swigc__p_wxPowerEvent[] = { {&_swigt__p_wxPowerEvent, 0, 0, 0},{0, 0, 0, 0}};
39248 static swig_cast_info _swigc__p_wxProcessEvent[] = { {&_swigt__p_wxProcessEvent, 0, 0, 0},{0, 0, 0, 0}};
39249 static swig_cast_info _swigc__p_wxPyArtProvider[] = { {&_swigt__p_wxPyArtProvider, 0, 0, 0},{0, 0, 0, 0}};
39250 static swig_cast_info _swigc__p_wxPyBitmapDataObject[] = { {&_swigt__p_wxPyBitmapDataObject, 0, 0, 0},{0, 0, 0, 0}};
39251 static swig_cast_info _swigc__p_wxPyDataObjectSimple[] = { {&_swigt__p_wxPyDataObjectSimple, 0, 0, 0},{0, 0, 0, 0}};
39252 static swig_cast_info _swigc__p_wxPyDropSource[] = { {&_swigt__p_wxPyDropSource, 0, 0, 0},{0, 0, 0, 0}};
39253 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}};
39254 static swig_cast_info _swigc__p_wxPyFileDropTarget[] = { {&_swigt__p_wxPyFileDropTarget, 0, 0, 0},{0, 0, 0, 0}};
39255 static swig_cast_info _swigc__p_wxPyLog[] = { {&_swigt__p_wxPyLog, 0, 0, 0},{0, 0, 0, 0}};
39256 static swig_cast_info _swigc__p_wxPyProcess[] = { {&_swigt__p_wxPyProcess, 0, 0, 0},{0, 0, 0, 0}};
39257 static swig_cast_info _swigc__p_wxPyTextDataObject[] = { {&_swigt__p_wxPyTextDataObject, 0, 0, 0},{0, 0, 0, 0}};
39258 static swig_cast_info _swigc__p_wxPyTextDropTarget[] = { {&_swigt__p_wxPyTextDropTarget, 0, 0, 0},{0, 0, 0, 0}};
39259 static swig_cast_info _swigc__p_wxPyTimer[] = { {&_swigt__p_wxPyTimer, 0, 0, 0},{0, 0, 0, 0}};
39260 static swig_cast_info _swigc__p_wxPyTipProvider[] = { {&_swigt__p_wxPyTipProvider, 0, 0, 0},{0, 0, 0, 0}};
39261 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
39262 static swig_cast_info _swigc__p_wxSingleInstanceChecker[] = { {&_swigt__p_wxSingleInstanceChecker, 0, 0, 0},{0, 0, 0, 0}};
39263 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
39264 static swig_cast_info _swigc__p_wxSound[] = { {&_swigt__p_wxSound, 0, 0, 0},{0, 0, 0, 0}};
39265 static swig_cast_info _swigc__p_wxStandardPaths[] = { {&_swigt__p_wxStandardPaths, 0, 0, 0},{0, 0, 0, 0}};
39266 static swig_cast_info _swigc__p_wxStopWatch[] = { {&_swigt__p_wxStopWatch, 0, 0, 0},{0, 0, 0, 0}};
39267 static swig_cast_info _swigc__p_wxString[] = { {&_swigt__p_wxString, 0, 0, 0},{0, 0, 0, 0}};
39268 static swig_cast_info _swigc__p_wxSystemOptions[] = { {&_swigt__p_wxSystemOptions, 0, 0, 0},{0, 0, 0, 0}};
39269 static swig_cast_info _swigc__p_wxSystemSettings[] = { {&_swigt__p_wxSystemSettings, 0, 0, 0},{0, 0, 0, 0}};
39270 static swig_cast_info _swigc__p_wxTextCtrl[] = { {&_swigt__p_wxTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
39271 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}};
39272 static swig_cast_info _swigc__p_wxTimeSpan[] = { {&_swigt__p_wxTimeSpan, 0, 0, 0},{0, 0, 0, 0}};
39273 static swig_cast_info _swigc__p_wxTimer[] = { {&_swigt__p_wxTimer, 0, 0, 0},{0, 0, 0, 0}};
39274 static swig_cast_info _swigc__p_wxTimerEvent[] = { {&_swigt__p_wxTimerEvent, 0, 0, 0},{0, 0, 0, 0}};
39275 static swig_cast_info _swigc__p_wxTimerRunner[] = { {&_swigt__p_wxTimerRunner, 0, 0, 0},{0, 0, 0, 0}};
39276 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}};
39277 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
39278 static swig_cast_info _swigc__p_wxURLDataObject[] = { {&_swigt__p_wxURLDataObject, 0, 0, 0},{0, 0, 0, 0}};
39279 static swig_cast_info _swigc__p_wxVideoMode[] = { {&_swigt__p_wxVideoMode, 0, 0, 0},{0, 0, 0, 0}};
39280 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}};
39281 static swig_cast_info _swigc__p_wxWindowDisabler[] = { {&_swigt__p_wxWindowDisabler, 0, 0, 0},{0, 0, 0, 0}};
39282
39283 static swig_cast_info *swig_cast_initial[] = {
39284 _swigc__p_char,
39285 _swigc__p_form_ops_t,
39286 _swigc__p_int,
39287 _swigc__p_unsigned_char,
39288 _swigc__p_unsigned_int,
39289 _swigc__p_unsigned_long,
39290 _swigc__p_void,
39291 _swigc__p_wxANIHandler,
39292 _swigc__p_wxAcceleratorTable,
39293 _swigc__p_wxActivateEvent,
39294 _swigc__p_wxArrayString,
39295 _swigc__p_wxBMPHandler,
39296 _swigc__p_wxBitmap,
39297 _swigc__p_wxBitmapDataObject,
39298 _swigc__p_wxBoxSizer,
39299 _swigc__p_wxBusyCursor,
39300 _swigc__p_wxBusyInfo,
39301 _swigc__p_wxCURHandler,
39302 _swigc__p_wxCaret,
39303 _swigc__p_wxChar,
39304 _swigc__p_wxChildFocusEvent,
39305 _swigc__p_wxClipboard,
39306 _swigc__p_wxClipboardLocker,
39307 _swigc__p_wxClipboardTextEvent,
39308 _swigc__p_wxCloseEvent,
39309 _swigc__p_wxColour,
39310 _swigc__p_wxCommandEvent,
39311 _swigc__p_wxConfig,
39312 _swigc__p_wxConfigBase,
39313 _swigc__p_wxConfigPathChanger,
39314 _swigc__p_wxContextMenuEvent,
39315 _swigc__p_wxControl,
39316 _swigc__p_wxControlWithItems,
39317 _swigc__p_wxCursor,
39318 _swigc__p_wxCustomDataObject,
39319 _swigc__p_wxDC,
39320 _swigc__p_wxDataFormat,
39321 _swigc__p_wxDataObject,
39322 _swigc__p_wxDataObjectComposite,
39323 _swigc__p_wxDataObjectSimple,
39324 _swigc__p_wxDateEvent,
39325 _swigc__p_wxDateSpan,
39326 _swigc__p_wxDateTime,
39327 _swigc__p_wxDateTime__TimeZone,
39328 _swigc__p_wxDisplay,
39329 _swigc__p_wxDisplayChangedEvent,
39330 _swigc__p_wxDropFilesEvent,
39331 _swigc__p_wxDuplexMode,
39332 _swigc__p_wxEraseEvent,
39333 _swigc__p_wxEvent,
39334 _swigc__p_wxEvtHandler,
39335 _swigc__p_wxFSFile,
39336 _swigc__p_wxFileConfig,
39337 _swigc__p_wxFileDataObject,
39338 _swigc__p_wxFileHistory,
39339 _swigc__p_wxFileSystem,
39340 _swigc__p_wxFileType,
39341 _swigc__p_wxFileTypeInfo,
39342 _swigc__p_wxFlexGridSizer,
39343 _swigc__p_wxFocusEvent,
39344 _swigc__p_wxFont,
39345 _swigc__p_wxFrame,
39346 _swigc__p_wxGBSizerItem,
39347 _swigc__p_wxGIFHandler,
39348 _swigc__p_wxGridBagSizer,
39349 _swigc__p_wxGridSizer,
39350 _swigc__p_wxICOHandler,
39351 _swigc__p_wxIcon,
39352 _swigc__p_wxIconizeEvent,
39353 _swigc__p_wxIdleEvent,
39354 _swigc__p_wxImage,
39355 _swigc__p_wxImageHandler,
39356 _swigc__p_wxIndividualLayoutConstraint,
39357 _swigc__p_wxInitDialogEvent,
39358 _swigc__p_wxJPEGHandler,
39359 _swigc__p_wxJoystick,
39360 _swigc__p_wxJoystickEvent,
39361 _swigc__p_wxKeyEvent,
39362 _swigc__p_wxKillError,
39363 _swigc__p_wxLayoutConstraints,
39364 _swigc__p_wxLog,
39365 _swigc__p_wxLogBuffer,
39366 _swigc__p_wxLogChain,
39367 _swigc__p_wxLogGui,
39368 _swigc__p_wxLogNull,
39369 _swigc__p_wxLogStderr,
39370 _swigc__p_wxLogTextCtrl,
39371 _swigc__p_wxLogWindow,
39372 _swigc__p_wxMaximizeEvent,
39373 _swigc__p_wxMenu,
39374 _swigc__p_wxMenuBar,
39375 _swigc__p_wxMenuEvent,
39376 _swigc__p_wxMenuItem,
39377 _swigc__p_wxMetafile,
39378 _swigc__p_wxMetafileDataObject,
39379 _swigc__p_wxMimeTypesManager,
39380 _swigc__p_wxMouseCaptureChangedEvent,
39381 _swigc__p_wxMouseCaptureLostEvent,
39382 _swigc__p_wxMouseEvent,
39383 _swigc__p_wxMouseState,
39384 _swigc__p_wxMoveEvent,
39385 _swigc__p_wxMutexGuiLocker,
39386 _swigc__p_wxNavigationKeyEvent,
39387 _swigc__p_wxNcPaintEvent,
39388 _swigc__p_wxNotifyEvent,
39389 _swigc__p_wxObject,
39390 _swigc__p_wxOutputStream,
39391 _swigc__p_wxPCXHandler,
39392 _swigc__p_wxPNGHandler,
39393 _swigc__p_wxPNMHandler,
39394 _swigc__p_wxPaintEvent,
39395 _swigc__p_wxPaletteChangedEvent,
39396 _swigc__p_wxPaperSize,
39397 _swigc__p_wxPlatformInfo,
39398 _swigc__p_wxPoint,
39399 _swigc__p_wxPowerEvent,
39400 _swigc__p_wxProcessEvent,
39401 _swigc__p_wxPyApp,
39402 _swigc__p_wxPyArtProvider,
39403 _swigc__p_wxPyBitmapDataObject,
39404 _swigc__p_wxPyCommandEvent,
39405 _swigc__p_wxPyDataObjectSimple,
39406 _swigc__p_wxPyDropSource,
39407 _swigc__p_wxPyDropTarget,
39408 _swigc__p_wxPyEvent,
39409 _swigc__p_wxPyFileDropTarget,
39410 _swigc__p_wxPyImageHandler,
39411 _swigc__p_wxPyLog,
39412 _swigc__p_wxPyProcess,
39413 _swigc__p_wxPySizer,
39414 _swigc__p_wxPyTextDataObject,
39415 _swigc__p_wxPyTextDropTarget,
39416 _swigc__p_wxPyTimer,
39417 _swigc__p_wxPyTipProvider,
39418 _swigc__p_wxPyValidator,
39419 _swigc__p_wxQueryNewPaletteEvent,
39420 _swigc__p_wxRect,
39421 _swigc__p_wxScrollEvent,
39422 _swigc__p_wxScrollWinEvent,
39423 _swigc__p_wxSetCursorEvent,
39424 _swigc__p_wxShowEvent,
39425 _swigc__p_wxSingleInstanceChecker,
39426 _swigc__p_wxSize,
39427 _swigc__p_wxSizeEvent,
39428 _swigc__p_wxSizer,
39429 _swigc__p_wxSizerItem,
39430 _swigc__p_wxSound,
39431 _swigc__p_wxStandardPaths,
39432 _swigc__p_wxStaticBoxSizer,
39433 _swigc__p_wxStdDialogButtonSizer,
39434 _swigc__p_wxStopWatch,
39435 _swigc__p_wxString,
39436 _swigc__p_wxSysColourChangedEvent,
39437 _swigc__p_wxSystemOptions,
39438 _swigc__p_wxSystemSettings,
39439 _swigc__p_wxTIFFHandler,
39440 _swigc__p_wxTextCtrl,
39441 _swigc__p_wxTextDataObject,
39442 _swigc__p_wxTimeSpan,
39443 _swigc__p_wxTimer,
39444 _swigc__p_wxTimerEvent,
39445 _swigc__p_wxTimerRunner,
39446 _swigc__p_wxTipProvider,
39447 _swigc__p_wxToolTip,
39448 _swigc__p_wxURLDataObject,
39449 _swigc__p_wxUpdateUIEvent,
39450 _swigc__p_wxValidator,
39451 _swigc__p_wxVideoMode,
39452 _swigc__p_wxWindow,
39453 _swigc__p_wxWindowCreateEvent,
39454 _swigc__p_wxWindowDestroyEvent,
39455 _swigc__p_wxWindowDisabler,
39456 _swigc__p_wxXPMHandler,
39457 };
39458
39459
39460 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
39461
39462 static swig_const_info swig_const_table[] = {
39463 {0, 0, 0, 0.0, 0, 0}};
39464
39465 #ifdef __cplusplus
39466 }
39467 #endif
39468 /* -----------------------------------------------------------------------------
39469 * Type initialization:
39470 * This problem is tough by the requirement that no dynamic
39471 * memory is used. Also, since swig_type_info structures store pointers to
39472 * swig_cast_info structures and swig_cast_info structures store pointers back
39473 * to swig_type_info structures, we need some lookup code at initialization.
39474 * The idea is that swig generates all the structures that are needed.
39475 * The runtime then collects these partially filled structures.
39476 * The SWIG_InitializeModule function takes these initial arrays out of
39477 * swig_module, and does all the lookup, filling in the swig_module.types
39478 * array with the correct data and linking the correct swig_cast_info
39479 * structures together.
39480 *
39481 * The generated swig_type_info structures are assigned staticly to an initial
39482 * array. We just loop though that array, and handle each type individually.
39483 * First we lookup if this type has been already loaded, and if so, use the
39484 * loaded structure instead of the generated one. Then we have to fill in the
39485 * cast linked list. The cast data is initially stored in something like a
39486 * two-dimensional array. Each row corresponds to a type (there are the same
39487 * number of rows as there are in the swig_type_initial array). Each entry in
39488 * a column is one of the swig_cast_info structures for that type.
39489 * The cast_initial array is actually an array of arrays, because each row has
39490 * a variable number of columns. So to actually build the cast linked list,
39491 * we find the array of casts associated with the type, and loop through it
39492 * adding the casts to the list. The one last trick we need to do is making
39493 * sure the type pointer in the swig_cast_info struct is correct.
39494 *
39495 * First off, we lookup the cast->type name to see if it is already loaded.
39496 * There are three cases to handle:
39497 * 1) If the cast->type has already been loaded AND the type we are adding
39498 * casting info to has not been loaded (it is in this module), THEN we
39499 * replace the cast->type pointer with the type pointer that has already
39500 * been loaded.
39501 * 2) If BOTH types (the one we are adding casting info to, and the
39502 * cast->type) are loaded, THEN the cast info has already been loaded by
39503 * the previous module so we just ignore it.
39504 * 3) Finally, if cast->type has not already been loaded, then we add that
39505 * swig_cast_info to the linked list (because the cast->type) pointer will
39506 * be correct.
39507 * ----------------------------------------------------------------------------- */
39508
39509 #ifdef __cplusplus
39510 extern "C" {
39511 #if 0
39512 } /* c-mode */
39513 #endif
39514 #endif
39515
39516 #if 0
39517 #define SWIGRUNTIME_DEBUG
39518 #endif
39519
39520 SWIGRUNTIME void
39521 SWIG_InitializeModule(void *clientdata) {
39522 size_t i;
39523 swig_module_info *module_head;
39524 static int init_run = 0;
39525
39526 clientdata = clientdata;
39527
39528 if (init_run) return;
39529 init_run = 1;
39530
39531 /* Initialize the swig_module */
39532 swig_module.type_initial = swig_type_initial;
39533 swig_module.cast_initial = swig_cast_initial;
39534
39535 /* Try and load any already created modules */
39536 module_head = SWIG_GetModule(clientdata);
39537 if (module_head) {
39538 swig_module.next = module_head->next;
39539 module_head->next = &swig_module;
39540 } else {
39541 /* This is the first module loaded */
39542 swig_module.next = &swig_module;
39543 SWIG_SetModule(clientdata, &swig_module);
39544 }
39545
39546 /* Now work on filling in swig_module.types */
39547 #ifdef SWIGRUNTIME_DEBUG
39548 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
39549 #endif
39550 for (i = 0; i < swig_module.size; ++i) {
39551 swig_type_info *type = 0;
39552 swig_type_info *ret;
39553 swig_cast_info *cast;
39554
39555 #ifdef SWIGRUNTIME_DEBUG
39556 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
39557 #endif
39558
39559 /* if there is another module already loaded */
39560 if (swig_module.next != &swig_module) {
39561 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
39562 }
39563 if (type) {
39564 /* Overwrite clientdata field */
39565 #ifdef SWIGRUNTIME_DEBUG
39566 printf("SWIG_InitializeModule: found type %s\n", type->name);
39567 #endif
39568 if (swig_module.type_initial[i]->clientdata) {
39569 type->clientdata = swig_module.type_initial[i]->clientdata;
39570 #ifdef SWIGRUNTIME_DEBUG
39571 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
39572 #endif
39573 }
39574 } else {
39575 type = swig_module.type_initial[i];
39576 }
39577
39578 /* Insert casting types */
39579 cast = swig_module.cast_initial[i];
39580 while (cast->type) {
39581 /* Don't need to add information already in the list */
39582 ret = 0;
39583 #ifdef SWIGRUNTIME_DEBUG
39584 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
39585 #endif
39586 if (swig_module.next != &swig_module) {
39587 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
39588 #ifdef SWIGRUNTIME_DEBUG
39589 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
39590 #endif
39591 }
39592 if (ret) {
39593 if (type == swig_module.type_initial[i]) {
39594 #ifdef SWIGRUNTIME_DEBUG
39595 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
39596 #endif
39597 cast->type = ret;
39598 ret = 0;
39599 } else {
39600 /* Check for casting already in the list */
39601 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
39602 #ifdef SWIGRUNTIME_DEBUG
39603 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
39604 #endif
39605 if (!ocast) ret = 0;
39606 }
39607 }
39608
39609 if (!ret) {
39610 #ifdef SWIGRUNTIME_DEBUG
39611 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
39612 #endif
39613 if (type->cast) {
39614 type->cast->prev = cast;
39615 cast->next = type->cast;
39616 }
39617 type->cast = cast;
39618 }
39619 cast++;
39620 }
39621 /* Set entry in modules->types array equal to the type */
39622 swig_module.types[i] = type;
39623 }
39624 swig_module.types[i] = 0;
39625
39626 #ifdef SWIGRUNTIME_DEBUG
39627 printf("**** SWIG_InitializeModule: Cast List ******\n");
39628 for (i = 0; i < swig_module.size; ++i) {
39629 int j = 0;
39630 swig_cast_info *cast = swig_module.cast_initial[i];
39631 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
39632 while (cast->type) {
39633 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
39634 cast++;
39635 ++j;
39636 }
39637 printf("---- Total casts: %d\n",j);
39638 }
39639 printf("**** SWIG_InitializeModule: Cast List ******\n");
39640 #endif
39641 }
39642
39643 /* This function will propagate the clientdata field of type to
39644 * any new swig_type_info structures that have been added into the list
39645 * of equivalent types. It is like calling
39646 * SWIG_TypeClientData(type, clientdata) a second time.
39647 */
39648 SWIGRUNTIME void
39649 SWIG_PropagateClientData(void) {
39650 size_t i;
39651 swig_cast_info *equiv;
39652 static int init_run = 0;
39653
39654 if (init_run) return;
39655 init_run = 1;
39656
39657 for (i = 0; i < swig_module.size; i++) {
39658 if (swig_module.types[i]->clientdata) {
39659 equiv = swig_module.types[i]->cast;
39660 while (equiv) {
39661 if (!equiv->converter) {
39662 if (equiv->type && !equiv->type->clientdata)
39663 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
39664 }
39665 equiv = equiv->next;
39666 }
39667 }
39668 }
39669 }
39670
39671 #ifdef __cplusplus
39672 #if 0
39673 {
39674 /* c-mode */
39675 #endif
39676 }
39677 #endif
39678
39679
39680
39681 #ifdef __cplusplus
39682 extern "C" {
39683 #endif
39684
39685 /* Python-specific SWIG API */
39686 #define SWIG_newvarlink() SWIG_Python_newvarlink()
39687 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
39688 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
39689
39690 /* -----------------------------------------------------------------------------
39691 * global variable support code.
39692 * ----------------------------------------------------------------------------- */
39693
39694 typedef struct swig_globalvar {
39695 char *name; /* Name of global variable */
39696 PyObject *(*get_attr)(void); /* Return the current value */
39697 int (*set_attr)(PyObject *); /* Set the value */
39698 struct swig_globalvar *next;
39699 } swig_globalvar;
39700
39701 typedef struct swig_varlinkobject {
39702 PyObject_HEAD
39703 swig_globalvar *vars;
39704 } swig_varlinkobject;
39705
39706 SWIGINTERN PyObject *
39707 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
39708 return PyString_FromString("<Swig global variables>");
39709 }
39710
39711 SWIGINTERN PyObject *
39712 swig_varlink_str(swig_varlinkobject *v) {
39713 PyObject *str = PyString_FromString("(");
39714 swig_globalvar *var;
39715 for (var = v->vars; var; var=var->next) {
39716 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
39717 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
39718 }
39719 PyString_ConcatAndDel(&str,PyString_FromString(")"));
39720 return str;
39721 }
39722
39723 SWIGINTERN int
39724 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
39725 PyObject *str = swig_varlink_str(v);
39726 fprintf(fp,"Swig global variables ");
39727 fprintf(fp,"%s\n", PyString_AsString(str));
39728 Py_DECREF(str);
39729 return 0;
39730 }
39731
39732 SWIGINTERN void
39733 swig_varlink_dealloc(swig_varlinkobject *v) {
39734 swig_globalvar *var = v->vars;
39735 while (var) {
39736 swig_globalvar *n = var->next;
39737 free(var->name);
39738 free(var);
39739 var = n;
39740 }
39741 }
39742
39743 SWIGINTERN PyObject *
39744 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
39745 PyObject *res = NULL;
39746 swig_globalvar *var = v->vars;
39747 while (var) {
39748 if (strcmp(var->name,n) == 0) {
39749 res = (*var->get_attr)();
39750 break;
39751 }
39752 var = var->next;
39753 }
39754 if (res == NULL && !PyErr_Occurred()) {
39755 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
39756 }
39757 return res;
39758 }
39759
39760 SWIGINTERN int
39761 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
39762 int res = 1;
39763 swig_globalvar *var = v->vars;
39764 while (var) {
39765 if (strcmp(var->name,n) == 0) {
39766 res = (*var->set_attr)(p);
39767 break;
39768 }
39769 var = var->next;
39770 }
39771 if (res == 1 && !PyErr_Occurred()) {
39772 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
39773 }
39774 return res;
39775 }
39776
39777 SWIGINTERN PyTypeObject*
39778 swig_varlink_type(void) {
39779 static char varlink__doc__[] = "Swig var link object";
39780 static PyTypeObject varlink_type;
39781 static int type_init = 0;
39782 if (!type_init) {
39783 const PyTypeObject tmp
39784 = {
39785 PyObject_HEAD_INIT(NULL)
39786 0, /* Number of items in variable part (ob_size) */
39787 (char *)"swigvarlink", /* Type name (tp_name) */
39788 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
39789 0, /* Itemsize (tp_itemsize) */
39790 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
39791 (printfunc) swig_varlink_print, /* Print (tp_print) */
39792 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
39793 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
39794 0, /* tp_compare */
39795 (reprfunc) swig_varlink_repr, /* tp_repr */
39796 0, /* tp_as_number */
39797 0, /* tp_as_sequence */
39798 0, /* tp_as_mapping */
39799 0, /* tp_hash */
39800 0, /* tp_call */
39801 (reprfunc)swig_varlink_str, /* tp_str */
39802 0, /* tp_getattro */
39803 0, /* tp_setattro */
39804 0, /* tp_as_buffer */
39805 0, /* tp_flags */
39806 varlink__doc__, /* tp_doc */
39807 0, /* tp_traverse */
39808 0, /* tp_clear */
39809 0, /* tp_richcompare */
39810 0, /* tp_weaklistoffset */
39811 #if PY_VERSION_HEX >= 0x02020000
39812 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
39813 #endif
39814 #if PY_VERSION_HEX >= 0x02030000
39815 0, /* tp_del */
39816 #endif
39817 #ifdef COUNT_ALLOCS
39818 0,0,0,0 /* tp_alloc -> tp_next */
39819 #endif
39820 };
39821 varlink_type = tmp;
39822 varlink_type.ob_type = &PyType_Type;
39823 type_init = 1;
39824 }
39825 return &varlink_type;
39826 }
39827
39828 /* Create a variable linking object for use later */
39829 SWIGINTERN PyObject *
39830 SWIG_Python_newvarlink(void) {
39831 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
39832 if (result) {
39833 result->vars = 0;
39834 }
39835 return ((PyObject*) result);
39836 }
39837
39838 SWIGINTERN void
39839 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
39840 swig_varlinkobject *v = (swig_varlinkobject *) p;
39841 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
39842 if (gv) {
39843 size_t size = strlen(name)+1;
39844 gv->name = (char *)malloc(size);
39845 if (gv->name) {
39846 strncpy(gv->name,name,size);
39847 gv->get_attr = get_attr;
39848 gv->set_attr = set_attr;
39849 gv->next = v->vars;
39850 }
39851 }
39852 v->vars = gv;
39853 }
39854
39855 SWIGINTERN PyObject *
39856 SWIG_globals() {
39857 static PyObject *_SWIG_globals = 0;
39858 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
39859 return _SWIG_globals;
39860 }
39861
39862 /* -----------------------------------------------------------------------------
39863 * constants/methods manipulation
39864 * ----------------------------------------------------------------------------- */
39865
39866 /* Install Constants */
39867 SWIGINTERN void
39868 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
39869 PyObject *obj = 0;
39870 size_t i;
39871 for (i = 0; constants[i].type; ++i) {
39872 switch(constants[i].type) {
39873 case SWIG_PY_POINTER:
39874 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
39875 break;
39876 case SWIG_PY_BINARY:
39877 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
39878 break;
39879 default:
39880 obj = 0;
39881 break;
39882 }
39883 if (obj) {
39884 PyDict_SetItemString(d, constants[i].name, obj);
39885 Py_DECREF(obj);
39886 }
39887 }
39888 }
39889
39890 /* -----------------------------------------------------------------------------*/
39891 /* Fix SwigMethods to carry the callback ptrs when needed */
39892 /* -----------------------------------------------------------------------------*/
39893
39894 SWIGINTERN void
39895 SWIG_Python_FixMethods(PyMethodDef *methods,
39896 swig_const_info *const_table,
39897 swig_type_info **types,
39898 swig_type_info **types_initial) {
39899 size_t i;
39900 for (i = 0; methods[i].ml_name; ++i) {
39901 const char *c = methods[i].ml_doc;
39902 if (c && (c = strstr(c, "swig_ptr: "))) {
39903 int j;
39904 swig_const_info *ci = 0;
39905 const char *name = c + 10;
39906 for (j = 0; const_table[j].type; ++j) {
39907 if (strncmp(const_table[j].name, name,
39908 strlen(const_table[j].name)) == 0) {
39909 ci = &(const_table[j]);
39910 break;
39911 }
39912 }
39913 if (ci) {
39914 size_t shift = (ci->ptype) - types;
39915 swig_type_info *ty = types_initial[shift];
39916 size_t ldoc = (c - methods[i].ml_doc);
39917 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
39918 char *ndoc = (char*)malloc(ldoc + lptr + 10);
39919 if (ndoc) {
39920 char *buff = ndoc;
39921 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
39922 if (ptr) {
39923 strncpy(buff, methods[i].ml_doc, ldoc);
39924 buff += ldoc;
39925 strncpy(buff, "swig_ptr: ", 10);
39926 buff += 10;
39927 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
39928 methods[i].ml_doc = ndoc;
39929 }
39930 }
39931 }
39932 }
39933 }
39934 }
39935
39936 #ifdef __cplusplus
39937 }
39938 #endif
39939
39940 /* -----------------------------------------------------------------------------*
39941 * Partial Init method
39942 * -----------------------------------------------------------------------------*/
39943
39944 #ifdef __cplusplus
39945 extern "C"
39946 #endif
39947 SWIGEXPORT void SWIG_init(void) {
39948 PyObject *m, *d;
39949
39950 /* Fix SwigMethods to carry the callback ptrs when needed */
39951 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
39952
39953 m = Py_InitModule((char *) SWIG_name, SwigMethods);
39954 d = PyModule_GetDict(m);
39955
39956 SWIG_InitializeModule(0);
39957 SWIG_InstallConstants(d,swig_const_table);
39958
39959
39960 SWIG_Python_SetConstant(d, "SYS_OEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_OEM_FIXED_FONT)));
39961 SWIG_Python_SetConstant(d, "SYS_ANSI_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_FIXED_FONT)));
39962 SWIG_Python_SetConstant(d, "SYS_ANSI_VAR_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_VAR_FONT)));
39963 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FONT)));
39964 SWIG_Python_SetConstant(d, "SYS_DEVICE_DEFAULT_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEVICE_DEFAULT_FONT)));
39965 SWIG_Python_SetConstant(d, "SYS_DEFAULT_PALETTE",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_PALETTE)));
39966 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FIXED_FONT)));
39967 SWIG_Python_SetConstant(d, "SYS_DEFAULT_GUI_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_GUI_FONT)));
39968 SWIG_Python_SetConstant(d, "SYS_ICONTITLE_FONT",SWIG_From_int(static_cast< int >(wxSYS_ICONTITLE_FONT)));
39969 SWIG_Python_SetConstant(d, "SYS_COLOUR_SCROLLBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_SCROLLBAR)));
39970 SWIG_Python_SetConstant(d, "SYS_COLOUR_BACKGROUND",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BACKGROUND)));
39971 SWIG_Python_SetConstant(d, "SYS_COLOUR_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_DESKTOP)));
39972 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVECAPTION)));
39973 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTION)));
39974 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENU",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENU)));
39975 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOW)));
39976 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWFRAME",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWFRAME)));
39977 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUTEXT)));
39978 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWTEXT)));
39979 SWIG_Python_SetConstant(d, "SYS_COLOUR_CAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_CAPTIONTEXT)));
39980 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVEBORDER)));
39981 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVEBORDER)));
39982 SWIG_Python_SetConstant(d, "SYS_COLOUR_APPWORKSPACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_APPWORKSPACE)));
39983 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHT)));
39984 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHTTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHTTEXT)));
39985 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNFACE)));
39986 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DFACE)));
39987 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNSHADOW)));
39988 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DSHADOW)));
39989 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRAYTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRAYTEXT)));
39990 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNTEXT)));
39991 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
39992 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHIGHLIGHT)));
39993 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHILIGHT)));
39994 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHIGHLIGHT)));
39995 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHILIGHT)));
39996 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DDKSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DDKSHADOW)));
39997 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DLIGHT)));
39998 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOTEXT)));
39999 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOBK",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOBK)));
40000 SWIG_Python_SetConstant(d, "SYS_COLOUR_LISTBOX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_LISTBOX)));
40001 SWIG_Python_SetConstant(d, "SYS_COLOUR_HOTLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HOTLIGHT)));
40002 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
40003 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTINACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
40004 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUHILIGHT)));
40005 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUBAR)));
40006 SWIG_Python_SetConstant(d, "SYS_COLOUR_MAX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MAX)));
40007 SWIG_Python_SetConstant(d, "SYS_MOUSE_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_MOUSE_BUTTONS)));
40008 SWIG_Python_SetConstant(d, "SYS_BORDER_X",SWIG_From_int(static_cast< int >(wxSYS_BORDER_X)));
40009 SWIG_Python_SetConstant(d, "SYS_BORDER_Y",SWIG_From_int(static_cast< int >(wxSYS_BORDER_Y)));
40010 SWIG_Python_SetConstant(d, "SYS_CURSOR_X",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_X)));
40011 SWIG_Python_SetConstant(d, "SYS_CURSOR_Y",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_Y)));
40012 SWIG_Python_SetConstant(d, "SYS_DCLICK_X",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_X)));
40013 SWIG_Python_SetConstant(d, "SYS_DCLICK_Y",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_Y)));
40014 SWIG_Python_SetConstant(d, "SYS_DRAG_X",SWIG_From_int(static_cast< int >(wxSYS_DRAG_X)));
40015 SWIG_Python_SetConstant(d, "SYS_DRAG_Y",SWIG_From_int(static_cast< int >(wxSYS_DRAG_Y)));
40016 SWIG_Python_SetConstant(d, "SYS_EDGE_X",SWIG_From_int(static_cast< int >(wxSYS_EDGE_X)));
40017 SWIG_Python_SetConstant(d, "SYS_EDGE_Y",SWIG_From_int(static_cast< int >(wxSYS_EDGE_Y)));
40018 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_X)));
40019 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_Y)));
40020 SWIG_Python_SetConstant(d, "SYS_HTHUMB_X",SWIG_From_int(static_cast< int >(wxSYS_HTHUMB_X)));
40021 SWIG_Python_SetConstant(d, "SYS_ICON_X",SWIG_From_int(static_cast< int >(wxSYS_ICON_X)));
40022 SWIG_Python_SetConstant(d, "SYS_ICON_Y",SWIG_From_int(static_cast< int >(wxSYS_ICON_Y)));
40023 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_X",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_X)));
40024 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_Y",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_Y)));
40025 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_X",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_X)));
40026 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_Y",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_Y)));
40027 SWIG_Python_SetConstant(d, "SYS_SCREEN_X",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_X)));
40028 SWIG_Python_SetConstant(d, "SYS_SCREEN_Y",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_Y)));
40029 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_X",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_X)));
40030 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_Y",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_Y)));
40031 SWIG_Python_SetConstant(d, "SYS_SMALLICON_X",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_X)));
40032 SWIG_Python_SetConstant(d, "SYS_SMALLICON_Y",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_Y)));
40033 SWIG_Python_SetConstant(d, "SYS_HSCROLL_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_Y)));
40034 SWIG_Python_SetConstant(d, "SYS_VSCROLL_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_X)));
40035 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_X)));
40036 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_Y)));
40037 SWIG_Python_SetConstant(d, "SYS_VTHUMB_Y",SWIG_From_int(static_cast< int >(wxSYS_VTHUMB_Y)));
40038 SWIG_Python_SetConstant(d, "SYS_CAPTION_Y",SWIG_From_int(static_cast< int >(wxSYS_CAPTION_Y)));
40039 SWIG_Python_SetConstant(d, "SYS_MENU_Y",SWIG_From_int(static_cast< int >(wxSYS_MENU_Y)));
40040 SWIG_Python_SetConstant(d, "SYS_NETWORK_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_NETWORK_PRESENT)));
40041 SWIG_Python_SetConstant(d, "SYS_PENWINDOWS_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_PENWINDOWS_PRESENT)));
40042 SWIG_Python_SetConstant(d, "SYS_SHOW_SOUNDS",SWIG_From_int(static_cast< int >(wxSYS_SHOW_SOUNDS)));
40043 SWIG_Python_SetConstant(d, "SYS_SWAP_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_SWAP_BUTTONS)));
40044 SWIG_Python_SetConstant(d, "SYS_CAN_DRAW_FRAME_DECORATIONS",SWIG_From_int(static_cast< int >(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
40045 SWIG_Python_SetConstant(d, "SYS_CAN_ICONIZE_FRAME",SWIG_From_int(static_cast< int >(wxSYS_CAN_ICONIZE_FRAME)));
40046 SWIG_Python_SetConstant(d, "SYS_TABLET_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_TABLET_PRESENT)));
40047 SWIG_Python_SetConstant(d, "SYS_SCREEN_NONE",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_NONE)));
40048 SWIG_Python_SetConstant(d, "SYS_SCREEN_TINY",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_TINY)));
40049 SWIG_Python_SetConstant(d, "SYS_SCREEN_PDA",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_PDA)));
40050 SWIG_Python_SetConstant(d, "SYS_SCREEN_SMALL",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_SMALL)));
40051 SWIG_Python_SetConstant(d, "SYS_SCREEN_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_DESKTOP)));
40052 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
40053 SWIG_addvarlink(SWIG_globals(),(char*)"WINDOW_DEFAULT_VARIANT",WINDOW_DEFAULT_VARIANT_get, WINDOW_DEFAULT_VARIANT_set);
40054 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorPromptStr",FileSelectorPromptStr_get, FileSelectorPromptStr_set);
40055 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorDefaultWildcardStr",FileSelectorDefaultWildcardStr_get, FileSelectorDefaultWildcardStr_set);
40056 SWIG_addvarlink(SWIG_globals(),(char*)"DirSelectorPromptStr",DirSelectorPromptStr_get, DirSelectorPromptStr_set);
40057 SWIG_Python_SetConstant(d, "SHUTDOWN_POWEROFF",SWIG_From_int(static_cast< int >(wxSHUTDOWN_POWEROFF)));
40058 SWIG_Python_SetConstant(d, "SHUTDOWN_REBOOT",SWIG_From_int(static_cast< int >(wxSHUTDOWN_REBOOT)));
40059 SWIG_Python_SetConstant(d, "OS_UNKNOWN",SWIG_From_int(static_cast< int >(wxOS_UNKNOWN)));
40060 SWIG_Python_SetConstant(d, "OS_MAC_OS",SWIG_From_int(static_cast< int >(wxOS_MAC_OS)));
40061 SWIG_Python_SetConstant(d, "OS_MAC_OSX_DARWIN",SWIG_From_int(static_cast< int >(wxOS_MAC_OSX_DARWIN)));
40062 SWIG_Python_SetConstant(d, "OS_MAC",SWIG_From_int(static_cast< int >(wxOS_MAC)));
40063 SWIG_Python_SetConstant(d, "OS_WINDOWS_9X",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_9X)));
40064 SWIG_Python_SetConstant(d, "OS_WINDOWS_NT",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_NT)));
40065 SWIG_Python_SetConstant(d, "OS_WINDOWS_MICRO",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_MICRO)));
40066 SWIG_Python_SetConstant(d, "OS_WINDOWS_CE",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_CE)));
40067 SWIG_Python_SetConstant(d, "OS_WINDOWS",SWIG_From_int(static_cast< int >(wxOS_WINDOWS)));
40068 SWIG_Python_SetConstant(d, "OS_UNIX_LINUX",SWIG_From_int(static_cast< int >(wxOS_UNIX_LINUX)));
40069 SWIG_Python_SetConstant(d, "OS_UNIX_FREEBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_FREEBSD)));
40070 SWIG_Python_SetConstant(d, "OS_UNIX_OPENBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_OPENBSD)));
40071 SWIG_Python_SetConstant(d, "OS_UNIX_NETBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_NETBSD)));
40072 SWIG_Python_SetConstant(d, "OS_UNIX_SOLARIS",SWIG_From_int(static_cast< int >(wxOS_UNIX_SOLARIS)));
40073 SWIG_Python_SetConstant(d, "OS_UNIX_AIX",SWIG_From_int(static_cast< int >(wxOS_UNIX_AIX)));
40074 SWIG_Python_SetConstant(d, "OS_UNIX_HPUX",SWIG_From_int(static_cast< int >(wxOS_UNIX_HPUX)));
40075 SWIG_Python_SetConstant(d, "OS_UNIX",SWIG_From_int(static_cast< int >(wxOS_UNIX)));
40076 SWIG_Python_SetConstant(d, "OS_DOS",SWIG_From_int(static_cast< int >(wxOS_DOS)));
40077 SWIG_Python_SetConstant(d, "OS_OS2",SWIG_From_int(static_cast< int >(wxOS_OS2)));
40078 SWIG_Python_SetConstant(d, "PORT_UNKNOWN",SWIG_From_int(static_cast< int >(wxPORT_UNKNOWN)));
40079 SWIG_Python_SetConstant(d, "PORT_BASE",SWIG_From_int(static_cast< int >(wxPORT_BASE)));
40080 SWIG_Python_SetConstant(d, "PORT_MSW",SWIG_From_int(static_cast< int >(wxPORT_MSW)));
40081 SWIG_Python_SetConstant(d, "PORT_MOTIF",SWIG_From_int(static_cast< int >(wxPORT_MOTIF)));
40082 SWIG_Python_SetConstant(d, "PORT_GTK",SWIG_From_int(static_cast< int >(wxPORT_GTK)));
40083 SWIG_Python_SetConstant(d, "PORT_MGL",SWIG_From_int(static_cast< int >(wxPORT_MGL)));
40084 SWIG_Python_SetConstant(d, "PORT_X11",SWIG_From_int(static_cast< int >(wxPORT_X11)));
40085 SWIG_Python_SetConstant(d, "PORT_PM",SWIG_From_int(static_cast< int >(wxPORT_PM)));
40086 SWIG_Python_SetConstant(d, "PORT_OS2",SWIG_From_int(static_cast< int >(wxPORT_OS2)));
40087 SWIG_Python_SetConstant(d, "PORT_MAC",SWIG_From_int(static_cast< int >(wxPORT_MAC)));
40088 SWIG_Python_SetConstant(d, "PORT_COCOA",SWIG_From_int(static_cast< int >(wxPORT_COCOA)));
40089 SWIG_Python_SetConstant(d, "PORT_WINCE",SWIG_From_int(static_cast< int >(wxPORT_WINCE)));
40090 SWIG_Python_SetConstant(d, "PORT_PALMOS",SWIG_From_int(static_cast< int >(wxPORT_PALMOS)));
40091 SWIG_Python_SetConstant(d, "PORT_DFB",SWIG_From_int(static_cast< int >(wxPORT_DFB)));
40092 SWIG_Python_SetConstant(d, "ARCH_INVALID",SWIG_From_int(static_cast< int >(wxARCH_INVALID)));
40093 SWIG_Python_SetConstant(d, "ARCH_32",SWIG_From_int(static_cast< int >(wxARCH_32)));
40094 SWIG_Python_SetConstant(d, "ARCH_64",SWIG_From_int(static_cast< int >(wxARCH_64)));
40095 SWIG_Python_SetConstant(d, "ARCH_MAX",SWIG_From_int(static_cast< int >(wxARCH_MAX)));
40096 SWIG_Python_SetConstant(d, "ENDIAN_INVALID",SWIG_From_int(static_cast< int >(wxENDIAN_INVALID)));
40097 SWIG_Python_SetConstant(d, "ENDIAN_BIG",SWIG_From_int(static_cast< int >(wxENDIAN_BIG)));
40098 SWIG_Python_SetConstant(d, "ENDIAN_LITTLE",SWIG_From_int(static_cast< int >(wxENDIAN_LITTLE)));
40099 SWIG_Python_SetConstant(d, "ENDIAN_PDP",SWIG_From_int(static_cast< int >(wxENDIAN_PDP)));
40100 SWIG_Python_SetConstant(d, "ENDIAN_MAX",SWIG_From_int(static_cast< int >(wxENDIAN_MAX)));
40101 SWIG_Python_SetConstant(d, "TIMER_CONTINUOUS",SWIG_From_int(static_cast< int >(wxTIMER_CONTINUOUS)));
40102 SWIG_Python_SetConstant(d, "TIMER_ONE_SHOT",SWIG_From_int(static_cast< int >(wxTIMER_ONE_SHOT)));
40103 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
40104
40105 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
40106
40107 SWIG_Python_SetConstant(d, "LOG_FatalError",SWIG_From_int(static_cast< int >(wxLOG_FatalError)));
40108 SWIG_Python_SetConstant(d, "LOG_Error",SWIG_From_int(static_cast< int >(wxLOG_Error)));
40109 SWIG_Python_SetConstant(d, "LOG_Warning",SWIG_From_int(static_cast< int >(wxLOG_Warning)));
40110 SWIG_Python_SetConstant(d, "LOG_Message",SWIG_From_int(static_cast< int >(wxLOG_Message)));
40111 SWIG_Python_SetConstant(d, "LOG_Status",SWIG_From_int(static_cast< int >(wxLOG_Status)));
40112 SWIG_Python_SetConstant(d, "LOG_Info",SWIG_From_int(static_cast< int >(wxLOG_Info)));
40113 SWIG_Python_SetConstant(d, "LOG_Debug",SWIG_From_int(static_cast< int >(wxLOG_Debug)));
40114 SWIG_Python_SetConstant(d, "LOG_Trace",SWIG_From_int(static_cast< int >(wxLOG_Trace)));
40115 SWIG_Python_SetConstant(d, "LOG_Progress",SWIG_From_int(static_cast< int >(wxLOG_Progress)));
40116 SWIG_Python_SetConstant(d, "LOG_User",SWIG_From_int(static_cast< int >(wxLOG_User)));
40117 SWIG_Python_SetConstant(d, "LOG_Max",SWIG_From_int(static_cast< int >(wxLOG_Max)));
40118 SWIG_Python_SetConstant(d, "TRACE_MemAlloc",SWIG_FromCharPtr("memalloc"));
40119 SWIG_Python_SetConstant(d, "TRACE_Messages",SWIG_FromCharPtr("messages"));
40120 SWIG_Python_SetConstant(d, "TRACE_ResAlloc",SWIG_FromCharPtr("resalloc"));
40121 SWIG_Python_SetConstant(d, "TRACE_RefCount",SWIG_FromCharPtr("refcount"));
40122 SWIG_Python_SetConstant(d, "TRACE_OleCalls",SWIG_FromCharPtr("ole"));
40123 SWIG_Python_SetConstant(d, "TraceMemAlloc",SWIG_From_int(static_cast< int >(0x0001)));
40124 SWIG_Python_SetConstant(d, "TraceMessages",SWIG_From_int(static_cast< int >(0x0002)));
40125 SWIG_Python_SetConstant(d, "TraceResAlloc",SWIG_From_int(static_cast< int >(0x0004)));
40126 SWIG_Python_SetConstant(d, "TraceRefCount",SWIG_From_int(static_cast< int >(0x0008)));
40127 SWIG_Python_SetConstant(d, "TraceOleCalls",SWIG_From_int(static_cast< int >(0x0100)));
40128 SWIG_Python_SetConstant(d, "PROCESS_DEFAULT",SWIG_From_int(static_cast< int >(wxPROCESS_DEFAULT)));
40129 SWIG_Python_SetConstant(d, "PROCESS_REDIRECT",SWIG_From_int(static_cast< int >(wxPROCESS_REDIRECT)));
40130 SWIG_Python_SetConstant(d, "KILL_OK",SWIG_From_int(static_cast< int >(wxKILL_OK)));
40131 SWIG_Python_SetConstant(d, "KILL_BAD_SIGNAL",SWIG_From_int(static_cast< int >(wxKILL_BAD_SIGNAL)));
40132 SWIG_Python_SetConstant(d, "KILL_ACCESS_DENIED",SWIG_From_int(static_cast< int >(wxKILL_ACCESS_DENIED)));
40133 SWIG_Python_SetConstant(d, "KILL_NO_PROCESS",SWIG_From_int(static_cast< int >(wxKILL_NO_PROCESS)));
40134 SWIG_Python_SetConstant(d, "KILL_ERROR",SWIG_From_int(static_cast< int >(wxKILL_ERROR)));
40135 SWIG_Python_SetConstant(d, "KILL_NOCHILDREN",SWIG_From_int(static_cast< int >(wxKILL_NOCHILDREN)));
40136 SWIG_Python_SetConstant(d, "KILL_CHILDREN",SWIG_From_int(static_cast< int >(wxKILL_CHILDREN)));
40137 SWIG_Python_SetConstant(d, "SIGNONE",SWIG_From_int(static_cast< int >(wxSIGNONE)));
40138 SWIG_Python_SetConstant(d, "SIGHUP",SWIG_From_int(static_cast< int >(wxSIGHUP)));
40139 SWIG_Python_SetConstant(d, "SIGINT",SWIG_From_int(static_cast< int >(wxSIGINT)));
40140 SWIG_Python_SetConstant(d, "SIGQUIT",SWIG_From_int(static_cast< int >(wxSIGQUIT)));
40141 SWIG_Python_SetConstant(d, "SIGILL",SWIG_From_int(static_cast< int >(wxSIGILL)));
40142 SWIG_Python_SetConstant(d, "SIGTRAP",SWIG_From_int(static_cast< int >(wxSIGTRAP)));
40143 SWIG_Python_SetConstant(d, "SIGABRT",SWIG_From_int(static_cast< int >(wxSIGABRT)));
40144 SWIG_Python_SetConstant(d, "SIGIOT",SWIG_From_int(static_cast< int >(wxSIGIOT)));
40145 SWIG_Python_SetConstant(d, "SIGEMT",SWIG_From_int(static_cast< int >(wxSIGEMT)));
40146 SWIG_Python_SetConstant(d, "SIGFPE",SWIG_From_int(static_cast< int >(wxSIGFPE)));
40147 SWIG_Python_SetConstant(d, "SIGKILL",SWIG_From_int(static_cast< int >(wxSIGKILL)));
40148 SWIG_Python_SetConstant(d, "SIGBUS",SWIG_From_int(static_cast< int >(wxSIGBUS)));
40149 SWIG_Python_SetConstant(d, "SIGSEGV",SWIG_From_int(static_cast< int >(wxSIGSEGV)));
40150 SWIG_Python_SetConstant(d, "SIGSYS",SWIG_From_int(static_cast< int >(wxSIGSYS)));
40151 SWIG_Python_SetConstant(d, "SIGPIPE",SWIG_From_int(static_cast< int >(wxSIGPIPE)));
40152 SWIG_Python_SetConstant(d, "SIGALRM",SWIG_From_int(static_cast< int >(wxSIGALRM)));
40153 SWIG_Python_SetConstant(d, "SIGTERM",SWIG_From_int(static_cast< int >(wxSIGTERM)));
40154 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
40155 SWIG_Python_SetConstant(d, "EXEC_ASYNC",SWIG_From_int(static_cast< int >(wxEXEC_ASYNC)));
40156 SWIG_Python_SetConstant(d, "EXEC_SYNC",SWIG_From_int(static_cast< int >(wxEXEC_SYNC)));
40157 SWIG_Python_SetConstant(d, "EXEC_NOHIDE",SWIG_From_int(static_cast< int >(wxEXEC_NOHIDE)));
40158 SWIG_Python_SetConstant(d, "EXEC_MAKE_GROUP_LEADER",SWIG_From_int(static_cast< int >(wxEXEC_MAKE_GROUP_LEADER)));
40159 SWIG_Python_SetConstant(d, "EXEC_NODISABLE",SWIG_From_int(static_cast< int >(wxEXEC_NODISABLE)));
40160
40161 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
40162
40163 SWIG_Python_SetConstant(d, "JOYSTICK1",SWIG_From_int(static_cast< int >(wxJOYSTICK1)));
40164 SWIG_Python_SetConstant(d, "JOYSTICK2",SWIG_From_int(static_cast< int >(wxJOYSTICK2)));
40165 SWIG_Python_SetConstant(d, "JOY_BUTTON_ANY",SWIG_From_int(static_cast< int >(wxJOY_BUTTON_ANY)));
40166 SWIG_Python_SetConstant(d, "JOY_BUTTON1",SWIG_From_int(static_cast< int >(wxJOY_BUTTON1)));
40167 SWIG_Python_SetConstant(d, "JOY_BUTTON2",SWIG_From_int(static_cast< int >(wxJOY_BUTTON2)));
40168 SWIG_Python_SetConstant(d, "JOY_BUTTON3",SWIG_From_int(static_cast< int >(wxJOY_BUTTON3)));
40169 SWIG_Python_SetConstant(d, "JOY_BUTTON4",SWIG_From_int(static_cast< int >(wxJOY_BUTTON4)));
40170 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
40171 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
40172 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
40173 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
40174 SWIG_Python_SetConstant(d, "SOUND_SYNC",SWIG_From_int(static_cast< int >(wxSOUND_SYNC)));
40175 SWIG_Python_SetConstant(d, "SOUND_ASYNC",SWIG_From_int(static_cast< int >(wxSOUND_ASYNC)));
40176 SWIG_Python_SetConstant(d, "SOUND_LOOP",SWIG_From_int(static_cast< int >(wxSOUND_LOOP)));
40177 SWIG_Python_SetConstant(d, "MAILCAP_STANDARD",SWIG_From_int(static_cast< int >(wxMAILCAP_STANDARD)));
40178 SWIG_Python_SetConstant(d, "MAILCAP_NETSCAPE",SWIG_From_int(static_cast< int >(wxMAILCAP_NETSCAPE)));
40179 SWIG_Python_SetConstant(d, "MAILCAP_KDE",SWIG_From_int(static_cast< int >(wxMAILCAP_KDE)));
40180 SWIG_Python_SetConstant(d, "MAILCAP_GNOME",SWIG_From_int(static_cast< int >(wxMAILCAP_GNOME)));
40181 SWIG_Python_SetConstant(d, "MAILCAP_ALL",SWIG_From_int(static_cast< int >(wxMAILCAP_ALL)));
40182 SWIG_addvarlink(SWIG_globals(),(char*)"TheMimeTypesManager",TheMimeTypesManager_get, TheMimeTypesManager_set);
40183 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TOOLBAR",ART_TOOLBAR_get, ART_TOOLBAR_set);
40184 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MENU",ART_MENU_get, ART_MENU_set);
40185 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FRAME_ICON",ART_FRAME_ICON_get, ART_FRAME_ICON_set);
40186 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CMN_DIALOG",ART_CMN_DIALOG_get, ART_CMN_DIALOG_set);
40187 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BROWSER",ART_HELP_BROWSER_get, ART_HELP_BROWSER_set);
40188 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MESSAGE_BOX",ART_MESSAGE_BOX_get, ART_MESSAGE_BOX_set);
40189 SWIG_addvarlink(SWIG_globals(),(char*)"ART_BUTTON",ART_BUTTON_get, ART_BUTTON_set);
40190 SWIG_addvarlink(SWIG_globals(),(char*)"ART_OTHER",ART_OTHER_get, ART_OTHER_set);
40191 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ADD_BOOKMARK",ART_ADD_BOOKMARK_get, ART_ADD_BOOKMARK_set);
40192 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DEL_BOOKMARK",ART_DEL_BOOKMARK_get, ART_DEL_BOOKMARK_set);
40193 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SIDE_PANEL",ART_HELP_SIDE_PANEL_get, ART_HELP_SIDE_PANEL_set);
40194 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SETTINGS",ART_HELP_SETTINGS_get, ART_HELP_SETTINGS_set);
40195 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BOOK",ART_HELP_BOOK_get, ART_HELP_BOOK_set);
40196 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_FOLDER",ART_HELP_FOLDER_get, ART_HELP_FOLDER_set);
40197 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_PAGE",ART_HELP_PAGE_get, ART_HELP_PAGE_set);
40198 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_BACK",ART_GO_BACK_get, ART_GO_BACK_set);
40199 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_FORWARD",ART_GO_FORWARD_get, ART_GO_FORWARD_set);
40200 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_UP",ART_GO_UP_get, ART_GO_UP_set);
40201 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DOWN",ART_GO_DOWN_get, ART_GO_DOWN_set);
40202 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_TO_PARENT",ART_GO_TO_PARENT_get, ART_GO_TO_PARENT_set);
40203 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_HOME",ART_GO_HOME_get, ART_GO_HOME_set);
40204 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_OPEN",ART_FILE_OPEN_get, ART_FILE_OPEN_set);
40205 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE",ART_FILE_SAVE_get, ART_FILE_SAVE_set);
40206 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE_AS",ART_FILE_SAVE_AS_get, ART_FILE_SAVE_AS_set);
40207 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PRINT",ART_PRINT_get, ART_PRINT_set);
40208 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP",ART_HELP_get, ART_HELP_set);
40209 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TIP",ART_TIP_get, ART_TIP_set);
40210 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REPORT_VIEW",ART_REPORT_VIEW_get, ART_REPORT_VIEW_set);
40211 SWIG_addvarlink(SWIG_globals(),(char*)"ART_LIST_VIEW",ART_LIST_VIEW_get, ART_LIST_VIEW_set);
40212 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW_DIR",ART_NEW_DIR_get, ART_NEW_DIR_set);
40213 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HARDDISK",ART_HARDDISK_get, ART_HARDDISK_set);
40214 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FLOPPY",ART_FLOPPY_get, ART_FLOPPY_set);
40215 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CDROM",ART_CDROM_get, ART_CDROM_set);
40216 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REMOVABLE",ART_REMOVABLE_get, ART_REMOVABLE_set);
40217 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER",ART_FOLDER_get, ART_FOLDER_set);
40218 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER_OPEN",ART_FOLDER_OPEN_get, ART_FOLDER_OPEN_set);
40219 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DIR_UP",ART_GO_DIR_UP_get, ART_GO_DIR_UP_set);
40220 SWIG_addvarlink(SWIG_globals(),(char*)"ART_EXECUTABLE_FILE",ART_EXECUTABLE_FILE_get, ART_EXECUTABLE_FILE_set);
40221 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NORMAL_FILE",ART_NORMAL_FILE_get, ART_NORMAL_FILE_set);
40222 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TICK_MARK",ART_TICK_MARK_get, ART_TICK_MARK_set);
40223 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CROSS_MARK",ART_CROSS_MARK_get, ART_CROSS_MARK_set);
40224 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ERROR",ART_ERROR_get, ART_ERROR_set);
40225 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUESTION",ART_QUESTION_get, ART_QUESTION_set);
40226 SWIG_addvarlink(SWIG_globals(),(char*)"ART_WARNING",ART_WARNING_get, ART_WARNING_set);
40227 SWIG_addvarlink(SWIG_globals(),(char*)"ART_INFORMATION",ART_INFORMATION_get, ART_INFORMATION_set);
40228 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MISSING_IMAGE",ART_MISSING_IMAGE_get, ART_MISSING_IMAGE_set);
40229 SWIG_addvarlink(SWIG_globals(),(char*)"ART_COPY",ART_COPY_get, ART_COPY_set);
40230 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CUT",ART_CUT_get, ART_CUT_set);
40231 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PASTE",ART_PASTE_get, ART_PASTE_set);
40232 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DELETE",ART_DELETE_get, ART_DELETE_set);
40233 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW",ART_NEW_get, ART_NEW_set);
40234 SWIG_addvarlink(SWIG_globals(),(char*)"ART_UNDO",ART_UNDO_get, ART_UNDO_set);
40235 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REDO",ART_REDO_get, ART_REDO_set);
40236 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUIT",ART_QUIT_get, ART_QUIT_set);
40237 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND",ART_FIND_get, ART_FIND_set);
40238 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND_AND_REPLACE",ART_FIND_AND_REPLACE_get, ART_FIND_AND_REPLACE_set);
40239
40240 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
40241
40242 SWIG_Python_SetConstant(d, "CONFIG_USE_LOCAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_LOCAL_FILE)));
40243 SWIG_Python_SetConstant(d, "CONFIG_USE_GLOBAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_GLOBAL_FILE)));
40244 SWIG_Python_SetConstant(d, "CONFIG_USE_RELATIVE_PATH",SWIG_From_int(static_cast< int >(wxCONFIG_USE_RELATIVE_PATH)));
40245 SWIG_Python_SetConstant(d, "CONFIG_USE_NO_ESCAPE_CHARACTERS",SWIG_From_int(static_cast< int >(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
40246 SWIG_Python_SetConstant(d, "ConfigBase_Type_Unknown",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Unknown)));
40247 SWIG_Python_SetConstant(d, "ConfigBase_Type_String",SWIG_From_int(static_cast< int >(wxConfigBase::Type_String)));
40248 SWIG_Python_SetConstant(d, "ConfigBase_Type_Boolean",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Boolean)));
40249 SWIG_Python_SetConstant(d, "ConfigBase_Type_Integer",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Integer)));
40250 SWIG_Python_SetConstant(d, "ConfigBase_Type_Float",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Float)));
40251 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTimeFormat",DefaultDateTimeFormat_get, DefaultDateTimeFormat_set);
40252 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultTimeSpanFormat",DefaultTimeSpanFormat_get, DefaultTimeSpanFormat_set);
40253 SWIG_Python_SetConstant(d, "DateTime_Local",SWIG_From_int(static_cast< int >(wxDateTime::Local)));
40254 SWIG_Python_SetConstant(d, "DateTime_GMT_12",SWIG_From_int(static_cast< int >(wxDateTime::GMT_12)));
40255 SWIG_Python_SetConstant(d, "DateTime_GMT_11",SWIG_From_int(static_cast< int >(wxDateTime::GMT_11)));
40256 SWIG_Python_SetConstant(d, "DateTime_GMT_10",SWIG_From_int(static_cast< int >(wxDateTime::GMT_10)));
40257 SWIG_Python_SetConstant(d, "DateTime_GMT_9",SWIG_From_int(static_cast< int >(wxDateTime::GMT_9)));
40258 SWIG_Python_SetConstant(d, "DateTime_GMT_8",SWIG_From_int(static_cast< int >(wxDateTime::GMT_8)));
40259 SWIG_Python_SetConstant(d, "DateTime_GMT_7",SWIG_From_int(static_cast< int >(wxDateTime::GMT_7)));
40260 SWIG_Python_SetConstant(d, "DateTime_GMT_6",SWIG_From_int(static_cast< int >(wxDateTime::GMT_6)));
40261 SWIG_Python_SetConstant(d, "DateTime_GMT_5",SWIG_From_int(static_cast< int >(wxDateTime::GMT_5)));
40262 SWIG_Python_SetConstant(d, "DateTime_GMT_4",SWIG_From_int(static_cast< int >(wxDateTime::GMT_4)));
40263 SWIG_Python_SetConstant(d, "DateTime_GMT_3",SWIG_From_int(static_cast< int >(wxDateTime::GMT_3)));
40264 SWIG_Python_SetConstant(d, "DateTime_GMT_2",SWIG_From_int(static_cast< int >(wxDateTime::GMT_2)));
40265 SWIG_Python_SetConstant(d, "DateTime_GMT_1",SWIG_From_int(static_cast< int >(wxDateTime::GMT_1)));
40266 SWIG_Python_SetConstant(d, "DateTime_GMT0",SWIG_From_int(static_cast< int >(wxDateTime::GMT0)));
40267 SWIG_Python_SetConstant(d, "DateTime_GMT1",SWIG_From_int(static_cast< int >(wxDateTime::GMT1)));
40268 SWIG_Python_SetConstant(d, "DateTime_GMT2",SWIG_From_int(static_cast< int >(wxDateTime::GMT2)));
40269 SWIG_Python_SetConstant(d, "DateTime_GMT3",SWIG_From_int(static_cast< int >(wxDateTime::GMT3)));
40270 SWIG_Python_SetConstant(d, "DateTime_GMT4",SWIG_From_int(static_cast< int >(wxDateTime::GMT4)));
40271 SWIG_Python_SetConstant(d, "DateTime_GMT5",SWIG_From_int(static_cast< int >(wxDateTime::GMT5)));
40272 SWIG_Python_SetConstant(d, "DateTime_GMT6",SWIG_From_int(static_cast< int >(wxDateTime::GMT6)));
40273 SWIG_Python_SetConstant(d, "DateTime_GMT7",SWIG_From_int(static_cast< int >(wxDateTime::GMT7)));
40274 SWIG_Python_SetConstant(d, "DateTime_GMT8",SWIG_From_int(static_cast< int >(wxDateTime::GMT8)));
40275 SWIG_Python_SetConstant(d, "DateTime_GMT9",SWIG_From_int(static_cast< int >(wxDateTime::GMT9)));
40276 SWIG_Python_SetConstant(d, "DateTime_GMT10",SWIG_From_int(static_cast< int >(wxDateTime::GMT10)));
40277 SWIG_Python_SetConstant(d, "DateTime_GMT11",SWIG_From_int(static_cast< int >(wxDateTime::GMT11)));
40278 SWIG_Python_SetConstant(d, "DateTime_GMT12",SWIG_From_int(static_cast< int >(wxDateTime::GMT12)));
40279 SWIG_Python_SetConstant(d, "DateTime_WET",SWIG_From_int(static_cast< int >(wxDateTime::WET)));
40280 SWIG_Python_SetConstant(d, "DateTime_WEST",SWIG_From_int(static_cast< int >(wxDateTime::WEST)));
40281 SWIG_Python_SetConstant(d, "DateTime_CET",SWIG_From_int(static_cast< int >(wxDateTime::CET)));
40282 SWIG_Python_SetConstant(d, "DateTime_CEST",SWIG_From_int(static_cast< int >(wxDateTime::CEST)));
40283 SWIG_Python_SetConstant(d, "DateTime_EET",SWIG_From_int(static_cast< int >(wxDateTime::EET)));
40284 SWIG_Python_SetConstant(d, "DateTime_EEST",SWIG_From_int(static_cast< int >(wxDateTime::EEST)));
40285 SWIG_Python_SetConstant(d, "DateTime_MSK",SWIG_From_int(static_cast< int >(wxDateTime::MSK)));
40286 SWIG_Python_SetConstant(d, "DateTime_MSD",SWIG_From_int(static_cast< int >(wxDateTime::MSD)));
40287 SWIG_Python_SetConstant(d, "DateTime_AST",SWIG_From_int(static_cast< int >(wxDateTime::AST)));
40288 SWIG_Python_SetConstant(d, "DateTime_ADT",SWIG_From_int(static_cast< int >(wxDateTime::ADT)));
40289 SWIG_Python_SetConstant(d, "DateTime_EST",SWIG_From_int(static_cast< int >(wxDateTime::EST)));
40290 SWIG_Python_SetConstant(d, "DateTime_EDT",SWIG_From_int(static_cast< int >(wxDateTime::EDT)));
40291 SWIG_Python_SetConstant(d, "DateTime_CST",SWIG_From_int(static_cast< int >(wxDateTime::CST)));
40292 SWIG_Python_SetConstant(d, "DateTime_CDT",SWIG_From_int(static_cast< int >(wxDateTime::CDT)));
40293 SWIG_Python_SetConstant(d, "DateTime_MST",SWIG_From_int(static_cast< int >(wxDateTime::MST)));
40294 SWIG_Python_SetConstant(d, "DateTime_MDT",SWIG_From_int(static_cast< int >(wxDateTime::MDT)));
40295 SWIG_Python_SetConstant(d, "DateTime_PST",SWIG_From_int(static_cast< int >(wxDateTime::PST)));
40296 SWIG_Python_SetConstant(d, "DateTime_PDT",SWIG_From_int(static_cast< int >(wxDateTime::PDT)));
40297 SWIG_Python_SetConstant(d, "DateTime_HST",SWIG_From_int(static_cast< int >(wxDateTime::HST)));
40298 SWIG_Python_SetConstant(d, "DateTime_AKST",SWIG_From_int(static_cast< int >(wxDateTime::AKST)));
40299 SWIG_Python_SetConstant(d, "DateTime_AKDT",SWIG_From_int(static_cast< int >(wxDateTime::AKDT)));
40300 SWIG_Python_SetConstant(d, "DateTime_A_WST",SWIG_From_int(static_cast< int >(wxDateTime::A_WST)));
40301 SWIG_Python_SetConstant(d, "DateTime_A_CST",SWIG_From_int(static_cast< int >(wxDateTime::A_CST)));
40302 SWIG_Python_SetConstant(d, "DateTime_A_EST",SWIG_From_int(static_cast< int >(wxDateTime::A_EST)));
40303 SWIG_Python_SetConstant(d, "DateTime_A_ESST",SWIG_From_int(static_cast< int >(wxDateTime::A_ESST)));
40304 SWIG_Python_SetConstant(d, "DateTime_UTC",SWIG_From_int(static_cast< int >(wxDateTime::UTC)));
40305 SWIG_Python_SetConstant(d, "DateTime_Gregorian",SWIG_From_int(static_cast< int >(wxDateTime::Gregorian)));
40306 SWIG_Python_SetConstant(d, "DateTime_Julian",SWIG_From_int(static_cast< int >(wxDateTime::Julian)));
40307 SWIG_Python_SetConstant(d, "DateTime_Gr_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Unknown)));
40308 SWIG_Python_SetConstant(d, "DateTime_Gr_Standard",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Standard)));
40309 SWIG_Python_SetConstant(d, "DateTime_Gr_Alaska",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Alaska)));
40310 SWIG_Python_SetConstant(d, "DateTime_Gr_Albania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Albania)));
40311 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria)));
40312 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Brixen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Brixen)));
40313 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Salzburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Salzburg)));
40314 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Tyrol",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Tyrol)));
40315 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Carinthia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Carinthia)));
40316 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Styria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Styria)));
40317 SWIG_Python_SetConstant(d, "DateTime_Gr_Belgium",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Belgium)));
40318 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria)));
40319 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_1)));
40320 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_2)));
40321 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_3)));
40322 SWIG_Python_SetConstant(d, "DateTime_Gr_Canada",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Canada)));
40323 SWIG_Python_SetConstant(d, "DateTime_Gr_China",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China)));
40324 SWIG_Python_SetConstant(d, "DateTime_Gr_China_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_1)));
40325 SWIG_Python_SetConstant(d, "DateTime_Gr_China_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_2)));
40326 SWIG_Python_SetConstant(d, "DateTime_Gr_Czechoslovakia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Czechoslovakia)));
40327 SWIG_Python_SetConstant(d, "DateTime_Gr_Denmark",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Denmark)));
40328 SWIG_Python_SetConstant(d, "DateTime_Gr_Egypt",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Egypt)));
40329 SWIG_Python_SetConstant(d, "DateTime_Gr_Estonia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Estonia)));
40330 SWIG_Python_SetConstant(d, "DateTime_Gr_Finland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Finland)));
40331 SWIG_Python_SetConstant(d, "DateTime_Gr_France",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France)));
40332 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Alsace",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Alsace)));
40333 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Lorraine",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Lorraine)));
40334 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Strasbourg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Strasbourg)));
40335 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany)));
40336 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Catholic)));
40337 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Prussia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Prussia)));
40338 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Protestant)));
40339 SWIG_Python_SetConstant(d, "DateTime_Gr_GreatBritain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_GreatBritain)));
40340 SWIG_Python_SetConstant(d, "DateTime_Gr_Greece",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Greece)));
40341 SWIG_Python_SetConstant(d, "DateTime_Gr_Hungary",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Hungary)));
40342 SWIG_Python_SetConstant(d, "DateTime_Gr_Ireland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Ireland)));
40343 SWIG_Python_SetConstant(d, "DateTime_Gr_Italy",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Italy)));
40344 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan)));
40345 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_1)));
40346 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_2)));
40347 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_3)));
40348 SWIG_Python_SetConstant(d, "DateTime_Gr_Latvia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Latvia)));
40349 SWIG_Python_SetConstant(d, "DateTime_Gr_Lithuania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Lithuania)));
40350 SWIG_Python_SetConstant(d, "DateTime_Gr_Luxemburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Luxemburg)));
40351 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands)));
40352 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Groningen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Groningen)));
40353 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Gelderland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Gelderland)));
40354 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Utrecht",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Utrecht)));
40355 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Friesland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Friesland)));
40356 SWIG_Python_SetConstant(d, "DateTime_Gr_Norway",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Norway)));
40357 SWIG_Python_SetConstant(d, "DateTime_Gr_Poland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Poland)));
40358 SWIG_Python_SetConstant(d, "DateTime_Gr_Portugal",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Portugal)));
40359 SWIG_Python_SetConstant(d, "DateTime_Gr_Romania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Romania)));
40360 SWIG_Python_SetConstant(d, "DateTime_Gr_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Russia)));
40361 SWIG_Python_SetConstant(d, "DateTime_Gr_Scotland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Scotland)));
40362 SWIG_Python_SetConstant(d, "DateTime_Gr_Spain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Spain)));
40363 SWIG_Python_SetConstant(d, "DateTime_Gr_Sweden",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Sweden)));
40364 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland)));
40365 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Catholic)));
40366 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Protestant)));
40367 SWIG_Python_SetConstant(d, "DateTime_Gr_Turkey",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Turkey)));
40368 SWIG_Python_SetConstant(d, "DateTime_Gr_USA",SWIG_From_int(static_cast< int >(wxDateTime::Gr_USA)));
40369 SWIG_Python_SetConstant(d, "DateTime_Gr_Wales",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Wales)));
40370 SWIG_Python_SetConstant(d, "DateTime_Gr_Yugoslavia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Yugoslavia)));
40371 SWIG_Python_SetConstant(d, "DateTime_Country_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Country_Unknown)));
40372 SWIG_Python_SetConstant(d, "DateTime_Country_Default",SWIG_From_int(static_cast< int >(wxDateTime::Country_Default)));
40373 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_Start",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_Start)));
40374 SWIG_Python_SetConstant(d, "DateTime_Country_EEC",SWIG_From_int(static_cast< int >(wxDateTime::Country_EEC)));
40375 SWIG_Python_SetConstant(d, "DateTime_France",SWIG_From_int(static_cast< int >(wxDateTime::France)));
40376 SWIG_Python_SetConstant(d, "DateTime_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Germany)));
40377 SWIG_Python_SetConstant(d, "DateTime_UK",SWIG_From_int(static_cast< int >(wxDateTime::UK)));
40378 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_End",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_End)));
40379 SWIG_Python_SetConstant(d, "DateTime_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Russia)));
40380 SWIG_Python_SetConstant(d, "DateTime_USA",SWIG_From_int(static_cast< int >(wxDateTime::USA)));
40381 SWIG_Python_SetConstant(d, "DateTime_Jan",SWIG_From_int(static_cast< int >(wxDateTime::Jan)));
40382 SWIG_Python_SetConstant(d, "DateTime_Feb",SWIG_From_int(static_cast< int >(wxDateTime::Feb)));
40383 SWIG_Python_SetConstant(d, "DateTime_Mar",SWIG_From_int(static_cast< int >(wxDateTime::Mar)));
40384 SWIG_Python_SetConstant(d, "DateTime_Apr",SWIG_From_int(static_cast< int >(wxDateTime::Apr)));
40385 SWIG_Python_SetConstant(d, "DateTime_May",SWIG_From_int(static_cast< int >(wxDateTime::May)));
40386 SWIG_Python_SetConstant(d, "DateTime_Jun",SWIG_From_int(static_cast< int >(wxDateTime::Jun)));
40387 SWIG_Python_SetConstant(d, "DateTime_Jul",SWIG_From_int(static_cast< int >(wxDateTime::Jul)));
40388 SWIG_Python_SetConstant(d, "DateTime_Aug",SWIG_From_int(static_cast< int >(wxDateTime::Aug)));
40389 SWIG_Python_SetConstant(d, "DateTime_Sep",SWIG_From_int(static_cast< int >(wxDateTime::Sep)));
40390 SWIG_Python_SetConstant(d, "DateTime_Oct",SWIG_From_int(static_cast< int >(wxDateTime::Oct)));
40391 SWIG_Python_SetConstant(d, "DateTime_Nov",SWIG_From_int(static_cast< int >(wxDateTime::Nov)));
40392 SWIG_Python_SetConstant(d, "DateTime_Dec",SWIG_From_int(static_cast< int >(wxDateTime::Dec)));
40393 SWIG_Python_SetConstant(d, "DateTime_Inv_Month",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Month)));
40394 SWIG_Python_SetConstant(d, "DateTime_Sun",SWIG_From_int(static_cast< int >(wxDateTime::Sun)));
40395 SWIG_Python_SetConstant(d, "DateTime_Mon",SWIG_From_int(static_cast< int >(wxDateTime::Mon)));
40396 SWIG_Python_SetConstant(d, "DateTime_Tue",SWIG_From_int(static_cast< int >(wxDateTime::Tue)));
40397 SWIG_Python_SetConstant(d, "DateTime_Wed",SWIG_From_int(static_cast< int >(wxDateTime::Wed)));
40398 SWIG_Python_SetConstant(d, "DateTime_Thu",SWIG_From_int(static_cast< int >(wxDateTime::Thu)));
40399 SWIG_Python_SetConstant(d, "DateTime_Fri",SWIG_From_int(static_cast< int >(wxDateTime::Fri)));
40400 SWIG_Python_SetConstant(d, "DateTime_Sat",SWIG_From_int(static_cast< int >(wxDateTime::Sat)));
40401 SWIG_Python_SetConstant(d, "DateTime_Inv_WeekDay",SWIG_From_int(static_cast< int >(wxDateTime::Inv_WeekDay)));
40402 SWIG_Python_SetConstant(d, "DateTime_Inv_Year",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Year)));
40403 SWIG_Python_SetConstant(d, "DateTime_Name_Full",SWIG_From_int(static_cast< int >(wxDateTime::Name_Full)));
40404 SWIG_Python_SetConstant(d, "DateTime_Name_Abbr",SWIG_From_int(static_cast< int >(wxDateTime::Name_Abbr)));
40405 SWIG_Python_SetConstant(d, "DateTime_Default_First",SWIG_From_int(static_cast< int >(wxDateTime::Default_First)));
40406 SWIG_Python_SetConstant(d, "DateTime_Monday_First",SWIG_From_int(static_cast< int >(wxDateTime::Monday_First)));
40407 SWIG_Python_SetConstant(d, "DateTime_Sunday_First",SWIG_From_int(static_cast< int >(wxDateTime::Sunday_First)));
40408 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTime",DefaultDateTime_get, DefaultDateTime_set);
40409 SWIG_Python_SetConstant(d, "DF_INVALID",SWIG_From_int(static_cast< int >(wxDF_INVALID)));
40410 SWIG_Python_SetConstant(d, "DF_TEXT",SWIG_From_int(static_cast< int >(wxDF_TEXT)));
40411 SWIG_Python_SetConstant(d, "DF_BITMAP",SWIG_From_int(static_cast< int >(wxDF_BITMAP)));
40412 SWIG_Python_SetConstant(d, "DF_METAFILE",SWIG_From_int(static_cast< int >(wxDF_METAFILE)));
40413 SWIG_Python_SetConstant(d, "DF_SYLK",SWIG_From_int(static_cast< int >(wxDF_SYLK)));
40414 SWIG_Python_SetConstant(d, "DF_DIF",SWIG_From_int(static_cast< int >(wxDF_DIF)));
40415 SWIG_Python_SetConstant(d, "DF_TIFF",SWIG_From_int(static_cast< int >(wxDF_TIFF)));
40416 SWIG_Python_SetConstant(d, "DF_OEMTEXT",SWIG_From_int(static_cast< int >(wxDF_OEMTEXT)));
40417 SWIG_Python_SetConstant(d, "DF_DIB",SWIG_From_int(static_cast< int >(wxDF_DIB)));
40418 SWIG_Python_SetConstant(d, "DF_PALETTE",SWIG_From_int(static_cast< int >(wxDF_PALETTE)));
40419 SWIG_Python_SetConstant(d, "DF_PENDATA",SWIG_From_int(static_cast< int >(wxDF_PENDATA)));
40420 SWIG_Python_SetConstant(d, "DF_RIFF",SWIG_From_int(static_cast< int >(wxDF_RIFF)));
40421 SWIG_Python_SetConstant(d, "DF_WAVE",SWIG_From_int(static_cast< int >(wxDF_WAVE)));
40422 SWIG_Python_SetConstant(d, "DF_UNICODETEXT",SWIG_From_int(static_cast< int >(wxDF_UNICODETEXT)));
40423 SWIG_Python_SetConstant(d, "DF_ENHMETAFILE",SWIG_From_int(static_cast< int >(wxDF_ENHMETAFILE)));
40424 SWIG_Python_SetConstant(d, "DF_FILENAME",SWIG_From_int(static_cast< int >(wxDF_FILENAME)));
40425 SWIG_Python_SetConstant(d, "DF_LOCALE",SWIG_From_int(static_cast< int >(wxDF_LOCALE)));
40426 SWIG_Python_SetConstant(d, "DF_PRIVATE",SWIG_From_int(static_cast< int >(wxDF_PRIVATE)));
40427 SWIG_Python_SetConstant(d, "DF_HTML",SWIG_From_int(static_cast< int >(wxDF_HTML)));
40428 SWIG_Python_SetConstant(d, "DF_MAX",SWIG_From_int(static_cast< int >(wxDF_MAX)));
40429 SWIG_addvarlink(SWIG_globals(),(char*)"FormatInvalid",FormatInvalid_get, FormatInvalid_set);
40430 SWIG_Python_SetConstant(d, "DataObject_Get",SWIG_From_int(static_cast< int >(wxDataObject::Get)));
40431 SWIG_Python_SetConstant(d, "DataObject_Set",SWIG_From_int(static_cast< int >(wxDataObject::Set)));
40432 SWIG_Python_SetConstant(d, "DataObject_Both",SWIG_From_int(static_cast< int >(wxDataObject::Both)));
40433 SWIG_Python_SetConstant(d, "Drag_CopyOnly",SWIG_From_int(static_cast< int >(wxDrag_CopyOnly)));
40434 SWIG_Python_SetConstant(d, "Drag_AllowMove",SWIG_From_int(static_cast< int >(wxDrag_AllowMove)));
40435 SWIG_Python_SetConstant(d, "Drag_DefaultMove",SWIG_From_int(static_cast< int >(wxDrag_DefaultMove)));
40436 SWIG_Python_SetConstant(d, "DragError",SWIG_From_int(static_cast< int >(wxDragError)));
40437 SWIG_Python_SetConstant(d, "DragNone",SWIG_From_int(static_cast< int >(wxDragNone)));
40438 SWIG_Python_SetConstant(d, "DragCopy",SWIG_From_int(static_cast< int >(wxDragCopy)));
40439 SWIG_Python_SetConstant(d, "DragMove",SWIG_From_int(static_cast< int >(wxDragMove)));
40440 SWIG_Python_SetConstant(d, "DragLink",SWIG_From_int(static_cast< int >(wxDragLink)));
40441 SWIG_Python_SetConstant(d, "DragCancel",SWIG_From_int(static_cast< int >(wxDragCancel)));
40442
40443 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
40444 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
40445 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
40446 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
40447
40448 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultVideoMode",DefaultVideoMode_get, DefaultVideoMode_set);
40449 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_None",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_None)));
40450 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Messages",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Messages)));
40451 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Max",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Max)));
40452 SWIG_Python_SetConstant(d, "POWER_SOCKET",SWIG_From_int(static_cast< int >(wxPOWER_SOCKET)));
40453 SWIG_Python_SetConstant(d, "POWER_BATTERY",SWIG_From_int(static_cast< int >(wxPOWER_BATTERY)));
40454 SWIG_Python_SetConstant(d, "POWER_UNKNOWN",SWIG_From_int(static_cast< int >(wxPOWER_UNKNOWN)));
40455 SWIG_Python_SetConstant(d, "BATTERY_NORMAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_NORMAL_STATE)));
40456 SWIG_Python_SetConstant(d, "BATTERY_LOW_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_LOW_STATE)));
40457 SWIG_Python_SetConstant(d, "BATTERY_CRITICAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_CRITICAL_STATE)));
40458 SWIG_Python_SetConstant(d, "BATTERY_SHUTDOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_SHUTDOWN_STATE)));
40459 SWIG_Python_SetConstant(d, "BATTERY_UNKNOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_UNKNOWN_STATE)));
40460 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDING", PyInt_FromLong(wxEVT_POWER_SUSPENDING));
40461 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDED", PyInt_FromLong(wxEVT_POWER_SUSPENDED));
40462 PyDict_SetItemString(d, "wxEVT_POWER_SUSPEND_CANCEL", PyInt_FromLong(wxEVT_POWER_SUSPEND_CANCEL));
40463 PyDict_SetItemString(d, "wxEVT_POWER_RESUME", PyInt_FromLong(wxEVT_POWER_RESUME));
40464 }
40465
wxWidgets (Impactor)