]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/mac/_misc_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Add wxRect2D
[wxWidgets.git] / wxPython / src / mac / _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_wxAboutDialogInfo swig_types[8]
2475 #define SWIGTYPE_p_wxAcceleratorTable swig_types[9]
2476 #define SWIGTYPE_p_wxActivateEvent swig_types[10]
2477 #define SWIGTYPE_p_wxArrayString swig_types[11]
2478 #define SWIGTYPE_p_wxBMPHandler swig_types[12]
2479 #define SWIGTYPE_p_wxBitmap swig_types[13]
2480 #define SWIGTYPE_p_wxBitmapDataObject swig_types[14]
2481 #define SWIGTYPE_p_wxBoxSizer swig_types[15]
2482 #define SWIGTYPE_p_wxBusyCursor swig_types[16]
2483 #define SWIGTYPE_p_wxBusyInfo swig_types[17]
2484 #define SWIGTYPE_p_wxCURHandler swig_types[18]
2485 #define SWIGTYPE_p_wxCaret swig_types[19]
2486 #define SWIGTYPE_p_wxChar swig_types[20]
2487 #define SWIGTYPE_p_wxChildFocusEvent swig_types[21]
2488 #define SWIGTYPE_p_wxClipboard swig_types[22]
2489 #define SWIGTYPE_p_wxClipboardLocker swig_types[23]
2490 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[24]
2491 #define SWIGTYPE_p_wxCloseEvent swig_types[25]
2492 #define SWIGTYPE_p_wxColour swig_types[26]
2493 #define SWIGTYPE_p_wxCommandEvent swig_types[27]
2494 #define SWIGTYPE_p_wxConfig swig_types[28]
2495 #define SWIGTYPE_p_wxConfigBase swig_types[29]
2496 #define SWIGTYPE_p_wxConfigPathChanger swig_types[30]
2497 #define SWIGTYPE_p_wxContextMenuEvent swig_types[31]
2498 #define SWIGTYPE_p_wxControl swig_types[32]
2499 #define SWIGTYPE_p_wxControlWithItems swig_types[33]
2500 #define SWIGTYPE_p_wxCursor swig_types[34]
2501 #define SWIGTYPE_p_wxCustomDataObject swig_types[35]
2502 #define SWIGTYPE_p_wxDC swig_types[36]
2503 #define SWIGTYPE_p_wxDataFormat swig_types[37]
2504 #define SWIGTYPE_p_wxDataObject swig_types[38]
2505 #define SWIGTYPE_p_wxDataObjectComposite swig_types[39]
2506 #define SWIGTYPE_p_wxDataObjectSimple swig_types[40]
2507 #define SWIGTYPE_p_wxDateEvent swig_types[41]
2508 #define SWIGTYPE_p_wxDateSpan swig_types[42]
2509 #define SWIGTYPE_p_wxDateTime swig_types[43]
2510 #define SWIGTYPE_p_wxDateTime__TimeZone swig_types[44]
2511 #define SWIGTYPE_p_wxDisplay swig_types[45]
2512 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[46]
2513 #define SWIGTYPE_p_wxDropFilesEvent swig_types[47]
2514 #define SWIGTYPE_p_wxDuplexMode swig_types[48]
2515 #define SWIGTYPE_p_wxEraseEvent swig_types[49]
2516 #define SWIGTYPE_p_wxEvent swig_types[50]
2517 #define SWIGTYPE_p_wxEvtHandler swig_types[51]
2518 #define SWIGTYPE_p_wxFSFile swig_types[52]
2519 #define SWIGTYPE_p_wxFileConfig swig_types[53]
2520 #define SWIGTYPE_p_wxFileDataObject swig_types[54]
2521 #define SWIGTYPE_p_wxFileHistory swig_types[55]
2522 #define SWIGTYPE_p_wxFileSystem swig_types[56]
2523 #define SWIGTYPE_p_wxFileType swig_types[57]
2524 #define SWIGTYPE_p_wxFileTypeInfo swig_types[58]
2525 #define SWIGTYPE_p_wxFlexGridSizer swig_types[59]
2526 #define SWIGTYPE_p_wxFocusEvent swig_types[60]
2527 #define SWIGTYPE_p_wxFont swig_types[61]
2528 #define SWIGTYPE_p_wxFrame swig_types[62]
2529 #define SWIGTYPE_p_wxGBSizerItem swig_types[63]
2530 #define SWIGTYPE_p_wxGIFHandler swig_types[64]
2531 #define SWIGTYPE_p_wxGridBagSizer swig_types[65]
2532 #define SWIGTYPE_p_wxGridSizer swig_types[66]
2533 #define SWIGTYPE_p_wxICOHandler swig_types[67]
2534 #define SWIGTYPE_p_wxIcon swig_types[68]
2535 #define SWIGTYPE_p_wxIconizeEvent swig_types[69]
2536 #define SWIGTYPE_p_wxIdleEvent swig_types[70]
2537 #define SWIGTYPE_p_wxImage swig_types[71]
2538 #define SWIGTYPE_p_wxImageHandler swig_types[72]
2539 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[73]
2540 #define SWIGTYPE_p_wxInitDialogEvent swig_types[74]
2541 #define SWIGTYPE_p_wxJPEGHandler swig_types[75]
2542 #define SWIGTYPE_p_wxJoystick swig_types[76]
2543 #define SWIGTYPE_p_wxJoystickEvent swig_types[77]
2544 #define SWIGTYPE_p_wxKeyEvent swig_types[78]
2545 #define SWIGTYPE_p_wxKillError swig_types[79]
2546 #define SWIGTYPE_p_wxLayoutConstraints swig_types[80]
2547 #define SWIGTYPE_p_wxLog swig_types[81]
2548 #define SWIGTYPE_p_wxLogBuffer swig_types[82]
2549 #define SWIGTYPE_p_wxLogChain swig_types[83]
2550 #define SWIGTYPE_p_wxLogGui swig_types[84]
2551 #define SWIGTYPE_p_wxLogNull swig_types[85]
2552 #define SWIGTYPE_p_wxLogStderr swig_types[86]
2553 #define SWIGTYPE_p_wxLogTextCtrl swig_types[87]
2554 #define SWIGTYPE_p_wxLogWindow swig_types[88]
2555 #define SWIGTYPE_p_wxMaximizeEvent swig_types[89]
2556 #define SWIGTYPE_p_wxMenu swig_types[90]
2557 #define SWIGTYPE_p_wxMenuBar swig_types[91]
2558 #define SWIGTYPE_p_wxMenuEvent swig_types[92]
2559 #define SWIGTYPE_p_wxMenuItem swig_types[93]
2560 #define SWIGTYPE_p_wxMetafile swig_types[94]
2561 #define SWIGTYPE_p_wxMetafileDataObject swig_types[95]
2562 #define SWIGTYPE_p_wxMimeTypesManager swig_types[96]
2563 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[97]
2564 #define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[98]
2565 #define SWIGTYPE_p_wxMouseEvent swig_types[99]
2566 #define SWIGTYPE_p_wxMouseState swig_types[100]
2567 #define SWIGTYPE_p_wxMoveEvent swig_types[101]
2568 #define SWIGTYPE_p_wxMutexGuiLocker swig_types[102]
2569 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[103]
2570 #define SWIGTYPE_p_wxNcPaintEvent swig_types[104]
2571 #define SWIGTYPE_p_wxNotifyEvent swig_types[105]
2572 #define SWIGTYPE_p_wxObject swig_types[106]
2573 #define SWIGTYPE_p_wxOutputStream swig_types[107]
2574 #define SWIGTYPE_p_wxPCXHandler swig_types[108]
2575 #define SWIGTYPE_p_wxPNGHandler swig_types[109]
2576 #define SWIGTYPE_p_wxPNMHandler swig_types[110]
2577 #define SWIGTYPE_p_wxPaintEvent swig_types[111]
2578 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[112]
2579 #define SWIGTYPE_p_wxPaperSize swig_types[113]
2580 #define SWIGTYPE_p_wxPlatformInfo swig_types[114]
2581 #define SWIGTYPE_p_wxPoint swig_types[115]
2582 #define SWIGTYPE_p_wxPowerEvent swig_types[116]
2583 #define SWIGTYPE_p_wxProcessEvent swig_types[117]
2584 #define SWIGTYPE_p_wxPyApp swig_types[118]
2585 #define SWIGTYPE_p_wxPyArtProvider swig_types[119]
2586 #define SWIGTYPE_p_wxPyBitmapDataObject swig_types[120]
2587 #define SWIGTYPE_p_wxPyCommandEvent swig_types[121]
2588 #define SWIGTYPE_p_wxPyDataObjectSimple swig_types[122]
2589 #define SWIGTYPE_p_wxPyDropSource swig_types[123]
2590 #define SWIGTYPE_p_wxPyDropTarget swig_types[124]
2591 #define SWIGTYPE_p_wxPyEvent swig_types[125]
2592 #define SWIGTYPE_p_wxPyFileDropTarget swig_types[126]
2593 #define SWIGTYPE_p_wxPyImageHandler swig_types[127]
2594 #define SWIGTYPE_p_wxPyLog swig_types[128]
2595 #define SWIGTYPE_p_wxPyProcess swig_types[129]
2596 #define SWIGTYPE_p_wxPySizer swig_types[130]
2597 #define SWIGTYPE_p_wxPyTextDataObject swig_types[131]
2598 #define SWIGTYPE_p_wxPyTextDropTarget swig_types[132]
2599 #define SWIGTYPE_p_wxPyTimer swig_types[133]
2600 #define SWIGTYPE_p_wxPyTipProvider swig_types[134]
2601 #define SWIGTYPE_p_wxPyValidator swig_types[135]
2602 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[136]
2603 #define SWIGTYPE_p_wxRect swig_types[137]
2604 #define SWIGTYPE_p_wxScrollEvent swig_types[138]
2605 #define SWIGTYPE_p_wxScrollWinEvent swig_types[139]
2606 #define SWIGTYPE_p_wxSetCursorEvent swig_types[140]
2607 #define SWIGTYPE_p_wxShowEvent swig_types[141]
2608 #define SWIGTYPE_p_wxSingleInstanceChecker swig_types[142]
2609 #define SWIGTYPE_p_wxSize swig_types[143]
2610 #define SWIGTYPE_p_wxSizeEvent swig_types[144]
2611 #define SWIGTYPE_p_wxSizer swig_types[145]
2612 #define SWIGTYPE_p_wxSizerItem swig_types[146]
2613 #define SWIGTYPE_p_wxSound swig_types[147]
2614 #define SWIGTYPE_p_wxStandardPaths swig_types[148]
2615 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[149]
2616 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[150]
2617 #define SWIGTYPE_p_wxStopWatch swig_types[151]
2618 #define SWIGTYPE_p_wxString swig_types[152]
2619 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[153]
2620 #define SWIGTYPE_p_wxSystemOptions swig_types[154]
2621 #define SWIGTYPE_p_wxSystemSettings swig_types[155]
2622 #define SWIGTYPE_p_wxTIFFHandler swig_types[156]
2623 #define SWIGTYPE_p_wxTextCtrl swig_types[157]
2624 #define SWIGTYPE_p_wxTextDataObject swig_types[158]
2625 #define SWIGTYPE_p_wxTimeSpan swig_types[159]
2626 #define SWIGTYPE_p_wxTimer swig_types[160]
2627 #define SWIGTYPE_p_wxTimerEvent swig_types[161]
2628 #define SWIGTYPE_p_wxTimerRunner swig_types[162]
2629 #define SWIGTYPE_p_wxTipProvider swig_types[163]
2630 #define SWIGTYPE_p_wxToolTip swig_types[164]
2631 #define SWIGTYPE_p_wxURLDataObject swig_types[165]
2632 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[166]
2633 #define SWIGTYPE_p_wxValidator swig_types[167]
2634 #define SWIGTYPE_p_wxVideoMode swig_types[168]
2635 #define SWIGTYPE_p_wxWindow swig_types[169]
2636 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[170]
2637 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[171]
2638 #define SWIGTYPE_p_wxWindowDisabler swig_types[172]
2639 #define SWIGTYPE_p_wxXPMHandler swig_types[173]
2640 static swig_type_info *swig_types[175];
2641 static swig_module_info swig_module = {swig_types, 174, 0, 0, 0, 0};
2642 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2643 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2644
2645 /* -------- TYPES TABLE (END) -------- */
2646
2647 #if (PY_VERSION_HEX <= 0x02000000)
2648 # if !defined(SWIG_PYTHON_CLASSIC)
2649 # error "This python version requires to use swig with the '-classic' option"
2650 # endif
2651 #endif
2652 #if (PY_VERSION_HEX <= 0x02020000)
2653 # error "This python version requires to use swig with the '-nomodern' option"
2654 #endif
2655 #if (PY_VERSION_HEX <= 0x02020000)
2656 # error "This python version requires to use swig with the '-nomodernargs' option"
2657 #endif
2658 #ifndef METH_O
2659 # error "This python version requires to use swig with the '-nofastunpack' option"
2660 #endif
2661
2662 /*-----------------------------------------------
2663 @(target):= _misc_.so
2664 ------------------------------------------------*/
2665 #define SWIG_init init_misc_
2666
2667 #define SWIG_name "_misc_"
2668
2669 #define SWIGVERSION 0x010329
2670
2671
2672 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2673 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2674
2675
2676 #include <stdexcept>
2677
2678
2679 namespace swig {
2680 class PyObject_ptr {
2681 protected:
2682 PyObject *_obj;
2683
2684 public:
2685 PyObject_ptr() :_obj(0)
2686 {
2687 }
2688
2689 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2690 {
2691 Py_XINCREF(_obj);
2692 }
2693
2694 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2695 {
2696 if (initial_ref) Py_XINCREF(_obj);
2697 }
2698
2699 PyObject_ptr & operator=(const PyObject_ptr& item)
2700 {
2701 Py_XINCREF(item._obj);
2702 Py_XDECREF(_obj);
2703 _obj = item._obj;
2704 return *this;
2705 }
2706
2707 ~PyObject_ptr()
2708 {
2709 Py_XDECREF(_obj);
2710 }
2711
2712 operator PyObject *() const
2713 {
2714 return _obj;
2715 }
2716
2717 PyObject *operator->() const
2718 {
2719 return _obj;
2720 }
2721 };
2722 }
2723
2724
2725 namespace swig {
2726 struct PyObject_var : PyObject_ptr {
2727 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2728
2729 PyObject_var & operator = (PyObject* obj)
2730 {
2731 Py_XDECREF(_obj);
2732 _obj = obj;
2733 return *this;
2734 }
2735 };
2736 }
2737
2738
2739 #include "wx/wxPython/wxPython.h"
2740 #include "wx/wxPython/pyclasses.h"
2741 #include "wx/wxPython/pyistream.h"
2742
2743 static const wxString wxPyEmptyString(wxEmptyString);
2744
2745
2746
2747 #define SWIG_From_long PyInt_FromLong
2748
2749
2750 SWIGINTERNINLINE PyObject *
2751 SWIG_From_int (int value)
2752 {
2753 return SWIG_From_long (value);
2754 }
2755
2756
2757 #include <limits.h>
2758 #ifndef LLONG_MIN
2759 # define LLONG_MIN LONG_LONG_MIN
2760 #endif
2761 #ifndef LLONG_MAX
2762 # define LLONG_MAX LONG_LONG_MAX
2763 #endif
2764 #ifndef ULLONG_MAX
2765 # define ULLONG_MAX ULONG_LONG_MAX
2766 #endif
2767
2768
2769 SWIGINTERN int
2770 SWIG_AsVal_long (PyObject* obj, long* val)
2771 {
2772 if (PyNumber_Check(obj)) {
2773 if (val) *val = PyInt_AsLong(obj);
2774 return SWIG_OK;
2775 }
2776 return SWIG_TypeError;
2777 }
2778
2779
2780 SWIGINTERN int
2781 SWIG_AsVal_int (PyObject * obj, int *val)
2782 {
2783 long v;
2784 int res = SWIG_AsVal_long (obj, &v);
2785 if (SWIG_IsOK(res)) {
2786 if ((v < INT_MIN || v > INT_MAX)) {
2787 return SWIG_OverflowError;
2788 } else {
2789 if (val) *val = static_cast< int >(v);
2790 }
2791 }
2792 return res;
2793 }
2794
2795 static const wxString wxPyWINDOW_DEFAULT_VARIANT(wxWINDOW_DEFAULT_VARIANT);
2796
2797 #include <wx/stockitem.h>
2798
2799 static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
2800 static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
2801 static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
2802
2803 SWIGINTERN int
2804 SWIG_AsVal_bool (PyObject *obj, bool *val)
2805 {
2806 if (obj == Py_True) {
2807 if (val) *val = true;
2808 return SWIG_OK;
2809 } else if (obj == Py_False) {
2810 if (val) *val = false;
2811 return SWIG_OK;
2812 } else {
2813 long v = 0;
2814 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
2815 if (SWIG_IsOK(res) && val) *val = v ? true : false;
2816 return res;
2817 }
2818 }
2819
2820
2821 SWIGINTERN int
2822 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
2823 {
2824 long v = 0;
2825 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2826 return SWIG_TypeError;
2827 }
2828 else if (val)
2829 *val = (unsigned long)v;
2830 return SWIG_OK;
2831 }
2832
2833
2834 SWIGINTERNINLINE PyObject*
2835 SWIG_From_unsigned_SS_long (unsigned long value)
2836 {
2837 return (value > LONG_MAX) ?
2838 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
2839 }
2840
2841
2842 void* wxGetXDisplay()
2843 {
2844 #ifdef __WXGTK__
2845 return wxGetDisplay();
2846 #else
2847 return NULL;
2848 #endif
2849 }
2850
2851
2852 wxWindow* FindWindowAtPointer() {
2853 wxPoint unused;
2854 return wxFindWindowAtPointer(unused);
2855 }
2856
2857
2858 bool wxThread_IsMain() {
2859 #ifdef WXP_WITH_THREAD
2860 return wxThread::IsMain();
2861 #else
2862 return true;
2863 #endif
2864 }
2865
2866 SWIGINTERN void wxCaret_Destroy(wxCaret *self){
2867 delete self;
2868 }
2869
2870 #include <wx/snglinst.h>
2871
2872
2873 #ifdef __WXMSW__
2874 #include <wx/msw/private.h>
2875 #include <wx/dynload.h>
2876 #endif
2877
2878
2879
2880 bool wxDrawWindowOnDC(wxWindow* window, const wxDC& dc
2881 #if 0
2882 , int method
2883 #endif
2884 )
2885 {
2886 #ifdef __WXMSW__
2887 #if 0
2888 switch (method)
2889 {
2890 case 1:
2891 // This one only partially works. Appears to be an undocumented
2892 // "standard" convention that not all widgets adhear to. For
2893 // example, for some widgets backgrounds or non-client areas may
2894 // not be painted.
2895 ::SendMessage(GetHwndOf(window), WM_PAINT, (long)GetHdcOf(dc), 0);
2896 break;
2897
2898 case 2:
2899 #endif
2900 // This one works much better, nearly all widgets and their
2901 // children are captured correctly[**]. Prior to the big
2902 // background erase changes that Vadim did in 2004-2005 this
2903 // method failed badly on XP with Themes activated, most native
2904 // widgets draw only partially, if at all. Without themes it
2905 // worked just like on Win2k. After those changes this method
2906 // works very well.
2907 //
2908 // ** For example the radio buttons in a wxRadioBox are not its
2909 // children by default, but you can capture it via the panel
2910 // instead, or change RADIOBTN_PARENT_IS_RADIOBOX in radiobox.cpp.
2911 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2912 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2913 PRF_ERASEBKGND | PRF_OWNED );
2914 return true;
2915 #if 0
2916 break;
2917
2918 case 3:
2919 // This one is only defined in the latest SDK and is only
2920 // available on XP. MSDN says it is similar to sending WM_PRINT
2921 // so I expect that it will work similar to the above. Since it
2922 // is avaialble only on XP, it can't be compiled like this and
2923 // will have to be loaded dynamically.
2924 // //::PrintWindow(GetHwndOf(window), GetHdcOf(dc), 0); //break;
2925
2926 // fall through
2927
2928 case 4:
2929 // Use PrintWindow if available, or fallback to WM_PRINT
2930 // otherwise. Unfortunately using PrintWindow is even worse than
2931 // WM_PRINT. For most native widgets nothing is drawn to the dc
2932 // at all, with or without Themes.
2933 typedef BOOL (WINAPI *PrintWindow_t)(HWND, HDC, UINT);
2934 static bool s_triedToLoad = false;
2935 static PrintWindow_t pfnPrintWindow = NULL;
2936 if ( !s_triedToLoad )
2937 {
2938
2939 s_triedToLoad = true;
2940 wxDynamicLibrary dllUser32(_T("user32.dll"));
2941 if ( dllUser32.IsLoaded() )
2942 {
2943 wxLogNull nolog; // Don't report errors here
2944 pfnPrintWindow = (PrintWindow_t)dllUser32.GetSymbol(_T("PrintWindow"));
2945 }
2946 }
2947 if (pfnPrintWindow)
2948 {
2949 //printf("Using PrintWindow\n");
2950 pfnPrintWindow(GetHwndOf(window), GetHdcOf(dc), 0);
2951 }
2952 else
2953 {
2954 //printf("Using WM_PRINT\n");
2955 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2956 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2957 PRF_ERASEBKGND | PRF_OWNED );
2958 }
2959 }
2960 #endif // 0
2961 #else
2962 return false;
2963 #endif // __WXMSW__
2964 }
2965
2966
2967
2968 #include <wx/tipdlg.h>
2969
2970
2971 SWIGINTERNINLINE PyObject *
2972 SWIG_From_size_t (size_t value)
2973 {
2974 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
2975 }
2976
2977
2978 class wxPyTipProvider : public wxTipProvider {
2979 public:
2980 wxPyTipProvider(size_t currentTip)
2981 : wxTipProvider(currentTip) {}
2982
2983 DEC_PYCALLBACK_STRING__pure(GetTip);
2984 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
2985 PYPRIVATE;
2986 };
2987
2988 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
2989 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
2990
2991
2992 SWIGINTERNINLINE int
2993 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
2994 {
2995 unsigned long v;
2996 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
2997 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
2998 return res;
2999 }
3000
3001
3002 IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
3003
3004 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
3005
3006 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
3007 : wxTimer(owner, id)
3008 {
3009 if (owner == NULL)
3010 SetOwner(this);
3011 }
3012
3013
3014 SWIGINTERN swig_type_info*
3015 SWIG_pchar_descriptor()
3016 {
3017 static int init = 0;
3018 static swig_type_info* info = 0;
3019 if (!init) {
3020 info = SWIG_TypeQuery("_p_char");
3021 init = 1;
3022 }
3023 return info;
3024 }
3025
3026
3027 SWIGINTERNINLINE PyObject *
3028 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3029 {
3030 if (carray) {
3031 if (size > INT_MAX) {
3032 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3033 return pchar_descriptor ?
3034 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3035 } else {
3036 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3037 }
3038 } else {
3039 return SWIG_Py_Void();
3040 }
3041 }
3042
3043
3044 SWIGINTERNINLINE PyObject *
3045 SWIG_FromCharPtr(const char *cptr)
3046 {
3047 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3048 }
3049
3050
3051 SWIGINTERN int
3052 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3053 {
3054 unsigned long v;
3055 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3056 if (SWIG_IsOK(res)) {
3057 if ((v > UINT_MAX)) {
3058 return SWIG_OverflowError;
3059 } else {
3060 if (val) *val = static_cast< unsigned int >(v);
3061 }
3062 }
3063 return res;
3064 }
3065
3066 SWIGINTERN wxString wxLog_TimeStamp(){
3067 wxString msg;
3068 wxLog::TimeStamp(&msg);
3069 return msg;
3070 }
3071 SWIGINTERN void wxLog_Destroy(wxLog *self){ delete self; }
3072 // Make some wrappers that double any % signs so they are 'escaped'
3073 void wxPyLogFatalError(const wxString& msg)
3074 {
3075 wxString m(msg);
3076 m.Replace(wxT("%"), wxT("%%"));
3077 wxLogFatalError(m);
3078 }
3079
3080 void wxPyLogError(const wxString& msg)
3081 {
3082 wxString m(msg);
3083 m.Replace(wxT("%"), wxT("%%"));
3084 wxLogError(m);
3085 }
3086
3087 void wxPyLogWarning(const wxString& msg)
3088 {
3089 wxString m(msg);
3090 m.Replace(wxT("%"), wxT("%%"));
3091 wxLogWarning(m);
3092 }
3093
3094 void wxPyLogMessage(const wxString& msg)
3095 {
3096 wxString m(msg);
3097 m.Replace(wxT("%"), wxT("%%"));
3098 wxLogMessage(m);
3099 }
3100
3101 void wxPyLogInfo(const wxString& msg)
3102 {
3103 wxString m(msg);
3104 m.Replace(wxT("%"), wxT("%%"));
3105 wxLogInfo(m);
3106 }
3107
3108 void wxPyLogDebug(const wxString& msg)
3109 {
3110 wxString m(msg);
3111 m.Replace(wxT("%"), wxT("%%"));
3112 wxLogDebug(m);
3113 }
3114
3115 void wxPyLogVerbose(const wxString& msg)
3116 {
3117 wxString m(msg);
3118 m.Replace(wxT("%"), wxT("%%"));
3119 wxLogVerbose(m);
3120 }
3121
3122 void wxPyLogStatus(const wxString& msg)
3123 {
3124 wxString m(msg);
3125 m.Replace(wxT("%"), wxT("%%"));
3126 wxLogStatus(m);
3127 }
3128
3129 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
3130 {
3131 wxString m(msg);
3132 m.Replace(wxT("%"), wxT("%%"));
3133 wxLogStatus(pFrame, m);
3134 }
3135
3136 void wxPyLogSysError(const wxString& msg)
3137 {
3138 wxString m(msg);
3139 m.Replace(wxT("%"), wxT("%%"));
3140 wxLogSysError(m);
3141 }
3142
3143 void wxPyLogGeneric(unsigned long level, const wxString& msg)
3144 {
3145 wxString m(msg);
3146 m.Replace(wxT("%"), wxT("%%"));
3147 wxLogGeneric(level, m);
3148 }
3149
3150 void wxPyLogTrace(unsigned long mask, const wxString& msg)
3151 {
3152 wxString m(msg);
3153 m.Replace(wxT("%"), wxT("%%"));
3154 wxLogTrace(mask, m);
3155 }
3156
3157 void wxPyLogTrace(const wxString& mask, const wxString& msg)
3158 {
3159 wxString m(msg);
3160 m.Replace(wxT("%"), wxT("%%"));
3161 wxLogTrace(mask, m);
3162 }
3163
3164
3165
3166 // A wxLog class that can be derived from in wxPython
3167 class wxPyLog : public wxLog {
3168 public:
3169 wxPyLog() : wxLog() {}
3170
3171 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
3172 bool found;
3173 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3174 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
3175 PyObject* s = wx2PyString(szString);
3176 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
3177 Py_DECREF(s);
3178 }
3179 wxPyEndBlockThreads(blocked);
3180 if (! found)
3181 wxLog::DoLog(level, szString, t);
3182 }
3183
3184 virtual void DoLogString(const wxChar *szString, time_t t) {
3185 bool found;
3186 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3187 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
3188 PyObject* s = wx2PyString(szString);
3189 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
3190 Py_DECREF(s);
3191 }
3192 wxPyEndBlockThreads(blocked);
3193 if (! found)
3194 wxLog::DoLogString(szString, t);
3195 }
3196
3197 DEC_PYCALLBACK_VOID_(Flush);
3198 PYPRIVATE;
3199 };
3200 IMP_PYCALLBACK_VOID_(wxPyLog, wxLog, Flush);
3201
3202
3203
3204
3205 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
3206
3207
3208 #include <wx/joystick.h>
3209
3210
3211 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
3212 // A C++ stub class for wxJoystick for platforms that don't have it.
3213 class wxJoystick : public wxObject {
3214 public:
3215 wxJoystick(int joystick = wxJOYSTICK1) {
3216 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3217 PyErr_SetString(PyExc_NotImplementedError,
3218 "wxJoystick is not available on this platform.");
3219 wxPyEndBlockThreads(blocked);
3220 }
3221 wxPoint GetPosition() { return wxPoint(-1,-1); }
3222 int GetZPosition() { return -1; }
3223 int GetButtonState() { return -1; }
3224 int GetPOVPosition() { return -1; }
3225 int GetPOVCTSPosition() { return -1; }
3226 int GetRudderPosition() { return -1; }
3227 int GetUPosition() { return -1; }
3228 int GetVPosition() { return -1; }
3229 int GetMovementThreshold() { return -1; }
3230 void SetMovementThreshold(int threshold) {}
3231
3232 bool IsOk(void) { return false; }
3233 int GetNumberJoysticks() { return -1; }
3234 int GetManufacturerId() { return -1; }
3235 int GetProductId() { return -1; }
3236 wxString GetProductName() { return wxEmptyString; }
3237 int GetXMin() { return -1; }
3238 int GetYMin() { return -1; }
3239 int GetZMin() { return -1; }
3240 int GetXMax() { return -1; }
3241 int GetYMax() { return -1; }
3242 int GetZMax() { return -1; }
3243 int GetNumberButtons() { return -1; }
3244 int GetNumberAxes() { return -1; }
3245 int GetMaxButtons() { return -1; }
3246 int GetMaxAxes() { return -1; }
3247 int GetPollingMin() { return -1; }
3248 int GetPollingMax() { return -1; }
3249 int GetRudderMin() { return -1; }
3250 int GetRudderMax() { return -1; }
3251 int GetUMin() { return -1; }
3252 int GetUMax() { return -1; }
3253 int GetVMin() { return -1; }
3254 int GetVMax() { return -1; }
3255
3256 bool HasRudder() { return false; }
3257 bool HasZ() { return false; }
3258 bool HasU() { return false; }
3259 bool HasV() { return false; }
3260 bool HasPOV() { return false; }
3261 bool HasPOV4Dir() { return false; }
3262 bool HasPOVCTS() { return false; }
3263
3264 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
3265 bool ReleaseCapture() { return false; }
3266 };
3267 #endif
3268
3269
3270 #include <wx/sound.h>
3271
3272
3273 #if !wxUSE_SOUND
3274 // A C++ stub class for wxWave for platforms that don't have it.
3275 class wxSound : public wxObject
3276 {
3277 public:
3278 wxSound() {
3279 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3280 PyErr_SetString(PyExc_NotImplementedError,
3281 "wxSound is not available on this platform.");
3282 wxPyEndBlockThreads(blocked);
3283 }
3284 wxSound(const wxString&/*, bool*/) {
3285 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3286 PyErr_SetString(PyExc_NotImplementedError,
3287 "wxSound is not available on this platform.");
3288 wxPyEndBlockThreads(blocked);
3289 }
3290 wxSound(int, const wxByte*) {
3291 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3292 PyErr_SetString(PyExc_NotImplementedError,
3293 "wxSound is not available on this platform.");
3294 wxPyEndBlockThreads(blocked);
3295 }
3296
3297 ~wxSound() {};
3298
3299 bool Create(const wxString&/*, bool*/) { return false; }
3300 bool Create(int, const wxByte*) { return false; };
3301 bool IsOk() { return false; };
3302 bool Play(unsigned) const { return false; }
3303 static bool Play(const wxString&, unsigned) { return false; }
3304 static void Stop() {}
3305 };
3306
3307 #endif
3308
3309 SWIGINTERN wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
3310 if (fileName.Length() == 0)
3311 return new wxSound;
3312 else
3313 return new wxSound(fileName);
3314 }
3315 SWIGINTERN wxSound *new_wxSound(PyObject *data){
3316 unsigned char* buffer; int size;
3317 wxSound *sound = NULL;
3318
3319 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3320 if (!PyArg_Parse(data, "t#", &buffer, &size))
3321 goto done;
3322 sound = new wxSound(size, buffer);
3323 done:
3324 wxPyEndBlockThreads(blocked);
3325 return sound;
3326 }
3327 SWIGINTERN bool wxSound_CreateFromData(wxSound *self,PyObject *data){
3328 #ifndef __WXMAC__
3329 unsigned char* buffer;
3330 int size;
3331 bool rv = false;
3332
3333 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3334 if (!PyArg_Parse(data, "t#", &buffer, &size))
3335 goto done;
3336 rv = self->Create(size, buffer);
3337 done:
3338 wxPyEndBlockThreads(blocked);
3339 return rv;
3340 #else
3341 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3342 PyErr_SetString(PyExc_NotImplementedError,
3343 "Create from data is not available on this platform.");
3344 wxPyEndBlockThreads(blocked);
3345 return false;
3346 #endif
3347 }
3348
3349 #include <wx/mimetype.h>
3350
3351 SWIGINTERN PyObject *wxFileType_GetMimeType(wxFileType *self){
3352 wxString str;
3353 if (self->GetMimeType(&str))
3354 return wx2PyString(str);
3355 else
3356 RETURN_NONE();
3357 }
3358 SWIGINTERN PyObject *wxFileType_GetMimeTypes(wxFileType *self){
3359 wxArrayString arr;
3360 if (self->GetMimeTypes(arr))
3361 return wxArrayString2PyList_helper(arr);
3362 else
3363 RETURN_NONE();
3364 }
3365 SWIGINTERN PyObject *wxFileType_GetExtensions(wxFileType *self){
3366 wxArrayString arr;
3367 if (self->GetExtensions(arr))
3368 return wxArrayString2PyList_helper(arr);
3369 else
3370 RETURN_NONE();
3371 }
3372 SWIGINTERN wxIcon *wxFileType_GetIcon(wxFileType *self){
3373 wxIconLocation loc;
3374 if (self->GetIcon(&loc))
3375 return new wxIcon(loc);
3376 else
3377 return NULL;
3378 }
3379 SWIGINTERN PyObject *wxFileType_GetIconInfo(wxFileType *self){
3380 wxIconLocation loc;
3381 if (self->GetIcon(&loc)) {
3382 wxString iconFile = loc.GetFileName();
3383 int iconIndex = -1;
3384
3385
3386
3387 // Make a tuple and put the values in it
3388 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3389 PyObject* tuple = PyTuple_New(3);
3390 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
3391 wxT("wxIcon"), true));
3392 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
3393 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
3394 wxPyEndBlockThreads(blocked);
3395 return tuple;
3396 }
3397 else
3398 RETURN_NONE();
3399 }
3400 SWIGINTERN PyObject *wxFileType_GetDescription(wxFileType *self){
3401 wxString str;
3402 if (self->GetDescription(&str))
3403 return wx2PyString(str);
3404 else
3405 RETURN_NONE();
3406 }
3407 SWIGINTERN PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3408 wxString str;
3409 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3410 return wx2PyString(str);
3411 else
3412 RETURN_NONE();
3413 }
3414 SWIGINTERN PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3415 wxString str;
3416 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3417 return wx2PyString(str);
3418 else
3419 RETURN_NONE();
3420 }
3421 SWIGINTERN PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3422 wxArrayString verbs;
3423 wxArrayString commands;
3424 if (self->GetAllCommands(&verbs, &commands,
3425 wxFileType::MessageParameters(filename, mimetype))) {
3426 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3427 PyObject* tuple = PyTuple_New(2);
3428 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
3429 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
3430 wxPyEndBlockThreads(blocked);
3431 return tuple;
3432 }
3433 else
3434 RETURN_NONE();
3435 }
3436 SWIGINTERN wxString wxFileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3437 return wxFileType::ExpandCommand(command,
3438 wxFileType::MessageParameters(filename, mimetype));
3439 }
3440 SWIGINTERN PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
3441 wxArrayString arr;
3442 self->EnumAllFileTypes(arr);
3443 return wxArrayString2PyList_helper(arr);
3444 }
3445
3446 #include <wx/artprov.h>
3447
3448 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
3449 static const wxString wxPyART_MENU(wxART_MENU);
3450 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
3451 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
3452 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
3453 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
3454 static const wxString wxPyART_BUTTON(wxART_BUTTON);
3455 static const wxString wxPyART_OTHER(wxART_OTHER);
3456 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
3457 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
3458 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
3459 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
3460 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
3461 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
3462 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
3463 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
3464 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
3465 static const wxString wxPyART_GO_UP(wxART_GO_UP);
3466 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
3467 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
3468 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
3469 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
3470 static const wxString wxPyART_FILE_SAVE(wxART_FILE_SAVE);
3471 static const wxString wxPyART_FILE_SAVE_AS(wxART_FILE_SAVE_AS);
3472 static const wxString wxPyART_PRINT(wxART_PRINT);
3473 static const wxString wxPyART_HELP(wxART_HELP);
3474 static const wxString wxPyART_TIP(wxART_TIP);
3475 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
3476 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
3477 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
3478 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
3479 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
3480 static const wxString wxPyART_CDROM(wxART_CDROM);
3481 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
3482 static const wxString wxPyART_FOLDER(wxART_FOLDER);
3483 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
3484 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
3485 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
3486 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
3487 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
3488 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
3489 static const wxString wxPyART_ERROR(wxART_ERROR);
3490 static const wxString wxPyART_QUESTION(wxART_QUESTION);
3491 static const wxString wxPyART_WARNING(wxART_WARNING);
3492 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
3493 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
3494 static const wxString wxPyART_COPY(wxART_COPY);
3495 static const wxString wxPyART_CUT(wxART_CUT);
3496 static const wxString wxPyART_PASTE(wxART_PASTE);
3497 static const wxString wxPyART_DELETE(wxART_DELETE);
3498 static const wxString wxPyART_NEW(wxART_NEW);
3499 static const wxString wxPyART_UNDO(wxART_UNDO);
3500 static const wxString wxPyART_REDO(wxART_REDO);
3501 static const wxString wxPyART_QUIT(wxART_QUIT);
3502 static const wxString wxPyART_FIND(wxART_FIND);
3503 static const wxString wxPyART_FIND_AND_REPLACE(wxART_FIND_AND_REPLACE);
3504 // Python aware wxArtProvider
3505 class wxPyArtProvider : public wxArtProvider {
3506 public:
3507
3508 virtual wxBitmap CreateBitmap(const wxArtID& id,
3509 const wxArtClient& client,
3510 const wxSize& size) {
3511 wxBitmap rval = wxNullBitmap;
3512 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3513 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
3514 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
3515 PyObject* ro;
3516 wxBitmap* ptr;
3517 PyObject* s1, *s2;
3518 s1 = wx2PyString(id);
3519 s2 = wx2PyString(client);
3520 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
3521 Py_DECREF(so);
3522 Py_DECREF(s1);
3523 Py_DECREF(s2);
3524 if (ro) {
3525 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
3526 rval = *ptr;
3527 Py_DECREF(ro);
3528 }
3529 }
3530 wxPyEndBlockThreads(blocked);
3531 return rval;
3532 }
3533
3534 PYPRIVATE;
3535 };
3536
3537 SWIGINTERN void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
3538
3539
3540
3541 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
3542 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3543 PyObject* ret = PyTuple_New(3);
3544 if (ret) {
3545 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
3546 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
3547 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
3548 }
3549 wxPyEndBlockThreads(blocked);
3550 return ret;
3551 }
3552
3553 SWIGINTERN PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
3554 bool cont;
3555 long index = 0;
3556 wxString value;
3557
3558 cont = self->GetFirstGroup(value, index);
3559 return __EnumerationHelper(cont, value, index);
3560 }
3561 SWIGINTERN PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
3562 bool cont;
3563 wxString value;
3564
3565 cont = self->GetNextGroup(value, index);
3566 return __EnumerationHelper(cont, value, index);
3567 }
3568 SWIGINTERN PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
3569 bool cont;
3570 long index = 0;
3571 wxString value;
3572
3573 cont = self->GetFirstEntry(value, index);
3574 return __EnumerationHelper(cont, value, index);
3575 }
3576 SWIGINTERN PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
3577 bool cont;
3578 wxString value;
3579
3580 cont = self->GetNextEntry(value, index);
3581 return __EnumerationHelper(cont, value, index);
3582 }
3583 SWIGINTERN long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
3584 long rv;
3585 self->Read(key, &rv, defaultVal);
3586 return rv;
3587 }
3588
3589 SWIGINTERN int
3590 SWIG_AsVal_double (PyObject *obj, double* val)
3591 {
3592 if (PyNumber_Check(obj)) {
3593 if (val) *val = PyFloat_AsDouble(obj);
3594 return SWIG_OK;
3595 }
3596 return SWIG_TypeError;
3597 }
3598
3599 SWIGINTERN double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
3600 double rv;
3601 self->Read(key, &rv, defaultVal);
3602 return rv;
3603 }
3604
3605 #define SWIG_From_double PyFloat_FromDouble
3606
3607 SWIGINTERN bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
3608 bool rv;
3609 self->Read(key, &rv, defaultVal);
3610 return rv;
3611 }
3612
3613 #include <wx/datetime.h>
3614
3615 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
3616 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
3617
3618 #define LOCAL_TZ wxDateTime::Local
3619
3620 SWIGINTERN PyObject *wxDateTime_GetAmPmStrings(){
3621 wxString am;
3622 wxString pm;
3623 wxDateTime::GetAmPmStrings(&am, &pm);
3624 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3625 PyObject* tup = PyTuple_New(2);
3626 PyTuple_SET_ITEM(tup, 0, wx2PyString(am));
3627 PyTuple_SET_ITEM(tup, 1, wx2PyString(pm));
3628 wxPyEndBlockThreads(blocked);
3629 return tup;
3630 }
3631
3632 SWIGINTERNINLINE PyObject *
3633 SWIG_From_unsigned_SS_int (unsigned int value)
3634 {
3635 return SWIG_From_unsigned_SS_long (value);
3636 }
3637
3638 SWIGINTERN wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
3639 SWIGINTERN wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
3640 SWIGINTERN wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
3641 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
3642 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
3643 SWIGINTERN bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
3644 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
3645 return (*self < *other);
3646 }
3647 SWIGINTERN bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
3648 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
3649 return (*self <= *other);
3650 }
3651 SWIGINTERN bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
3652 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
3653 return (*self > *other);
3654 }
3655 SWIGINTERN bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
3656 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
3657 return (*self >= *other);
3658 }
3659 SWIGINTERN bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
3660 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
3661 return (*self == *other);
3662 }
3663 SWIGINTERN bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
3664 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
3665 return (*self != *other);
3666 }
3667 SWIGINTERN int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
3668 const wxChar* rv;
3669 const wxChar* _date = date;
3670 rv = self->ParseRfc822Date(_date);
3671 if (rv == NULL) return -1;
3672 return rv - _date;
3673 }
3674 SWIGINTERN int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
3675 const wxChar* rv;
3676 const wxChar* _date = date;
3677 rv = self->ParseFormat(_date, format, dateDef);
3678 if (rv == NULL) return -1;
3679 return rv - _date;
3680 }
3681 SWIGINTERN int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
3682 const wxChar* rv;
3683 const wxChar* _datetime = datetime;
3684 rv = self->ParseDateTime(_datetime);
3685 if (rv == NULL) return -1;
3686 return rv - _datetime;
3687 }
3688 SWIGINTERN int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
3689 const wxChar* rv;
3690 const wxChar* _date = date;
3691 rv = self->ParseDate(_date);
3692 if (rv == NULL) return -1;
3693 return rv - _date;
3694 }
3695 SWIGINTERN int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
3696 const wxChar* rv;
3697 const wxChar* _time = time;
3698 rv = self->ParseTime(_time);
3699 if (rv == NULL) return -1;
3700 return rv - _time;
3701 }
3702 SWIGINTERN wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
3703 SWIGINTERN wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
3704 SWIGINTERN wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
3705 SWIGINTERN wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
3706 SWIGINTERN bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
3707 SWIGINTERN bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
3708 SWIGINTERN bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
3709 SWIGINTERN bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
3710 SWIGINTERN bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
3711 SWIGINTERN bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
3712 SWIGINTERN wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
3713 SWIGINTERN wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
3714 SWIGINTERN wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
3715 SWIGINTERN wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
3716 SWIGINTERN bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
3717 SWIGINTERN bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
3718
3719 #include <wx/dataobj.h>
3720
3721 SWIGINTERN PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
3722 size_t count = self->GetFormatCount(dir);
3723 wxDataFormat* formats = new wxDataFormat[count];
3724 self->GetAllFormats(formats, dir);
3725
3726 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3727 PyObject* list = PyList_New(count);
3728 for (size_t i=0; i<count; i++) {
3729 wxDataFormat* format = new wxDataFormat(formats[i]);
3730 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
3731 PyList_SET_ITEM(list, i, obj); // PyList_SET_ITEM steals a reference
3732 }
3733 wxPyEndBlockThreads(blocked);
3734 delete [] formats;
3735 return list;
3736 }
3737 SWIGINTERN PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
3738 PyObject* rval = NULL;
3739 size_t size = self->GetDataSize(format);
3740 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3741 if (size) {
3742 char* buf = new char[size];
3743 if (self->GetDataHere(format, buf))
3744 rval = PyString_FromStringAndSize(buf, size);
3745 delete [] buf;
3746 }
3747 if (! rval) {
3748 rval = Py_None;
3749 Py_INCREF(rval);
3750 }
3751 wxPyEndBlockThreads(blocked);
3752 return rval;
3753 }
3754 SWIGINTERN bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
3755 bool rval;
3756 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3757 if (PyString_Check(data)) {
3758 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
3759 }
3760 else {
3761 // raise a TypeError if not a string
3762 PyErr_SetString(PyExc_TypeError, "String expected.");
3763 rval = false;
3764 }
3765 wxPyEndBlockThreads(blocked);
3766 return rval;
3767 }
3768 SWIGINTERN PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
3769 PyObject* rval = NULL;
3770 size_t size = self->GetDataSize();
3771 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3772 if (size) {
3773 char* buf = new char[size];
3774 if (self->GetDataHere(buf))
3775 rval = PyString_FromStringAndSize(buf, size);
3776 delete [] buf;
3777 }
3778 if (! rval) {
3779 rval = Py_None;
3780 Py_INCREF(rval);
3781 }
3782 wxPyEndBlockThreads(blocked);
3783 return rval;
3784 }
3785 SWIGINTERN bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
3786 bool rval;
3787 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3788 if (PyString_Check(data)) {
3789 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3790 }
3791 else {
3792 // raise a TypeError if not a string
3793 PyErr_SetString(PyExc_TypeError, "String expected.");
3794 rval = false;
3795 }
3796 wxPyEndBlockThreads(blocked);
3797 return rval;
3798 }
3799 // Create a new class for wxPython to use
3800 class wxPyDataObjectSimple : public wxDataObjectSimple {
3801 public:
3802 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
3803 : wxDataObjectSimple(format) {}
3804
3805 DEC_PYCALLBACK_SIZET__const(GetDataSize);
3806 bool GetDataHere(void *buf) const;
3807 bool SetData(size_t len, const void *buf);
3808 PYPRIVATE;
3809 };
3810
3811 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
3812
3813 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
3814 // We need to get the data for this object and write it to buf. I think
3815 // the best way to do this for wxPython is to have the Python method
3816 // return either a string or None and then act appropriately with the
3817 // C++ version.
3818
3819 bool rval = false;
3820 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3821 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
3822 PyObject* ro;
3823 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3824 if (ro) {
3825 rval = (ro != Py_None && PyString_Check(ro));
3826 if (rval)
3827 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
3828 Py_DECREF(ro);
3829 }
3830 }
3831 wxPyEndBlockThreads(blocked);
3832 return rval;
3833 }
3834
3835 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) {
3836 // For this one we simply need to make a string from buf and len
3837 // and send it to the Python method.
3838 bool rval = false;
3839 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3840 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
3841 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
3842 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
3843 Py_DECREF(data);
3844 }
3845 wxPyEndBlockThreads(blocked);
3846 return rval;
3847 }
3848
3849 // Create a new class for wxPython to use
3850 class wxPyTextDataObject : public wxTextDataObject {
3851 public:
3852 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
3853 : wxTextDataObject(text) {}
3854
3855 DEC_PYCALLBACK_SIZET__const(GetTextLength);
3856 DEC_PYCALLBACK_STRING__const(GetText);
3857 DEC_PYCALLBACK__STRING(SetText);
3858 PYPRIVATE;
3859 };
3860
3861 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
3862 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
3863 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
3864
3865
3866 // Create a new class for wxPython to use
3867 class wxPyBitmapDataObject : public wxBitmapDataObject {
3868 public:
3869 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
3870 : wxBitmapDataObject(bitmap) {}
3871
3872 wxBitmap GetBitmap() const;
3873 void SetBitmap(const wxBitmap& bitmap);
3874 PYPRIVATE;
3875 };
3876
3877 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
3878 wxBitmap* rval = &wxNullBitmap;
3879 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3880 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
3881 PyObject* ro;
3882 wxBitmap* ptr;
3883 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3884 if (ro) {
3885 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
3886 rval = ptr;
3887 Py_DECREF(ro);
3888 }
3889 }
3890 wxPyEndBlockThreads(blocked);
3891 return *rval;
3892 }
3893
3894 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
3895 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3896 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
3897 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
3898 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
3899 Py_DECREF(bo);
3900 }
3901 wxPyEndBlockThreads(blocked);
3902 }
3903
3904 SWIGINTERN wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
3905 return new wxCustomDataObject(wxDataFormat(formatName));
3906 }
3907 SWIGINTERN bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
3908 bool rval;
3909 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3910 if (PyString_Check(data)) {
3911 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3912 }
3913 else {
3914 // raise a TypeError if not a string
3915 PyErr_SetString(PyExc_TypeError, "String expected.");
3916 rval = false;
3917 }
3918 wxPyEndBlockThreads(blocked);
3919 return rval;
3920 }
3921 SWIGINTERN PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
3922 PyObject* obj;
3923 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3924 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
3925 wxPyEndBlockThreads(blocked);
3926 return obj;
3927 }
3928
3929 #include <wx/metafile.h>
3930
3931
3932 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
3933
3934
3935 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
3936 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
3937 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
3938 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
3939 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
3940
3941
3942 class wxPyTextDropTarget : public wxTextDropTarget {
3943 public:
3944 wxPyTextDropTarget() {}
3945
3946 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
3947
3948 DEC_PYCALLBACK__(OnLeave);
3949 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3950 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3951 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3952 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3953
3954 PYPRIVATE;
3955 };
3956
3957 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
3958 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
3959 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
3960 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
3961 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
3962 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
3963
3964
3965
3966 class wxPyFileDropTarget : public wxFileDropTarget {
3967 public:
3968 wxPyFileDropTarget() {}
3969
3970 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
3971
3972 DEC_PYCALLBACK__(OnLeave);
3973 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3974 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3975 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3976 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3977
3978 PYPRIVATE;
3979 };
3980
3981 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
3982 const wxArrayString& filenames) {
3983 bool rval = false;
3984 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3985 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
3986 PyObject* list = wxArrayString2PyList_helper(filenames);
3987 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
3988 Py_DECREF(list);
3989 }
3990 wxPyEndBlockThreads(blocked);
3991 return rval;
3992 }
3993
3994
3995
3996 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
3997 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
3998 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
3999 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
4000 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
4001
4002
4003
4004
4005 SWIGINTERN bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
4006
4007 #include <wx/display.h>
4008
4009 SWIGINTERN bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
4010 SWIGINTERN bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
4011
4012 #if !wxUSE_DISPLAY
4013 const wxVideoMode wxDefaultVideoMode;
4014 #endif
4015
4016 SWIGINTERN PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4017 #if wxUSE_DISPLAY
4018 PyObject* pyList = NULL;
4019 wxArrayVideoModes arr = self->GetModes(mode);
4020 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4021 pyList = PyList_New(0);
4022 for (size_t i=0; i < arr.GetCount(); i++)
4023 {
4024 wxVideoMode* m = new wxVideoMode(arr.Item(i));
4025 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
4026 PyList_Append(pyList, pyObj);
4027 Py_DECREF(pyObj);
4028 }
4029 wxPyEndBlockThreads(blocked);
4030 return pyList;
4031 #else
4032 wxPyRaiseNotImplemented();
4033 return NULL;
4034 #endif
4035 }
4036 SWIGINTERN wxVideoMode wxDisplay_GetCurrentMode(wxDisplay const *self){
4037 #if wxUSE_DISPLAY
4038 return self->GetCurrentMode();
4039 #else
4040 wxPyRaiseNotImplemented();
4041 return wxDefaultVideoMode;
4042 #endif
4043 }
4044 SWIGINTERN bool wxDisplay_ChangeMode(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4045 #if wxUSE_DISPLAY
4046 return self->ChangeMode(mode);
4047 #else
4048 wxPyRaiseNotImplemented();
4049 return false;
4050 #endif
4051 }
4052 SWIGINTERN void wxDisplay_ResetMode(wxDisplay *self){
4053 #if wxUSE_DISPLAY
4054 self->ResetMode();
4055 #else
4056 wxPyRaiseNotImplemented();
4057 #endif
4058 }
4059
4060 #include <wx/stdpaths.h>
4061
4062 SWIGINTERN wxStandardPaths *wxStandardPaths_Get(){
4063 return (wxStandardPaths*) &wxStandardPaths::Get();
4064 }
4065 SWIGINTERN void wxStandardPaths_SetInstallPrefix(wxStandardPaths *self,wxString const &prefix){}
4066 SWIGINTERN wxString wxStandardPaths_GetInstallPrefix(wxStandardPaths *self){ return wxEmptyString; }
4067
4068 #ifndef wxHAS_POWER_EVENTS
4069 // Dummy class and other definitions for platforms that don't have them
4070
4071 // See wxPython_int.h for wxPowerEvent
4072
4073 enum {
4074 wxEVT_POWER_SUSPENDING,
4075 wxEVT_POWER_SUSPENDED,
4076 wxEVT_POWER_SUSPEND_CANCEL,
4077 wxEVT_POWER_RESUME,
4078 };
4079
4080 wxPowerType wxGetPowerType() { return wxPOWER_UNKNOWN; }
4081 wxBatteryState wxGetBatteryState() { return wxBATTERY_UNKNOWN_STATE; }
4082
4083 #endif
4084
4085
4086 #include <wx/aboutdlg.h>
4087
4088 #ifdef __cplusplus
4089 extern "C" {
4090 #endif
4091 SWIGINTERN PyObject *_wrap_SystemSettings_GetColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4092 PyObject *resultobj = 0;
4093 wxSystemColour arg1 ;
4094 wxColour result;
4095 int val1 ;
4096 int ecode1 = 0 ;
4097 PyObject * obj0 = 0 ;
4098 char * kwnames[] = {
4099 (char *) "index", NULL
4100 };
4101
4102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) SWIG_fail;
4103 ecode1 = SWIG_AsVal_int(obj0, &val1);
4104 if (!SWIG_IsOK(ecode1)) {
4105 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetColour" "', expected argument " "1"" of type '" "wxSystemColour""'");
4106 }
4107 arg1 = static_cast< wxSystemColour >(val1);
4108 {
4109 if (!wxPyCheckForApp()) SWIG_fail;
4110 PyThreadState* __tstate = wxPyBeginAllowThreads();
4111 result = wxSystemSettings::GetColour(arg1);
4112 wxPyEndAllowThreads(__tstate);
4113 if (PyErr_Occurred()) SWIG_fail;
4114 }
4115 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
4116 return resultobj;
4117 fail:
4118 return NULL;
4119 }
4120
4121
4122 SWIGINTERN PyObject *_wrap_SystemSettings_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4123 PyObject *resultobj = 0;
4124 wxSystemFont arg1 ;
4125 wxFont result;
4126 int val1 ;
4127 int ecode1 = 0 ;
4128 PyObject * obj0 = 0 ;
4129 char * kwnames[] = {
4130 (char *) "index", NULL
4131 };
4132
4133 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) SWIG_fail;
4134 ecode1 = SWIG_AsVal_int(obj0, &val1);
4135 if (!SWIG_IsOK(ecode1)) {
4136 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetFont" "', expected argument " "1"" of type '" "wxSystemFont""'");
4137 }
4138 arg1 = static_cast< wxSystemFont >(val1);
4139 {
4140 if (!wxPyCheckForApp()) SWIG_fail;
4141 PyThreadState* __tstate = wxPyBeginAllowThreads();
4142 result = wxSystemSettings::GetFont(arg1);
4143 wxPyEndAllowThreads(__tstate);
4144 if (PyErr_Occurred()) SWIG_fail;
4145 }
4146 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
4147 return resultobj;
4148 fail:
4149 return NULL;
4150 }
4151
4152
4153 SWIGINTERN PyObject *_wrap_SystemSettings_GetMetric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4154 PyObject *resultobj = 0;
4155 wxSystemMetric arg1 ;
4156 wxWindow *arg2 = (wxWindow *) NULL ;
4157 int result;
4158 int val1 ;
4159 int ecode1 = 0 ;
4160 void *argp2 = 0 ;
4161 int res2 = 0 ;
4162 PyObject * obj0 = 0 ;
4163 PyObject * obj1 = 0 ;
4164 char * kwnames[] = {
4165 (char *) "index",(char *) "win", NULL
4166 };
4167
4168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SystemSettings_GetMetric",kwnames,&obj0,&obj1)) SWIG_fail;
4169 ecode1 = SWIG_AsVal_int(obj0, &val1);
4170 if (!SWIG_IsOK(ecode1)) {
4171 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetMetric" "', expected argument " "1"" of type '" "wxSystemMetric""'");
4172 }
4173 arg1 = static_cast< wxSystemMetric >(val1);
4174 if (obj1) {
4175 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
4176 if (!SWIG_IsOK(res2)) {
4177 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SystemSettings_GetMetric" "', expected argument " "2"" of type '" "wxWindow *""'");
4178 }
4179 arg2 = reinterpret_cast< wxWindow * >(argp2);
4180 }
4181 {
4182 if (!wxPyCheckForApp()) SWIG_fail;
4183 PyThreadState* __tstate = wxPyBeginAllowThreads();
4184 result = (int)wxSystemSettings::GetMetric(arg1,arg2);
4185 wxPyEndAllowThreads(__tstate);
4186 if (PyErr_Occurred()) SWIG_fail;
4187 }
4188 resultobj = SWIG_From_int(static_cast< int >(result));
4189 return resultobj;
4190 fail:
4191 return NULL;
4192 }
4193
4194
4195 SWIGINTERN PyObject *_wrap_SystemSettings_HasFeature(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4196 PyObject *resultobj = 0;
4197 wxSystemFeature arg1 ;
4198 bool result;
4199 int val1 ;
4200 int ecode1 = 0 ;
4201 PyObject * obj0 = 0 ;
4202 char * kwnames[] = {
4203 (char *) "index", NULL
4204 };
4205
4206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) SWIG_fail;
4207 ecode1 = SWIG_AsVal_int(obj0, &val1);
4208 if (!SWIG_IsOK(ecode1)) {
4209 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_HasFeature" "', expected argument " "1"" of type '" "wxSystemFeature""'");
4210 }
4211 arg1 = static_cast< wxSystemFeature >(val1);
4212 {
4213 if (!wxPyCheckForApp()) SWIG_fail;
4214 PyThreadState* __tstate = wxPyBeginAllowThreads();
4215 result = (bool)wxSystemSettings::HasFeature(arg1);
4216 wxPyEndAllowThreads(__tstate);
4217 if (PyErr_Occurred()) SWIG_fail;
4218 }
4219 {
4220 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4221 }
4222 return resultobj;
4223 fail:
4224 return NULL;
4225 }
4226
4227
4228 SWIGINTERN PyObject *_wrap_SystemSettings_GetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4229 PyObject *resultobj = 0;
4230 wxSystemScreenType result;
4231
4232 if (!SWIG_Python_UnpackTuple(args,"SystemSettings_GetScreenType",0,0,0)) SWIG_fail;
4233 {
4234 if (!wxPyCheckForApp()) SWIG_fail;
4235 PyThreadState* __tstate = wxPyBeginAllowThreads();
4236 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
4237 wxPyEndAllowThreads(__tstate);
4238 if (PyErr_Occurred()) SWIG_fail;
4239 }
4240 resultobj = SWIG_From_int(static_cast< int >(result));
4241 return resultobj;
4242 fail:
4243 return NULL;
4244 }
4245
4246
4247 SWIGINTERN PyObject *_wrap_SystemSettings_SetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4248 PyObject *resultobj = 0;
4249 wxSystemScreenType arg1 ;
4250 int val1 ;
4251 int ecode1 = 0 ;
4252 PyObject * obj0 = 0 ;
4253 char * kwnames[] = {
4254 (char *) "screen", NULL
4255 };
4256
4257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) SWIG_fail;
4258 ecode1 = SWIG_AsVal_int(obj0, &val1);
4259 if (!SWIG_IsOK(ecode1)) {
4260 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_SetScreenType" "', expected argument " "1"" of type '" "wxSystemScreenType""'");
4261 }
4262 arg1 = static_cast< wxSystemScreenType >(val1);
4263 {
4264 if (!wxPyCheckForApp()) SWIG_fail;
4265 PyThreadState* __tstate = wxPyBeginAllowThreads();
4266 wxSystemSettings::SetScreenType(arg1);
4267 wxPyEndAllowThreads(__tstate);
4268 if (PyErr_Occurred()) SWIG_fail;
4269 }
4270 resultobj = SWIG_Py_Void();
4271 return resultobj;
4272 fail:
4273 return NULL;
4274 }
4275
4276
4277 SWIGINTERN PyObject *SystemSettings_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4278 PyObject *obj;
4279 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4280 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemSettings, SWIG_NewClientData(obj));
4281 return SWIG_Py_Void();
4282 }
4283
4284 SWIGINTERN int WINDOW_DEFAULT_VARIANT_set(PyObject *) {
4285 SWIG_Error(SWIG_AttributeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
4286 return 1;
4287 }
4288
4289
4290 SWIGINTERN PyObject *WINDOW_DEFAULT_VARIANT_get(void) {
4291 PyObject *pyobj = 0;
4292
4293 {
4294 #if wxUSE_UNICODE
4295 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4296 #else
4297 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4298 #endif
4299 }
4300 return pyobj;
4301 }
4302
4303
4304 SWIGINTERN PyObject *_wrap_new_SystemOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4305 PyObject *resultobj = 0;
4306 wxSystemOptions *result = 0 ;
4307
4308 if (!SWIG_Python_UnpackTuple(args,"new_SystemOptions",0,0,0)) SWIG_fail;
4309 {
4310 PyThreadState* __tstate = wxPyBeginAllowThreads();
4311 result = (wxSystemOptions *)new wxSystemOptions();
4312 wxPyEndAllowThreads(__tstate);
4313 if (PyErr_Occurred()) SWIG_fail;
4314 }
4315 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSystemOptions, SWIG_POINTER_NEW | 0 );
4316 return resultobj;
4317 fail:
4318 return NULL;
4319 }
4320
4321
4322 SWIGINTERN PyObject *_wrap_SystemOptions_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4323 PyObject *resultobj = 0;
4324 wxString *arg1 = 0 ;
4325 wxString *arg2 = 0 ;
4326 bool temp1 = false ;
4327 bool temp2 = false ;
4328 PyObject * obj0 = 0 ;
4329 PyObject * obj1 = 0 ;
4330 char * kwnames[] = {
4331 (char *) "name",(char *) "value", NULL
4332 };
4333
4334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) SWIG_fail;
4335 {
4336 arg1 = wxString_in_helper(obj0);
4337 if (arg1 == NULL) SWIG_fail;
4338 temp1 = true;
4339 }
4340 {
4341 arg2 = wxString_in_helper(obj1);
4342 if (arg2 == NULL) SWIG_fail;
4343 temp2 = true;
4344 }
4345 {
4346 PyThreadState* __tstate = wxPyBeginAllowThreads();
4347 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
4348 wxPyEndAllowThreads(__tstate);
4349 if (PyErr_Occurred()) SWIG_fail;
4350 }
4351 resultobj = SWIG_Py_Void();
4352 {
4353 if (temp1)
4354 delete arg1;
4355 }
4356 {
4357 if (temp2)
4358 delete arg2;
4359 }
4360 return resultobj;
4361 fail:
4362 {
4363 if (temp1)
4364 delete arg1;
4365 }
4366 {
4367 if (temp2)
4368 delete arg2;
4369 }
4370 return NULL;
4371 }
4372
4373
4374 SWIGINTERN PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4375 PyObject *resultobj = 0;
4376 wxString *arg1 = 0 ;
4377 int arg2 ;
4378 bool temp1 = false ;
4379 int val2 ;
4380 int ecode2 = 0 ;
4381 PyObject * obj0 = 0 ;
4382 PyObject * obj1 = 0 ;
4383 char * kwnames[] = {
4384 (char *) "name",(char *) "value", NULL
4385 };
4386
4387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
4388 {
4389 arg1 = wxString_in_helper(obj0);
4390 if (arg1 == NULL) SWIG_fail;
4391 temp1 = true;
4392 }
4393 ecode2 = SWIG_AsVal_int(obj1, &val2);
4394 if (!SWIG_IsOK(ecode2)) {
4395 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SystemOptions_SetOptionInt" "', expected argument " "2"" of type '" "int""'");
4396 }
4397 arg2 = static_cast< int >(val2);
4398 {
4399 PyThreadState* __tstate = wxPyBeginAllowThreads();
4400 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
4401 wxPyEndAllowThreads(__tstate);
4402 if (PyErr_Occurred()) SWIG_fail;
4403 }
4404 resultobj = SWIG_Py_Void();
4405 {
4406 if (temp1)
4407 delete arg1;
4408 }
4409 return resultobj;
4410 fail:
4411 {
4412 if (temp1)
4413 delete arg1;
4414 }
4415 return NULL;
4416 }
4417
4418
4419 SWIGINTERN PyObject *_wrap_SystemOptions_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4420 PyObject *resultobj = 0;
4421 wxString *arg1 = 0 ;
4422 wxString result;
4423 bool temp1 = false ;
4424 PyObject * obj0 = 0 ;
4425 char * kwnames[] = {
4426 (char *) "name", NULL
4427 };
4428
4429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) SWIG_fail;
4430 {
4431 arg1 = wxString_in_helper(obj0);
4432 if (arg1 == NULL) SWIG_fail;
4433 temp1 = true;
4434 }
4435 {
4436 PyThreadState* __tstate = wxPyBeginAllowThreads();
4437 result = wxSystemOptions::GetOption((wxString const &)*arg1);
4438 wxPyEndAllowThreads(__tstate);
4439 if (PyErr_Occurred()) SWIG_fail;
4440 }
4441 {
4442 #if wxUSE_UNICODE
4443 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4444 #else
4445 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4446 #endif
4447 }
4448 {
4449 if (temp1)
4450 delete arg1;
4451 }
4452 return resultobj;
4453 fail:
4454 {
4455 if (temp1)
4456 delete arg1;
4457 }
4458 return NULL;
4459 }
4460
4461
4462 SWIGINTERN PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4463 PyObject *resultobj = 0;
4464 wxString *arg1 = 0 ;
4465 int result;
4466 bool temp1 = false ;
4467 PyObject * obj0 = 0 ;
4468 char * kwnames[] = {
4469 (char *) "name", NULL
4470 };
4471
4472 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) SWIG_fail;
4473 {
4474 arg1 = wxString_in_helper(obj0);
4475 if (arg1 == NULL) SWIG_fail;
4476 temp1 = true;
4477 }
4478 {
4479 PyThreadState* __tstate = wxPyBeginAllowThreads();
4480 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
4481 wxPyEndAllowThreads(__tstate);
4482 if (PyErr_Occurred()) SWIG_fail;
4483 }
4484 resultobj = SWIG_From_int(static_cast< int >(result));
4485 {
4486 if (temp1)
4487 delete arg1;
4488 }
4489 return resultobj;
4490 fail:
4491 {
4492 if (temp1)
4493 delete arg1;
4494 }
4495 return NULL;
4496 }
4497
4498
4499 SWIGINTERN PyObject *_wrap_SystemOptions_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4500 PyObject *resultobj = 0;
4501 wxString *arg1 = 0 ;
4502 bool result;
4503 bool temp1 = false ;
4504 PyObject * obj0 = 0 ;
4505 char * kwnames[] = {
4506 (char *) "name", NULL
4507 };
4508
4509 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) SWIG_fail;
4510 {
4511 arg1 = wxString_in_helper(obj0);
4512 if (arg1 == NULL) SWIG_fail;
4513 temp1 = true;
4514 }
4515 {
4516 PyThreadState* __tstate = wxPyBeginAllowThreads();
4517 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
4518 wxPyEndAllowThreads(__tstate);
4519 if (PyErr_Occurred()) SWIG_fail;
4520 }
4521 {
4522 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4523 }
4524 {
4525 if (temp1)
4526 delete arg1;
4527 }
4528 return resultobj;
4529 fail:
4530 {
4531 if (temp1)
4532 delete arg1;
4533 }
4534 return NULL;
4535 }
4536
4537
4538 SWIGINTERN PyObject *_wrap_SystemOptions_IsFalse(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4539 PyObject *resultobj = 0;
4540 wxString *arg1 = 0 ;
4541 bool result;
4542 bool temp1 = false ;
4543 PyObject * obj0 = 0 ;
4544 char * kwnames[] = {
4545 (char *) "name", NULL
4546 };
4547
4548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_IsFalse",kwnames,&obj0)) SWIG_fail;
4549 {
4550 arg1 = wxString_in_helper(obj0);
4551 if (arg1 == NULL) SWIG_fail;
4552 temp1 = true;
4553 }
4554 {
4555 PyThreadState* __tstate = wxPyBeginAllowThreads();
4556 result = (bool)wxSystemOptions::IsFalse((wxString const &)*arg1);
4557 wxPyEndAllowThreads(__tstate);
4558 if (PyErr_Occurred()) SWIG_fail;
4559 }
4560 {
4561 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4562 }
4563 {
4564 if (temp1)
4565 delete arg1;
4566 }
4567 return resultobj;
4568 fail:
4569 {
4570 if (temp1)
4571 delete arg1;
4572 }
4573 return NULL;
4574 }
4575
4576
4577 SWIGINTERN PyObject *SystemOptions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4578 PyObject *obj;
4579 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4580 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemOptions, SWIG_NewClientData(obj));
4581 return SWIG_Py_Void();
4582 }
4583
4584 SWIGINTERN PyObject *SystemOptions_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4585 return SWIG_Python_InitShadowInstance(args);
4586 }
4587
4588 SWIGINTERN int FileSelectorPromptStr_set(PyObject *) {
4589 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorPromptStr is read-only.");
4590 return 1;
4591 }
4592
4593
4594 SWIGINTERN PyObject *FileSelectorPromptStr_get(void) {
4595 PyObject *pyobj = 0;
4596
4597 {
4598 #if wxUSE_UNICODE
4599 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4600 #else
4601 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4602 #endif
4603 }
4604 return pyobj;
4605 }
4606
4607
4608 SWIGINTERN int FileSelectorDefaultWildcardStr_set(PyObject *) {
4609 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
4610 return 1;
4611 }
4612
4613
4614 SWIGINTERN PyObject *FileSelectorDefaultWildcardStr_get(void) {
4615 PyObject *pyobj = 0;
4616
4617 {
4618 #if wxUSE_UNICODE
4619 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4620 #else
4621 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4622 #endif
4623 }
4624 return pyobj;
4625 }
4626
4627
4628 SWIGINTERN int DirSelectorPromptStr_set(PyObject *) {
4629 SWIG_Error(SWIG_AttributeError,"Variable DirSelectorPromptStr is read-only.");
4630 return 1;
4631 }
4632
4633
4634 SWIGINTERN PyObject *DirSelectorPromptStr_get(void) {
4635 PyObject *pyobj = 0;
4636
4637 {
4638 #if wxUSE_UNICODE
4639 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4640 #else
4641 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4642 #endif
4643 }
4644 return pyobj;
4645 }
4646
4647
4648 SWIGINTERN PyObject *_wrap_NewId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4649 PyObject *resultobj = 0;
4650 long result;
4651
4652 if (!SWIG_Python_UnpackTuple(args,"NewId",0,0,0)) SWIG_fail;
4653 {
4654 PyThreadState* __tstate = wxPyBeginAllowThreads();
4655 result = (long)wxNewId();
4656 wxPyEndAllowThreads(__tstate);
4657 if (PyErr_Occurred()) SWIG_fail;
4658 }
4659 resultobj = SWIG_From_long(static_cast< long >(result));
4660 return resultobj;
4661 fail:
4662 return NULL;
4663 }
4664
4665
4666 SWIGINTERN PyObject *_wrap_RegisterId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4667 PyObject *resultobj = 0;
4668 long arg1 ;
4669 long val1 ;
4670 int ecode1 = 0 ;
4671 PyObject * obj0 = 0 ;
4672 char * kwnames[] = {
4673 (char *) "id", NULL
4674 };
4675
4676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) SWIG_fail;
4677 ecode1 = SWIG_AsVal_long(obj0, &val1);
4678 if (!SWIG_IsOK(ecode1)) {
4679 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "RegisterId" "', expected argument " "1"" of type '" "long""'");
4680 }
4681 arg1 = static_cast< long >(val1);
4682 {
4683 PyThreadState* __tstate = wxPyBeginAllowThreads();
4684 wxRegisterId(arg1);
4685 wxPyEndAllowThreads(__tstate);
4686 if (PyErr_Occurred()) SWIG_fail;
4687 }
4688 resultobj = SWIG_Py_Void();
4689 return resultobj;
4690 fail:
4691 return NULL;
4692 }
4693
4694
4695 SWIGINTERN PyObject *_wrap_GetCurrentId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4696 PyObject *resultobj = 0;
4697 long result;
4698
4699 if (!SWIG_Python_UnpackTuple(args,"GetCurrentId",0,0,0)) SWIG_fail;
4700 {
4701 PyThreadState* __tstate = wxPyBeginAllowThreads();
4702 result = (long)wxGetCurrentId();
4703 wxPyEndAllowThreads(__tstate);
4704 if (PyErr_Occurred()) SWIG_fail;
4705 }
4706 resultobj = SWIG_From_long(static_cast< long >(result));
4707 return resultobj;
4708 fail:
4709 return NULL;
4710 }
4711
4712
4713 SWIGINTERN PyObject *_wrap_IsStockID(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4714 PyObject *resultobj = 0;
4715 int arg1 ;
4716 bool result;
4717 int val1 ;
4718 int ecode1 = 0 ;
4719 PyObject * obj0 = 0 ;
4720 char * kwnames[] = {
4721 (char *) "id", NULL
4722 };
4723
4724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) SWIG_fail;
4725 ecode1 = SWIG_AsVal_int(obj0, &val1);
4726 if (!SWIG_IsOK(ecode1)) {
4727 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockID" "', expected argument " "1"" of type '" "int""'");
4728 }
4729 arg1 = static_cast< int >(val1);
4730 {
4731 PyThreadState* __tstate = wxPyBeginAllowThreads();
4732 result = (bool)wxIsStockID(arg1);
4733 wxPyEndAllowThreads(__tstate);
4734 if (PyErr_Occurred()) SWIG_fail;
4735 }
4736 {
4737 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4738 }
4739 return resultobj;
4740 fail:
4741 return NULL;
4742 }
4743
4744
4745 SWIGINTERN PyObject *_wrap_IsStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4746 PyObject *resultobj = 0;
4747 int arg1 ;
4748 wxString *arg2 = 0 ;
4749 bool result;
4750 int val1 ;
4751 int ecode1 = 0 ;
4752 bool temp2 = false ;
4753 PyObject * obj0 = 0 ;
4754 PyObject * obj1 = 0 ;
4755 char * kwnames[] = {
4756 (char *) "id",(char *) "label", NULL
4757 };
4758
4759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) SWIG_fail;
4760 ecode1 = SWIG_AsVal_int(obj0, &val1);
4761 if (!SWIG_IsOK(ecode1)) {
4762 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockLabel" "', expected argument " "1"" of type '" "int""'");
4763 }
4764 arg1 = static_cast< int >(val1);
4765 {
4766 arg2 = wxString_in_helper(obj1);
4767 if (arg2 == NULL) SWIG_fail;
4768 temp2 = true;
4769 }
4770 {
4771 PyThreadState* __tstate = wxPyBeginAllowThreads();
4772 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
4773 wxPyEndAllowThreads(__tstate);
4774 if (PyErr_Occurred()) SWIG_fail;
4775 }
4776 {
4777 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4778 }
4779 {
4780 if (temp2)
4781 delete arg2;
4782 }
4783 return resultobj;
4784 fail:
4785 {
4786 if (temp2)
4787 delete arg2;
4788 }
4789 return NULL;
4790 }
4791
4792
4793 SWIGINTERN PyObject *_wrap_GetStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4794 PyObject *resultobj = 0;
4795 int arg1 ;
4796 long arg2 = (long) wxSTOCK_WITH_MNEMONIC ;
4797 wxString result;
4798 int val1 ;
4799 int ecode1 = 0 ;
4800 long val2 ;
4801 int ecode2 = 0 ;
4802 PyObject * obj0 = 0 ;
4803 PyObject * obj1 = 0 ;
4804 char * kwnames[] = {
4805 (char *) "id",(char *) "flags", NULL
4806 };
4807
4808 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GetStockLabel",kwnames,&obj0,&obj1)) SWIG_fail;
4809 ecode1 = SWIG_AsVal_int(obj0, &val1);
4810 if (!SWIG_IsOK(ecode1)) {
4811 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetStockLabel" "', expected argument " "1"" of type '" "int""'");
4812 }
4813 arg1 = static_cast< int >(val1);
4814 if (obj1) {
4815 ecode2 = SWIG_AsVal_long(obj1, &val2);
4816 if (!SWIG_IsOK(ecode2)) {
4817 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetStockLabel" "', expected argument " "2"" of type '" "long""'");
4818 }
4819 arg2 = static_cast< long >(val2);
4820 }
4821 {
4822 PyThreadState* __tstate = wxPyBeginAllowThreads();
4823 result = wxGetStockLabel(arg1,arg2);
4824 wxPyEndAllowThreads(__tstate);
4825 if (PyErr_Occurred()) SWIG_fail;
4826 }
4827 {
4828 #if wxUSE_UNICODE
4829 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4830 #else
4831 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4832 #endif
4833 }
4834 return resultobj;
4835 fail:
4836 return NULL;
4837 }
4838
4839
4840 SWIGINTERN PyObject *_wrap_GetStockHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4841 PyObject *resultobj = 0;
4842 int arg1 ;
4843 wxStockHelpStringClient arg2 = (wxStockHelpStringClient) wxSTOCK_MENU ;
4844 wxString result;
4845 int val1 ;
4846 int ecode1 = 0 ;
4847 int val2 ;
4848 int ecode2 = 0 ;
4849 PyObject * obj0 = 0 ;
4850 PyObject * obj1 = 0 ;
4851 char * kwnames[] = {
4852 (char *) "id",(char *) "client", NULL
4853 };
4854
4855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GetStockHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
4856 ecode1 = SWIG_AsVal_int(obj0, &val1);
4857 if (!SWIG_IsOK(ecode1)) {
4858 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetStockHelpString" "', expected argument " "1"" of type '" "int""'");
4859 }
4860 arg1 = static_cast< int >(val1);
4861 if (obj1) {
4862 ecode2 = SWIG_AsVal_int(obj1, &val2);
4863 if (!SWIG_IsOK(ecode2)) {
4864 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetStockHelpString" "', expected argument " "2"" of type '" "wxStockHelpStringClient""'");
4865 }
4866 arg2 = static_cast< wxStockHelpStringClient >(val2);
4867 }
4868 {
4869 PyThreadState* __tstate = wxPyBeginAllowThreads();
4870 result = wxGetStockHelpString(arg1,arg2);
4871 wxPyEndAllowThreads(__tstate);
4872 if (PyErr_Occurred()) SWIG_fail;
4873 }
4874 {
4875 #if wxUSE_UNICODE
4876 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4877 #else
4878 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4879 #endif
4880 }
4881 return resultobj;
4882 fail:
4883 return NULL;
4884 }
4885
4886
4887 SWIGINTERN PyObject *_wrap_Bell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4888 PyObject *resultobj = 0;
4889
4890 if (!SWIG_Python_UnpackTuple(args,"Bell",0,0,0)) SWIG_fail;
4891 {
4892 if (!wxPyCheckForApp()) SWIG_fail;
4893 PyThreadState* __tstate = wxPyBeginAllowThreads();
4894 wxBell();
4895 wxPyEndAllowThreads(__tstate);
4896 if (PyErr_Occurred()) SWIG_fail;
4897 }
4898 resultobj = SWIG_Py_Void();
4899 return resultobj;
4900 fail:
4901 return NULL;
4902 }
4903
4904
4905 SWIGINTERN PyObject *_wrap_EndBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4906 PyObject *resultobj = 0;
4907
4908 if (!SWIG_Python_UnpackTuple(args,"EndBusyCursor",0,0,0)) SWIG_fail;
4909 {
4910 if (!wxPyCheckForApp()) SWIG_fail;
4911 PyThreadState* __tstate = wxPyBeginAllowThreads();
4912 wxEndBusyCursor();
4913 wxPyEndAllowThreads(__tstate);
4914 if (PyErr_Occurred()) SWIG_fail;
4915 }
4916 resultobj = SWIG_Py_Void();
4917 return resultobj;
4918 fail:
4919 return NULL;
4920 }
4921
4922
4923 SWIGINTERN PyObject *_wrap_GetElapsedTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4924 PyObject *resultobj = 0;
4925 bool arg1 = (bool) true ;
4926 long result;
4927 bool val1 ;
4928 int ecode1 = 0 ;
4929 PyObject * obj0 = 0 ;
4930 char * kwnames[] = {
4931 (char *) "resetTimer", NULL
4932 };
4933
4934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) SWIG_fail;
4935 if (obj0) {
4936 ecode1 = SWIG_AsVal_bool(obj0, &val1);
4937 if (!SWIG_IsOK(ecode1)) {
4938 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetElapsedTime" "', expected argument " "1"" of type '" "bool""'");
4939 }
4940 arg1 = static_cast< bool >(val1);
4941 }
4942 {
4943 PyThreadState* __tstate = wxPyBeginAllowThreads();
4944 result = (long)wxGetElapsedTime(arg1);
4945 wxPyEndAllowThreads(__tstate);
4946 if (PyErr_Occurred()) SWIG_fail;
4947 }
4948 resultobj = SWIG_From_long(static_cast< long >(result));
4949 return resultobj;
4950 fail:
4951 return NULL;
4952 }
4953
4954
4955 SWIGINTERN PyObject *_wrap_IsBusy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4956 PyObject *resultobj = 0;
4957 bool result;
4958
4959 if (!SWIG_Python_UnpackTuple(args,"IsBusy",0,0,0)) SWIG_fail;
4960 {
4961 PyThreadState* __tstate = wxPyBeginAllowThreads();
4962 result = (bool)wxIsBusy();
4963 wxPyEndAllowThreads(__tstate);
4964 if (PyErr_Occurred()) SWIG_fail;
4965 }
4966 {
4967 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4968 }
4969 return resultobj;
4970 fail:
4971 return NULL;
4972 }
4973
4974
4975 SWIGINTERN PyObject *_wrap_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4976 PyObject *resultobj = 0;
4977 wxString result;
4978
4979 if (!SWIG_Python_UnpackTuple(args,"Now",0,0,0)) SWIG_fail;
4980 {
4981 PyThreadState* __tstate = wxPyBeginAllowThreads();
4982 result = wxNow();
4983 wxPyEndAllowThreads(__tstate);
4984 if (PyErr_Occurred()) SWIG_fail;
4985 }
4986 {
4987 #if wxUSE_UNICODE
4988 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4989 #else
4990 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4991 #endif
4992 }
4993 return resultobj;
4994 fail:
4995 return NULL;
4996 }
4997
4998
4999 SWIGINTERN PyObject *_wrap_Shell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5000 PyObject *resultobj = 0;
5001 wxString const &arg1_defvalue = wxPyEmptyString ;
5002 wxString *arg1 = (wxString *) &arg1_defvalue ;
5003 bool result;
5004 bool temp1 = false ;
5005 PyObject * obj0 = 0 ;
5006 char * kwnames[] = {
5007 (char *) "command", NULL
5008 };
5009
5010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) SWIG_fail;
5011 if (obj0) {
5012 {
5013 arg1 = wxString_in_helper(obj0);
5014 if (arg1 == NULL) SWIG_fail;
5015 temp1 = true;
5016 }
5017 }
5018 {
5019 PyThreadState* __tstate = wxPyBeginAllowThreads();
5020 result = (bool)wxShell((wxString const &)*arg1);
5021 wxPyEndAllowThreads(__tstate);
5022 if (PyErr_Occurred()) SWIG_fail;
5023 }
5024 {
5025 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5026 }
5027 {
5028 if (temp1)
5029 delete arg1;
5030 }
5031 return resultobj;
5032 fail:
5033 {
5034 if (temp1)
5035 delete arg1;
5036 }
5037 return NULL;
5038 }
5039
5040
5041 SWIGINTERN PyObject *_wrap_StartTimer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5042 PyObject *resultobj = 0;
5043
5044 if (!SWIG_Python_UnpackTuple(args,"StartTimer",0,0,0)) SWIG_fail;
5045 {
5046 PyThreadState* __tstate = wxPyBeginAllowThreads();
5047 wxStartTimer();
5048 wxPyEndAllowThreads(__tstate);
5049 if (PyErr_Occurred()) SWIG_fail;
5050 }
5051 resultobj = SWIG_Py_Void();
5052 return resultobj;
5053 fail:
5054 return NULL;
5055 }
5056
5057
5058 SWIGINTERN PyObject *_wrap_GetOsVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5059 PyObject *resultobj = 0;
5060 int *arg1 = (int *) 0 ;
5061 int *arg2 = (int *) 0 ;
5062 int result;
5063 int temp1 ;
5064 int res1 = SWIG_TMPOBJ ;
5065 int temp2 ;
5066 int res2 = SWIG_TMPOBJ ;
5067
5068 arg1 = &temp1;
5069 arg2 = &temp2;
5070 if (!SWIG_Python_UnpackTuple(args,"GetOsVersion",0,0,0)) SWIG_fail;
5071 {
5072 PyThreadState* __tstate = wxPyBeginAllowThreads();
5073 result = (int)wxGetOsVersion(arg1,arg2);
5074 wxPyEndAllowThreads(__tstate);
5075 if (PyErr_Occurred()) SWIG_fail;
5076 }
5077 resultobj = SWIG_From_int(static_cast< int >(result));
5078 if (SWIG_IsTmpObj(res1)) {
5079 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
5080 } else {
5081 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5082 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
5083 }
5084 if (SWIG_IsTmpObj(res2)) {
5085 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
5086 } else {
5087 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5088 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
5089 }
5090 return resultobj;
5091 fail:
5092 return NULL;
5093 }
5094
5095
5096 SWIGINTERN PyObject *_wrap_GetOsDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5097 PyObject *resultobj = 0;
5098 wxString result;
5099
5100 if (!SWIG_Python_UnpackTuple(args,"GetOsDescription",0,0,0)) SWIG_fail;
5101 {
5102 PyThreadState* __tstate = wxPyBeginAllowThreads();
5103 result = wxGetOsDescription();
5104 wxPyEndAllowThreads(__tstate);
5105 if (PyErr_Occurred()) SWIG_fail;
5106 }
5107 {
5108 #if wxUSE_UNICODE
5109 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5110 #else
5111 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5112 #endif
5113 }
5114 return resultobj;
5115 fail:
5116 return NULL;
5117 }
5118
5119
5120 SWIGINTERN PyObject *_wrap_IsPlatformLittleEndian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5121 PyObject *resultobj = 0;
5122 bool result;
5123
5124 if (!SWIG_Python_UnpackTuple(args,"IsPlatformLittleEndian",0,0,0)) SWIG_fail;
5125 {
5126 PyThreadState* __tstate = wxPyBeginAllowThreads();
5127 result = (bool)wxIsPlatformLittleEndian();
5128 wxPyEndAllowThreads(__tstate);
5129 if (PyErr_Occurred()) SWIG_fail;
5130 }
5131 {
5132 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5133 }
5134 return resultobj;
5135 fail:
5136 return NULL;
5137 }
5138
5139
5140 SWIGINTERN PyObject *_wrap_IsPlatform64Bit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5141 PyObject *resultobj = 0;
5142 bool result;
5143
5144 if (!SWIG_Python_UnpackTuple(args,"IsPlatform64Bit",0,0,0)) SWIG_fail;
5145 {
5146 PyThreadState* __tstate = wxPyBeginAllowThreads();
5147 result = (bool)wxIsPlatform64Bit();
5148 wxPyEndAllowThreads(__tstate);
5149 if (PyErr_Occurred()) SWIG_fail;
5150 }
5151 {
5152 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5153 }
5154 return resultobj;
5155 fail:
5156 return NULL;
5157 }
5158
5159
5160 SWIGINTERN PyObject *_wrap_GetFreeMemory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5161 PyObject *resultobj = 0;
5162 wxMemorySize result;
5163
5164 if (!SWIG_Python_UnpackTuple(args,"GetFreeMemory",0,0,0)) SWIG_fail;
5165 {
5166 PyThreadState* __tstate = wxPyBeginAllowThreads();
5167 result = wxGetFreeMemory();
5168 wxPyEndAllowThreads(__tstate);
5169 if (PyErr_Occurred()) SWIG_fail;
5170 }
5171 {
5172 #if wxUSE_LONGLONG
5173 resultobj = PyLong_FromLongLong((&result)->GetValue());
5174 #else
5175 resultobj = PyInt_FromLong(result);
5176 #endif
5177 }
5178 return resultobj;
5179 fail:
5180 return NULL;
5181 }
5182
5183
5184 SWIGINTERN PyObject *_wrap_Shutdown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5185 PyObject *resultobj = 0;
5186 wxShutdownFlags arg1 ;
5187 bool result;
5188 int val1 ;
5189 int ecode1 = 0 ;
5190 PyObject * obj0 = 0 ;
5191 char * kwnames[] = {
5192 (char *) "wFlags", NULL
5193 };
5194
5195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) SWIG_fail;
5196 ecode1 = SWIG_AsVal_int(obj0, &val1);
5197 if (!SWIG_IsOK(ecode1)) {
5198 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Shutdown" "', expected argument " "1"" of type '" "wxShutdownFlags""'");
5199 }
5200 arg1 = static_cast< wxShutdownFlags >(val1);
5201 {
5202 if (!wxPyCheckForApp()) SWIG_fail;
5203 PyThreadState* __tstate = wxPyBeginAllowThreads();
5204 result = (bool)wxShutdown(arg1);
5205 wxPyEndAllowThreads(__tstate);
5206 if (PyErr_Occurred()) SWIG_fail;
5207 }
5208 {
5209 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5210 }
5211 return resultobj;
5212 fail:
5213 return NULL;
5214 }
5215
5216
5217 SWIGINTERN PyObject *_wrap_Sleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5218 PyObject *resultobj = 0;
5219 int arg1 ;
5220 int val1 ;
5221 int ecode1 = 0 ;
5222 PyObject * obj0 = 0 ;
5223 char * kwnames[] = {
5224 (char *) "secs", NULL
5225 };
5226
5227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) SWIG_fail;
5228 ecode1 = SWIG_AsVal_int(obj0, &val1);
5229 if (!SWIG_IsOK(ecode1)) {
5230 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Sleep" "', expected argument " "1"" of type '" "int""'");
5231 }
5232 arg1 = static_cast< int >(val1);
5233 {
5234 PyThreadState* __tstate = wxPyBeginAllowThreads();
5235 wxSleep(arg1);
5236 wxPyEndAllowThreads(__tstate);
5237 if (PyErr_Occurred()) SWIG_fail;
5238 }
5239 resultobj = SWIG_Py_Void();
5240 return resultobj;
5241 fail:
5242 return NULL;
5243 }
5244
5245
5246 SWIGINTERN PyObject *_wrap_MilliSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5247 PyObject *resultobj = 0;
5248 unsigned long arg1 ;
5249 unsigned long val1 ;
5250 int ecode1 = 0 ;
5251 PyObject * obj0 = 0 ;
5252 char * kwnames[] = {
5253 (char *) "milliseconds", NULL
5254 };
5255
5256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) SWIG_fail;
5257 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5258 if (!SWIG_IsOK(ecode1)) {
5259 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MilliSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5260 }
5261 arg1 = static_cast< unsigned long >(val1);
5262 {
5263 PyThreadState* __tstate = wxPyBeginAllowThreads();
5264 wxMilliSleep(arg1);
5265 wxPyEndAllowThreads(__tstate);
5266 if (PyErr_Occurred()) SWIG_fail;
5267 }
5268 resultobj = SWIG_Py_Void();
5269 return resultobj;
5270 fail:
5271 return NULL;
5272 }
5273
5274
5275 SWIGINTERN PyObject *_wrap_MicroSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5276 PyObject *resultobj = 0;
5277 unsigned long arg1 ;
5278 unsigned long val1 ;
5279 int ecode1 = 0 ;
5280 PyObject * obj0 = 0 ;
5281 char * kwnames[] = {
5282 (char *) "microseconds", NULL
5283 };
5284
5285 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) SWIG_fail;
5286 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5287 if (!SWIG_IsOK(ecode1)) {
5288 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MicroSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5289 }
5290 arg1 = static_cast< unsigned long >(val1);
5291 {
5292 PyThreadState* __tstate = wxPyBeginAllowThreads();
5293 wxMicroSleep(arg1);
5294 wxPyEndAllowThreads(__tstate);
5295 if (PyErr_Occurred()) SWIG_fail;
5296 }
5297 resultobj = SWIG_Py_Void();
5298 return resultobj;
5299 fail:
5300 return NULL;
5301 }
5302
5303
5304 SWIGINTERN PyObject *_wrap_EnableTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5305 PyObject *resultobj = 0;
5306 bool arg1 ;
5307 bool val1 ;
5308 int ecode1 = 0 ;
5309 PyObject * obj0 = 0 ;
5310 char * kwnames[] = {
5311 (char *) "enable", NULL
5312 };
5313
5314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) SWIG_fail;
5315 ecode1 = SWIG_AsVal_bool(obj0, &val1);
5316 if (!SWIG_IsOK(ecode1)) {
5317 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "EnableTopLevelWindows" "', expected argument " "1"" of type '" "bool""'");
5318 }
5319 arg1 = static_cast< bool >(val1);
5320 {
5321 PyThreadState* __tstate = wxPyBeginAllowThreads();
5322 wxEnableTopLevelWindows(arg1);
5323 wxPyEndAllowThreads(__tstate);
5324 if (PyErr_Occurred()) SWIG_fail;
5325 }
5326 resultobj = SWIG_Py_Void();
5327 return resultobj;
5328 fail:
5329 return NULL;
5330 }
5331
5332
5333 SWIGINTERN PyObject *_wrap_StripMenuCodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5334 PyObject *resultobj = 0;
5335 wxString *arg1 = 0 ;
5336 wxString result;
5337 bool temp1 = false ;
5338 PyObject * obj0 = 0 ;
5339 char * kwnames[] = {
5340 (char *) "in", NULL
5341 };
5342
5343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) SWIG_fail;
5344 {
5345 arg1 = wxString_in_helper(obj0);
5346 if (arg1 == NULL) SWIG_fail;
5347 temp1 = true;
5348 }
5349 {
5350 PyThreadState* __tstate = wxPyBeginAllowThreads();
5351 result = wxStripMenuCodes((wxString const &)*arg1);
5352 wxPyEndAllowThreads(__tstate);
5353 if (PyErr_Occurred()) SWIG_fail;
5354 }
5355 {
5356 #if wxUSE_UNICODE
5357 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5358 #else
5359 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5360 #endif
5361 }
5362 {
5363 if (temp1)
5364 delete arg1;
5365 }
5366 return resultobj;
5367 fail:
5368 {
5369 if (temp1)
5370 delete arg1;
5371 }
5372 return NULL;
5373 }
5374
5375
5376 SWIGINTERN PyObject *_wrap_GetEmailAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5377 PyObject *resultobj = 0;
5378 wxString result;
5379
5380 if (!SWIG_Python_UnpackTuple(args,"GetEmailAddress",0,0,0)) SWIG_fail;
5381 {
5382 PyThreadState* __tstate = wxPyBeginAllowThreads();
5383 result = wxGetEmailAddress();
5384 wxPyEndAllowThreads(__tstate);
5385 if (PyErr_Occurred()) SWIG_fail;
5386 }
5387 {
5388 #if wxUSE_UNICODE
5389 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5390 #else
5391 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5392 #endif
5393 }
5394 return resultobj;
5395 fail:
5396 return NULL;
5397 }
5398
5399
5400 SWIGINTERN PyObject *_wrap_GetHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5401 PyObject *resultobj = 0;
5402 wxString result;
5403
5404 if (!SWIG_Python_UnpackTuple(args,"GetHostName",0,0,0)) SWIG_fail;
5405 {
5406 PyThreadState* __tstate = wxPyBeginAllowThreads();
5407 result = wxGetHostName();
5408 wxPyEndAllowThreads(__tstate);
5409 if (PyErr_Occurred()) SWIG_fail;
5410 }
5411 {
5412 #if wxUSE_UNICODE
5413 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5414 #else
5415 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5416 #endif
5417 }
5418 return resultobj;
5419 fail:
5420 return NULL;
5421 }
5422
5423
5424 SWIGINTERN PyObject *_wrap_GetFullHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5425 PyObject *resultobj = 0;
5426 wxString result;
5427
5428 if (!SWIG_Python_UnpackTuple(args,"GetFullHostName",0,0,0)) SWIG_fail;
5429 {
5430 PyThreadState* __tstate = wxPyBeginAllowThreads();
5431 result = wxGetFullHostName();
5432 wxPyEndAllowThreads(__tstate);
5433 if (PyErr_Occurred()) SWIG_fail;
5434 }
5435 {
5436 #if wxUSE_UNICODE
5437 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5438 #else
5439 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5440 #endif
5441 }
5442 return resultobj;
5443 fail:
5444 return NULL;
5445 }
5446
5447
5448 SWIGINTERN PyObject *_wrap_GetUserId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5449 PyObject *resultobj = 0;
5450 wxString result;
5451
5452 if (!SWIG_Python_UnpackTuple(args,"GetUserId",0,0,0)) SWIG_fail;
5453 {
5454 PyThreadState* __tstate = wxPyBeginAllowThreads();
5455 result = wxGetUserId();
5456 wxPyEndAllowThreads(__tstate);
5457 if (PyErr_Occurred()) SWIG_fail;
5458 }
5459 {
5460 #if wxUSE_UNICODE
5461 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5462 #else
5463 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5464 #endif
5465 }
5466 return resultobj;
5467 fail:
5468 return NULL;
5469 }
5470
5471
5472 SWIGINTERN PyObject *_wrap_GetUserName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5473 PyObject *resultobj = 0;
5474 wxString result;
5475
5476 if (!SWIG_Python_UnpackTuple(args,"GetUserName",0,0,0)) SWIG_fail;
5477 {
5478 PyThreadState* __tstate = wxPyBeginAllowThreads();
5479 result = wxGetUserName();
5480 wxPyEndAllowThreads(__tstate);
5481 if (PyErr_Occurred()) SWIG_fail;
5482 }
5483 {
5484 #if wxUSE_UNICODE
5485 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5486 #else
5487 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5488 #endif
5489 }
5490 return resultobj;
5491 fail:
5492 return NULL;
5493 }
5494
5495
5496 SWIGINTERN PyObject *_wrap_GetHomeDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5497 PyObject *resultobj = 0;
5498 wxString result;
5499
5500 if (!SWIG_Python_UnpackTuple(args,"GetHomeDir",0,0,0)) SWIG_fail;
5501 {
5502 PyThreadState* __tstate = wxPyBeginAllowThreads();
5503 result = wxGetHomeDir();
5504 wxPyEndAllowThreads(__tstate);
5505 if (PyErr_Occurred()) SWIG_fail;
5506 }
5507 {
5508 #if wxUSE_UNICODE
5509 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5510 #else
5511 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5512 #endif
5513 }
5514 return resultobj;
5515 fail:
5516 return NULL;
5517 }
5518
5519
5520 SWIGINTERN PyObject *_wrap_GetUserHome(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5521 PyObject *resultobj = 0;
5522 wxString const &arg1_defvalue = wxPyEmptyString ;
5523 wxString *arg1 = (wxString *) &arg1_defvalue ;
5524 wxString result;
5525 bool temp1 = false ;
5526 PyObject * obj0 = 0 ;
5527 char * kwnames[] = {
5528 (char *) "user", NULL
5529 };
5530
5531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) SWIG_fail;
5532 if (obj0) {
5533 {
5534 arg1 = wxString_in_helper(obj0);
5535 if (arg1 == NULL) SWIG_fail;
5536 temp1 = true;
5537 }
5538 }
5539 {
5540 PyThreadState* __tstate = wxPyBeginAllowThreads();
5541 result = wxGetUserHome((wxString const &)*arg1);
5542 wxPyEndAllowThreads(__tstate);
5543 if (PyErr_Occurred()) SWIG_fail;
5544 }
5545 {
5546 #if wxUSE_UNICODE
5547 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5548 #else
5549 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5550 #endif
5551 }
5552 {
5553 if (temp1)
5554 delete arg1;
5555 }
5556 return resultobj;
5557 fail:
5558 {
5559 if (temp1)
5560 delete arg1;
5561 }
5562 return NULL;
5563 }
5564
5565
5566 SWIGINTERN PyObject *_wrap_GetProcessId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5567 PyObject *resultobj = 0;
5568 unsigned long result;
5569
5570 if (!SWIG_Python_UnpackTuple(args,"GetProcessId",0,0,0)) SWIG_fail;
5571 {
5572 PyThreadState* __tstate = wxPyBeginAllowThreads();
5573 result = (unsigned long)wxGetProcessId();
5574 wxPyEndAllowThreads(__tstate);
5575 if (PyErr_Occurred()) SWIG_fail;
5576 }
5577 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
5578 return resultobj;
5579 fail:
5580 return NULL;
5581 }
5582
5583
5584 SWIGINTERN PyObject *_wrap_Trap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5585 PyObject *resultobj = 0;
5586
5587 if (!SWIG_Python_UnpackTuple(args,"Trap",0,0,0)) SWIG_fail;
5588 {
5589 PyThreadState* __tstate = wxPyBeginAllowThreads();
5590 wxTrap();
5591 wxPyEndAllowThreads(__tstate);
5592 if (PyErr_Occurred()) SWIG_fail;
5593 }
5594 resultobj = SWIG_Py_Void();
5595 return resultobj;
5596 fail:
5597 return NULL;
5598 }
5599
5600
5601 SWIGINTERN PyObject *_wrap_FileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5602 PyObject *resultobj = 0;
5603 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
5604 wxString *arg1 = (wxString *) &arg1_defvalue ;
5605 wxString const &arg2_defvalue = wxPyEmptyString ;
5606 wxString *arg2 = (wxString *) &arg2_defvalue ;
5607 wxString const &arg3_defvalue = wxPyEmptyString ;
5608 wxString *arg3 = (wxString *) &arg3_defvalue ;
5609 wxString const &arg4_defvalue = wxPyEmptyString ;
5610 wxString *arg4 = (wxString *) &arg4_defvalue ;
5611 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
5612 wxString *arg5 = (wxString *) &arg5_defvalue ;
5613 int arg6 = (int) 0 ;
5614 wxWindow *arg7 = (wxWindow *) NULL ;
5615 int arg8 = (int) -1 ;
5616 int arg9 = (int) -1 ;
5617 wxString result;
5618 bool temp1 = false ;
5619 bool temp2 = false ;
5620 bool temp3 = false ;
5621 bool temp4 = false ;
5622 bool temp5 = false ;
5623 int val6 ;
5624 int ecode6 = 0 ;
5625 void *argp7 = 0 ;
5626 int res7 = 0 ;
5627 int val8 ;
5628 int ecode8 = 0 ;
5629 int val9 ;
5630 int ecode9 = 0 ;
5631 PyObject * obj0 = 0 ;
5632 PyObject * obj1 = 0 ;
5633 PyObject * obj2 = 0 ;
5634 PyObject * obj3 = 0 ;
5635 PyObject * obj4 = 0 ;
5636 PyObject * obj5 = 0 ;
5637 PyObject * obj6 = 0 ;
5638 PyObject * obj7 = 0 ;
5639 PyObject * obj8 = 0 ;
5640 char * kwnames[] = {
5641 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
5642 };
5643
5644 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
5645 if (obj0) {
5646 {
5647 arg1 = wxString_in_helper(obj0);
5648 if (arg1 == NULL) SWIG_fail;
5649 temp1 = true;
5650 }
5651 }
5652 if (obj1) {
5653 {
5654 arg2 = wxString_in_helper(obj1);
5655 if (arg2 == NULL) SWIG_fail;
5656 temp2 = true;
5657 }
5658 }
5659 if (obj2) {
5660 {
5661 arg3 = wxString_in_helper(obj2);
5662 if (arg3 == NULL) SWIG_fail;
5663 temp3 = true;
5664 }
5665 }
5666 if (obj3) {
5667 {
5668 arg4 = wxString_in_helper(obj3);
5669 if (arg4 == NULL) SWIG_fail;
5670 temp4 = true;
5671 }
5672 }
5673 if (obj4) {
5674 {
5675 arg5 = wxString_in_helper(obj4);
5676 if (arg5 == NULL) SWIG_fail;
5677 temp5 = true;
5678 }
5679 }
5680 if (obj5) {
5681 ecode6 = SWIG_AsVal_int(obj5, &val6);
5682 if (!SWIG_IsOK(ecode6)) {
5683 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "FileSelector" "', expected argument " "6"" of type '" "int""'");
5684 }
5685 arg6 = static_cast< int >(val6);
5686 }
5687 if (obj6) {
5688 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_wxWindow, 0 | 0 );
5689 if (!SWIG_IsOK(res7)) {
5690 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "FileSelector" "', expected argument " "7"" of type '" "wxWindow *""'");
5691 }
5692 arg7 = reinterpret_cast< wxWindow * >(argp7);
5693 }
5694 if (obj7) {
5695 ecode8 = SWIG_AsVal_int(obj7, &val8);
5696 if (!SWIG_IsOK(ecode8)) {
5697 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "FileSelector" "', expected argument " "8"" of type '" "int""'");
5698 }
5699 arg8 = static_cast< int >(val8);
5700 }
5701 if (obj8) {
5702 ecode9 = SWIG_AsVal_int(obj8, &val9);
5703 if (!SWIG_IsOK(ecode9)) {
5704 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "FileSelector" "', expected argument " "9"" of type '" "int""'");
5705 }
5706 arg9 = static_cast< int >(val9);
5707 }
5708 {
5709 if (!wxPyCheckForApp()) SWIG_fail;
5710 PyThreadState* __tstate = wxPyBeginAllowThreads();
5711 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
5712 wxPyEndAllowThreads(__tstate);
5713 if (PyErr_Occurred()) SWIG_fail;
5714 }
5715 {
5716 #if wxUSE_UNICODE
5717 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5718 #else
5719 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5720 #endif
5721 }
5722 {
5723 if (temp1)
5724 delete arg1;
5725 }
5726 {
5727 if (temp2)
5728 delete arg2;
5729 }
5730 {
5731 if (temp3)
5732 delete arg3;
5733 }
5734 {
5735 if (temp4)
5736 delete arg4;
5737 }
5738 {
5739 if (temp5)
5740 delete arg5;
5741 }
5742 return resultobj;
5743 fail:
5744 {
5745 if (temp1)
5746 delete arg1;
5747 }
5748 {
5749 if (temp2)
5750 delete arg2;
5751 }
5752 {
5753 if (temp3)
5754 delete arg3;
5755 }
5756 {
5757 if (temp4)
5758 delete arg4;
5759 }
5760 {
5761 if (temp5)
5762 delete arg5;
5763 }
5764 return NULL;
5765 }
5766
5767
5768 SWIGINTERN PyObject *_wrap_LoadFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5769 PyObject *resultobj = 0;
5770 wxString *arg1 = 0 ;
5771 wxString *arg2 = 0 ;
5772 wxString const &arg3_defvalue = wxPyEmptyString ;
5773 wxString *arg3 = (wxString *) &arg3_defvalue ;
5774 wxWindow *arg4 = (wxWindow *) NULL ;
5775 wxString result;
5776 bool temp1 = false ;
5777 bool temp2 = false ;
5778 bool temp3 = false ;
5779 void *argp4 = 0 ;
5780 int res4 = 0 ;
5781 PyObject * obj0 = 0 ;
5782 PyObject * obj1 = 0 ;
5783 PyObject * obj2 = 0 ;
5784 PyObject * obj3 = 0 ;
5785 char * kwnames[] = {
5786 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5787 };
5788
5789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5790 {
5791 arg1 = wxString_in_helper(obj0);
5792 if (arg1 == NULL) SWIG_fail;
5793 temp1 = true;
5794 }
5795 {
5796 arg2 = wxString_in_helper(obj1);
5797 if (arg2 == NULL) SWIG_fail;
5798 temp2 = true;
5799 }
5800 if (obj2) {
5801 {
5802 arg3 = wxString_in_helper(obj2);
5803 if (arg3 == NULL) SWIG_fail;
5804 temp3 = true;
5805 }
5806 }
5807 if (obj3) {
5808 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5809 if (!SWIG_IsOK(res4)) {
5810 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LoadFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5811 }
5812 arg4 = reinterpret_cast< wxWindow * >(argp4);
5813 }
5814 {
5815 if (!wxPyCheckForApp()) SWIG_fail;
5816 PyThreadState* __tstate = wxPyBeginAllowThreads();
5817 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5818 wxPyEndAllowThreads(__tstate);
5819 if (PyErr_Occurred()) SWIG_fail;
5820 }
5821 {
5822 #if wxUSE_UNICODE
5823 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5824 #else
5825 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5826 #endif
5827 }
5828 {
5829 if (temp1)
5830 delete arg1;
5831 }
5832 {
5833 if (temp2)
5834 delete arg2;
5835 }
5836 {
5837 if (temp3)
5838 delete arg3;
5839 }
5840 return resultobj;
5841 fail:
5842 {
5843 if (temp1)
5844 delete arg1;
5845 }
5846 {
5847 if (temp2)
5848 delete arg2;
5849 }
5850 {
5851 if (temp3)
5852 delete arg3;
5853 }
5854 return NULL;
5855 }
5856
5857
5858 SWIGINTERN PyObject *_wrap_SaveFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5859 PyObject *resultobj = 0;
5860 wxString *arg1 = 0 ;
5861 wxString *arg2 = 0 ;
5862 wxString const &arg3_defvalue = wxPyEmptyString ;
5863 wxString *arg3 = (wxString *) &arg3_defvalue ;
5864 wxWindow *arg4 = (wxWindow *) NULL ;
5865 wxString result;
5866 bool temp1 = false ;
5867 bool temp2 = false ;
5868 bool temp3 = false ;
5869 void *argp4 = 0 ;
5870 int res4 = 0 ;
5871 PyObject * obj0 = 0 ;
5872 PyObject * obj1 = 0 ;
5873 PyObject * obj2 = 0 ;
5874 PyObject * obj3 = 0 ;
5875 char * kwnames[] = {
5876 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5877 };
5878
5879 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5880 {
5881 arg1 = wxString_in_helper(obj0);
5882 if (arg1 == NULL) SWIG_fail;
5883 temp1 = true;
5884 }
5885 {
5886 arg2 = wxString_in_helper(obj1);
5887 if (arg2 == NULL) SWIG_fail;
5888 temp2 = true;
5889 }
5890 if (obj2) {
5891 {
5892 arg3 = wxString_in_helper(obj2);
5893 if (arg3 == NULL) SWIG_fail;
5894 temp3 = true;
5895 }
5896 }
5897 if (obj3) {
5898 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5899 if (!SWIG_IsOK(res4)) {
5900 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SaveFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5901 }
5902 arg4 = reinterpret_cast< wxWindow * >(argp4);
5903 }
5904 {
5905 if (!wxPyCheckForApp()) SWIG_fail;
5906 PyThreadState* __tstate = wxPyBeginAllowThreads();
5907 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5908 wxPyEndAllowThreads(__tstate);
5909 if (PyErr_Occurred()) SWIG_fail;
5910 }
5911 {
5912 #if wxUSE_UNICODE
5913 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5914 #else
5915 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5916 #endif
5917 }
5918 {
5919 if (temp1)
5920 delete arg1;
5921 }
5922 {
5923 if (temp2)
5924 delete arg2;
5925 }
5926 {
5927 if (temp3)
5928 delete arg3;
5929 }
5930 return resultobj;
5931 fail:
5932 {
5933 if (temp1)
5934 delete arg1;
5935 }
5936 {
5937 if (temp2)
5938 delete arg2;
5939 }
5940 {
5941 if (temp3)
5942 delete arg3;
5943 }
5944 return NULL;
5945 }
5946
5947
5948 SWIGINTERN PyObject *_wrap_DirSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5949 PyObject *resultobj = 0;
5950 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
5951 wxString *arg1 = (wxString *) &arg1_defvalue ;
5952 wxString const &arg2_defvalue = wxPyEmptyString ;
5953 wxString *arg2 = (wxString *) &arg2_defvalue ;
5954 long arg3 = (long) wxDD_DEFAULT_STYLE ;
5955 wxPoint const &arg4_defvalue = wxDefaultPosition ;
5956 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
5957 wxWindow *arg5 = (wxWindow *) NULL ;
5958 wxString result;
5959 bool temp1 = false ;
5960 bool temp2 = false ;
5961 long val3 ;
5962 int ecode3 = 0 ;
5963 wxPoint temp4 ;
5964 void *argp5 = 0 ;
5965 int res5 = 0 ;
5966 PyObject * obj0 = 0 ;
5967 PyObject * obj1 = 0 ;
5968 PyObject * obj2 = 0 ;
5969 PyObject * obj3 = 0 ;
5970 PyObject * obj4 = 0 ;
5971 char * kwnames[] = {
5972 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
5973 };
5974
5975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
5976 if (obj0) {
5977 {
5978 arg1 = wxString_in_helper(obj0);
5979 if (arg1 == NULL) SWIG_fail;
5980 temp1 = true;
5981 }
5982 }
5983 if (obj1) {
5984 {
5985 arg2 = wxString_in_helper(obj1);
5986 if (arg2 == NULL) SWIG_fail;
5987 temp2 = true;
5988 }
5989 }
5990 if (obj2) {
5991 ecode3 = SWIG_AsVal_long(obj2, &val3);
5992 if (!SWIG_IsOK(ecode3)) {
5993 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DirSelector" "', expected argument " "3"" of type '" "long""'");
5994 }
5995 arg3 = static_cast< long >(val3);
5996 }
5997 if (obj3) {
5998 {
5999 arg4 = &temp4;
6000 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
6001 }
6002 }
6003 if (obj4) {
6004 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6005 if (!SWIG_IsOK(res5)) {
6006 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DirSelector" "', expected argument " "5"" of type '" "wxWindow *""'");
6007 }
6008 arg5 = reinterpret_cast< wxWindow * >(argp5);
6009 }
6010 {
6011 if (!wxPyCheckForApp()) SWIG_fail;
6012 PyThreadState* __tstate = wxPyBeginAllowThreads();
6013 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
6014 wxPyEndAllowThreads(__tstate);
6015 if (PyErr_Occurred()) SWIG_fail;
6016 }
6017 {
6018 #if wxUSE_UNICODE
6019 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6020 #else
6021 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6022 #endif
6023 }
6024 {
6025 if (temp1)
6026 delete arg1;
6027 }
6028 {
6029 if (temp2)
6030 delete arg2;
6031 }
6032 return resultobj;
6033 fail:
6034 {
6035 if (temp1)
6036 delete arg1;
6037 }
6038 {
6039 if (temp2)
6040 delete arg2;
6041 }
6042 return NULL;
6043 }
6044
6045
6046 SWIGINTERN PyObject *_wrap_GetTextFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6047 PyObject *resultobj = 0;
6048 wxString *arg1 = 0 ;
6049 wxString const &arg2_defvalue = wxPyEmptyString ;
6050 wxString *arg2 = (wxString *) &arg2_defvalue ;
6051 wxString const &arg3_defvalue = wxPyEmptyString ;
6052 wxString *arg3 = (wxString *) &arg3_defvalue ;
6053 wxWindow *arg4 = (wxWindow *) NULL ;
6054 int arg5 = (int) -1 ;
6055 int arg6 = (int) -1 ;
6056 bool arg7 = (bool) true ;
6057 wxString result;
6058 bool temp1 = false ;
6059 bool temp2 = false ;
6060 bool temp3 = false ;
6061 void *argp4 = 0 ;
6062 int res4 = 0 ;
6063 int val5 ;
6064 int ecode5 = 0 ;
6065 int val6 ;
6066 int ecode6 = 0 ;
6067 bool val7 ;
6068 int ecode7 = 0 ;
6069 PyObject * obj0 = 0 ;
6070 PyObject * obj1 = 0 ;
6071 PyObject * obj2 = 0 ;
6072 PyObject * obj3 = 0 ;
6073 PyObject * obj4 = 0 ;
6074 PyObject * obj5 = 0 ;
6075 PyObject * obj6 = 0 ;
6076 char * kwnames[] = {
6077 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
6078 };
6079
6080 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
6081 {
6082 arg1 = wxString_in_helper(obj0);
6083 if (arg1 == NULL) SWIG_fail;
6084 temp1 = true;
6085 }
6086 if (obj1) {
6087 {
6088 arg2 = wxString_in_helper(obj1);
6089 if (arg2 == NULL) SWIG_fail;
6090 temp2 = true;
6091 }
6092 }
6093 if (obj2) {
6094 {
6095 arg3 = wxString_in_helper(obj2);
6096 if (arg3 == NULL) SWIG_fail;
6097 temp3 = true;
6098 }
6099 }
6100 if (obj3) {
6101 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6102 if (!SWIG_IsOK(res4)) {
6103 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetTextFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6104 }
6105 arg4 = reinterpret_cast< wxWindow * >(argp4);
6106 }
6107 if (obj4) {
6108 ecode5 = SWIG_AsVal_int(obj4, &val5);
6109 if (!SWIG_IsOK(ecode5)) {
6110 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetTextFromUser" "', expected argument " "5"" of type '" "int""'");
6111 }
6112 arg5 = static_cast< int >(val5);
6113 }
6114 if (obj5) {
6115 ecode6 = SWIG_AsVal_int(obj5, &val6);
6116 if (!SWIG_IsOK(ecode6)) {
6117 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetTextFromUser" "', expected argument " "6"" of type '" "int""'");
6118 }
6119 arg6 = static_cast< int >(val6);
6120 }
6121 if (obj6) {
6122 ecode7 = SWIG_AsVal_bool(obj6, &val7);
6123 if (!SWIG_IsOK(ecode7)) {
6124 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetTextFromUser" "', expected argument " "7"" of type '" "bool""'");
6125 }
6126 arg7 = static_cast< bool >(val7);
6127 }
6128 {
6129 if (!wxPyCheckForApp()) SWIG_fail;
6130 PyThreadState* __tstate = wxPyBeginAllowThreads();
6131 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
6132 wxPyEndAllowThreads(__tstate);
6133 if (PyErr_Occurred()) SWIG_fail;
6134 }
6135 {
6136 #if wxUSE_UNICODE
6137 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6138 #else
6139 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6140 #endif
6141 }
6142 {
6143 if (temp1)
6144 delete arg1;
6145 }
6146 {
6147 if (temp2)
6148 delete arg2;
6149 }
6150 {
6151 if (temp3)
6152 delete arg3;
6153 }
6154 return resultobj;
6155 fail:
6156 {
6157 if (temp1)
6158 delete arg1;
6159 }
6160 {
6161 if (temp2)
6162 delete arg2;
6163 }
6164 {
6165 if (temp3)
6166 delete arg3;
6167 }
6168 return NULL;
6169 }
6170
6171
6172 SWIGINTERN PyObject *_wrap_GetPasswordFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6173 PyObject *resultobj = 0;
6174 wxString *arg1 = 0 ;
6175 wxString const &arg2_defvalue = wxPyEmptyString ;
6176 wxString *arg2 = (wxString *) &arg2_defvalue ;
6177 wxString const &arg3_defvalue = wxPyEmptyString ;
6178 wxString *arg3 = (wxString *) &arg3_defvalue ;
6179 wxWindow *arg4 = (wxWindow *) NULL ;
6180 wxString result;
6181 bool temp1 = false ;
6182 bool temp2 = false ;
6183 bool temp3 = false ;
6184 void *argp4 = 0 ;
6185 int res4 = 0 ;
6186 PyObject * obj0 = 0 ;
6187 PyObject * obj1 = 0 ;
6188 PyObject * obj2 = 0 ;
6189 PyObject * obj3 = 0 ;
6190 char * kwnames[] = {
6191 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
6192 };
6193
6194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6195 {
6196 arg1 = wxString_in_helper(obj0);
6197 if (arg1 == NULL) SWIG_fail;
6198 temp1 = true;
6199 }
6200 if (obj1) {
6201 {
6202 arg2 = wxString_in_helper(obj1);
6203 if (arg2 == NULL) SWIG_fail;
6204 temp2 = true;
6205 }
6206 }
6207 if (obj2) {
6208 {
6209 arg3 = wxString_in_helper(obj2);
6210 if (arg3 == NULL) SWIG_fail;
6211 temp3 = true;
6212 }
6213 }
6214 if (obj3) {
6215 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6216 if (!SWIG_IsOK(res4)) {
6217 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetPasswordFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6218 }
6219 arg4 = reinterpret_cast< wxWindow * >(argp4);
6220 }
6221 {
6222 if (!wxPyCheckForApp()) SWIG_fail;
6223 PyThreadState* __tstate = wxPyBeginAllowThreads();
6224 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
6225 wxPyEndAllowThreads(__tstate);
6226 if (PyErr_Occurred()) SWIG_fail;
6227 }
6228 {
6229 #if wxUSE_UNICODE
6230 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6231 #else
6232 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6233 #endif
6234 }
6235 {
6236 if (temp1)
6237 delete arg1;
6238 }
6239 {
6240 if (temp2)
6241 delete arg2;
6242 }
6243 {
6244 if (temp3)
6245 delete arg3;
6246 }
6247 return resultobj;
6248 fail:
6249 {
6250 if (temp1)
6251 delete arg1;
6252 }
6253 {
6254 if (temp2)
6255 delete arg2;
6256 }
6257 {
6258 if (temp3)
6259 delete arg3;
6260 }
6261 return NULL;
6262 }
6263
6264
6265 SWIGINTERN PyObject *_wrap_GetSingleChoice(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6266 PyObject *resultobj = 0;
6267 wxString *arg1 = 0 ;
6268 wxString *arg2 = 0 ;
6269 int arg3 ;
6270 wxString *arg4 = (wxString *) 0 ;
6271 wxWindow *arg5 = (wxWindow *) NULL ;
6272 int arg6 = (int) -1 ;
6273 int arg7 = (int) -1 ;
6274 bool arg8 = (bool) true ;
6275 int arg9 = (int) 150 ;
6276 int arg10 = (int) 200 ;
6277 wxString result;
6278 bool temp1 = false ;
6279 bool temp2 = false ;
6280 void *argp5 = 0 ;
6281 int res5 = 0 ;
6282 int val6 ;
6283 int ecode6 = 0 ;
6284 int val7 ;
6285 int ecode7 = 0 ;
6286 bool val8 ;
6287 int ecode8 = 0 ;
6288 int val9 ;
6289 int ecode9 = 0 ;
6290 int val10 ;
6291 int ecode10 = 0 ;
6292 PyObject * obj0 = 0 ;
6293 PyObject * obj1 = 0 ;
6294 PyObject * obj2 = 0 ;
6295 PyObject * obj3 = 0 ;
6296 PyObject * obj4 = 0 ;
6297 PyObject * obj5 = 0 ;
6298 PyObject * obj6 = 0 ;
6299 PyObject * obj7 = 0 ;
6300 PyObject * obj8 = 0 ;
6301 char * kwnames[] = {
6302 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6303 };
6304
6305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6306 {
6307 arg1 = wxString_in_helper(obj0);
6308 if (arg1 == NULL) SWIG_fail;
6309 temp1 = true;
6310 }
6311 {
6312 arg2 = wxString_in_helper(obj1);
6313 if (arg2 == NULL) SWIG_fail;
6314 temp2 = true;
6315 }
6316 {
6317 arg3 = PyList_Size(obj2);
6318 arg4 = wxString_LIST_helper(obj2);
6319 if (arg4 == NULL) SWIG_fail;
6320 }
6321 if (obj3) {
6322 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6323 if (!SWIG_IsOK(res5)) {
6324 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoice" "', expected argument " "5"" of type '" "wxWindow *""'");
6325 }
6326 arg5 = reinterpret_cast< wxWindow * >(argp5);
6327 }
6328 if (obj4) {
6329 ecode6 = SWIG_AsVal_int(obj4, &val6);
6330 if (!SWIG_IsOK(ecode6)) {
6331 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoice" "', expected argument " "6"" of type '" "int""'");
6332 }
6333 arg6 = static_cast< int >(val6);
6334 }
6335 if (obj5) {
6336 ecode7 = SWIG_AsVal_int(obj5, &val7);
6337 if (!SWIG_IsOK(ecode7)) {
6338 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoice" "', expected argument " "7"" of type '" "int""'");
6339 }
6340 arg7 = static_cast< int >(val7);
6341 }
6342 if (obj6) {
6343 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6344 if (!SWIG_IsOK(ecode8)) {
6345 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoice" "', expected argument " "8"" of type '" "bool""'");
6346 }
6347 arg8 = static_cast< bool >(val8);
6348 }
6349 if (obj7) {
6350 ecode9 = SWIG_AsVal_int(obj7, &val9);
6351 if (!SWIG_IsOK(ecode9)) {
6352 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoice" "', expected argument " "9"" of type '" "int""'");
6353 }
6354 arg9 = static_cast< int >(val9);
6355 }
6356 if (obj8) {
6357 ecode10 = SWIG_AsVal_int(obj8, &val10);
6358 if (!SWIG_IsOK(ecode10)) {
6359 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoice" "', expected argument " "10"" of type '" "int""'");
6360 }
6361 arg10 = static_cast< int >(val10);
6362 }
6363 {
6364 if (!wxPyCheckForApp()) SWIG_fail;
6365 PyThreadState* __tstate = wxPyBeginAllowThreads();
6366 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6367 wxPyEndAllowThreads(__tstate);
6368 if (PyErr_Occurred()) SWIG_fail;
6369 }
6370 {
6371 #if wxUSE_UNICODE
6372 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6373 #else
6374 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6375 #endif
6376 }
6377 {
6378 if (temp1)
6379 delete arg1;
6380 }
6381 {
6382 if (temp2)
6383 delete arg2;
6384 }
6385 {
6386 if (arg4) delete [] arg4;
6387 }
6388 return resultobj;
6389 fail:
6390 {
6391 if (temp1)
6392 delete arg1;
6393 }
6394 {
6395 if (temp2)
6396 delete arg2;
6397 }
6398 {
6399 if (arg4) delete [] arg4;
6400 }
6401 return NULL;
6402 }
6403
6404
6405 SWIGINTERN PyObject *_wrap_GetSingleChoiceIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6406 PyObject *resultobj = 0;
6407 wxString *arg1 = 0 ;
6408 wxString *arg2 = 0 ;
6409 int arg3 ;
6410 wxString *arg4 = (wxString *) 0 ;
6411 wxWindow *arg5 = (wxWindow *) NULL ;
6412 int arg6 = (int) -1 ;
6413 int arg7 = (int) -1 ;
6414 bool arg8 = (bool) true ;
6415 int arg9 = (int) 150 ;
6416 int arg10 = (int) 200 ;
6417 int result;
6418 bool temp1 = false ;
6419 bool temp2 = false ;
6420 void *argp5 = 0 ;
6421 int res5 = 0 ;
6422 int val6 ;
6423 int ecode6 = 0 ;
6424 int val7 ;
6425 int ecode7 = 0 ;
6426 bool val8 ;
6427 int ecode8 = 0 ;
6428 int val9 ;
6429 int ecode9 = 0 ;
6430 int val10 ;
6431 int ecode10 = 0 ;
6432 PyObject * obj0 = 0 ;
6433 PyObject * obj1 = 0 ;
6434 PyObject * obj2 = 0 ;
6435 PyObject * obj3 = 0 ;
6436 PyObject * obj4 = 0 ;
6437 PyObject * obj5 = 0 ;
6438 PyObject * obj6 = 0 ;
6439 PyObject * obj7 = 0 ;
6440 PyObject * obj8 = 0 ;
6441 char * kwnames[] = {
6442 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6443 };
6444
6445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6446 {
6447 arg1 = wxString_in_helper(obj0);
6448 if (arg1 == NULL) SWIG_fail;
6449 temp1 = true;
6450 }
6451 {
6452 arg2 = wxString_in_helper(obj1);
6453 if (arg2 == NULL) SWIG_fail;
6454 temp2 = true;
6455 }
6456 {
6457 arg3 = PyList_Size(obj2);
6458 arg4 = wxString_LIST_helper(obj2);
6459 if (arg4 == NULL) SWIG_fail;
6460 }
6461 if (obj3) {
6462 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6463 if (!SWIG_IsOK(res5)) {
6464 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoiceIndex" "', expected argument " "5"" of type '" "wxWindow *""'");
6465 }
6466 arg5 = reinterpret_cast< wxWindow * >(argp5);
6467 }
6468 if (obj4) {
6469 ecode6 = SWIG_AsVal_int(obj4, &val6);
6470 if (!SWIG_IsOK(ecode6)) {
6471 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoiceIndex" "', expected argument " "6"" of type '" "int""'");
6472 }
6473 arg6 = static_cast< int >(val6);
6474 }
6475 if (obj5) {
6476 ecode7 = SWIG_AsVal_int(obj5, &val7);
6477 if (!SWIG_IsOK(ecode7)) {
6478 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoiceIndex" "', expected argument " "7"" of type '" "int""'");
6479 }
6480 arg7 = static_cast< int >(val7);
6481 }
6482 if (obj6) {
6483 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6484 if (!SWIG_IsOK(ecode8)) {
6485 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoiceIndex" "', expected argument " "8"" of type '" "bool""'");
6486 }
6487 arg8 = static_cast< bool >(val8);
6488 }
6489 if (obj7) {
6490 ecode9 = SWIG_AsVal_int(obj7, &val9);
6491 if (!SWIG_IsOK(ecode9)) {
6492 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoiceIndex" "', expected argument " "9"" of type '" "int""'");
6493 }
6494 arg9 = static_cast< int >(val9);
6495 }
6496 if (obj8) {
6497 ecode10 = SWIG_AsVal_int(obj8, &val10);
6498 if (!SWIG_IsOK(ecode10)) {
6499 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoiceIndex" "', expected argument " "10"" of type '" "int""'");
6500 }
6501 arg10 = static_cast< int >(val10);
6502 }
6503 {
6504 if (!wxPyCheckForApp()) SWIG_fail;
6505 PyThreadState* __tstate = wxPyBeginAllowThreads();
6506 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6507 wxPyEndAllowThreads(__tstate);
6508 if (PyErr_Occurred()) SWIG_fail;
6509 }
6510 resultobj = SWIG_From_int(static_cast< int >(result));
6511 {
6512 if (temp1)
6513 delete arg1;
6514 }
6515 {
6516 if (temp2)
6517 delete arg2;
6518 }
6519 {
6520 if (arg4) delete [] arg4;
6521 }
6522 return resultobj;
6523 fail:
6524 {
6525 if (temp1)
6526 delete arg1;
6527 }
6528 {
6529 if (temp2)
6530 delete arg2;
6531 }
6532 {
6533 if (arg4) delete [] arg4;
6534 }
6535 return NULL;
6536 }
6537
6538
6539 SWIGINTERN PyObject *_wrap_MessageBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6540 PyObject *resultobj = 0;
6541 wxString *arg1 = 0 ;
6542 wxString const &arg2_defvalue = wxPyEmptyString ;
6543 wxString *arg2 = (wxString *) &arg2_defvalue ;
6544 int arg3 = (int) wxOK|wxCENTRE ;
6545 wxWindow *arg4 = (wxWindow *) NULL ;
6546 int arg5 = (int) -1 ;
6547 int arg6 = (int) -1 ;
6548 int result;
6549 bool temp1 = false ;
6550 bool temp2 = false ;
6551 int val3 ;
6552 int ecode3 = 0 ;
6553 void *argp4 = 0 ;
6554 int res4 = 0 ;
6555 int val5 ;
6556 int ecode5 = 0 ;
6557 int val6 ;
6558 int ecode6 = 0 ;
6559 PyObject * obj0 = 0 ;
6560 PyObject * obj1 = 0 ;
6561 PyObject * obj2 = 0 ;
6562 PyObject * obj3 = 0 ;
6563 PyObject * obj4 = 0 ;
6564 PyObject * obj5 = 0 ;
6565 char * kwnames[] = {
6566 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
6567 };
6568
6569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
6570 {
6571 arg1 = wxString_in_helper(obj0);
6572 if (arg1 == NULL) SWIG_fail;
6573 temp1 = true;
6574 }
6575 if (obj1) {
6576 {
6577 arg2 = wxString_in_helper(obj1);
6578 if (arg2 == NULL) SWIG_fail;
6579 temp2 = true;
6580 }
6581 }
6582 if (obj2) {
6583 ecode3 = SWIG_AsVal_int(obj2, &val3);
6584 if (!SWIG_IsOK(ecode3)) {
6585 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MessageBox" "', expected argument " "3"" of type '" "int""'");
6586 }
6587 arg3 = static_cast< int >(val3);
6588 }
6589 if (obj3) {
6590 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6591 if (!SWIG_IsOK(res4)) {
6592 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MessageBox" "', expected argument " "4"" of type '" "wxWindow *""'");
6593 }
6594 arg4 = reinterpret_cast< wxWindow * >(argp4);
6595 }
6596 if (obj4) {
6597 ecode5 = SWIG_AsVal_int(obj4, &val5);
6598 if (!SWIG_IsOK(ecode5)) {
6599 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "MessageBox" "', expected argument " "5"" of type '" "int""'");
6600 }
6601 arg5 = static_cast< int >(val5);
6602 }
6603 if (obj5) {
6604 ecode6 = SWIG_AsVal_int(obj5, &val6);
6605 if (!SWIG_IsOK(ecode6)) {
6606 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "MessageBox" "', expected argument " "6"" of type '" "int""'");
6607 }
6608 arg6 = static_cast< int >(val6);
6609 }
6610 {
6611 if (!wxPyCheckForApp()) SWIG_fail;
6612 PyThreadState* __tstate = wxPyBeginAllowThreads();
6613 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
6614 wxPyEndAllowThreads(__tstate);
6615 if (PyErr_Occurred()) SWIG_fail;
6616 }
6617 resultobj = SWIG_From_int(static_cast< int >(result));
6618 {
6619 if (temp1)
6620 delete arg1;
6621 }
6622 {
6623 if (temp2)
6624 delete arg2;
6625 }
6626 return resultobj;
6627 fail:
6628 {
6629 if (temp1)
6630 delete arg1;
6631 }
6632 {
6633 if (temp2)
6634 delete arg2;
6635 }
6636 return NULL;
6637 }
6638
6639
6640 SWIGINTERN PyObject *_wrap_GetNumberFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6641 PyObject *resultobj = 0;
6642 wxString *arg1 = 0 ;
6643 wxString *arg2 = 0 ;
6644 wxString *arg3 = 0 ;
6645 long arg4 ;
6646 long arg5 = (long) 0 ;
6647 long arg6 = (long) 100 ;
6648 wxWindow *arg7 = (wxWindow *) NULL ;
6649 wxPoint const &arg8_defvalue = wxDefaultPosition ;
6650 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
6651 long result;
6652 bool temp1 = false ;
6653 bool temp2 = false ;
6654 bool temp3 = false ;
6655 long val4 ;
6656 int ecode4 = 0 ;
6657 long val5 ;
6658 int ecode5 = 0 ;
6659 long val6 ;
6660 int ecode6 = 0 ;
6661 void *argp7 = 0 ;
6662 int res7 = 0 ;
6663 wxPoint temp8 ;
6664 PyObject * obj0 = 0 ;
6665 PyObject * obj1 = 0 ;
6666 PyObject * obj2 = 0 ;
6667 PyObject * obj3 = 0 ;
6668 PyObject * obj4 = 0 ;
6669 PyObject * obj5 = 0 ;
6670 PyObject * obj6 = 0 ;
6671 PyObject * obj7 = 0 ;
6672 char * kwnames[] = {
6673 (char *) "message",(char *) "prompt",(char *) "caption",(char *) "value",(char *) "min",(char *) "max",(char *) "parent",(char *) "pos", NULL
6674 };
6675
6676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOOO:GetNumberFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
6677 {
6678 arg1 = wxString_in_helper(obj0);
6679 if (arg1 == NULL) SWIG_fail;
6680 temp1 = true;
6681 }
6682 {
6683 arg2 = wxString_in_helper(obj1);
6684 if (arg2 == NULL) SWIG_fail;
6685 temp2 = true;
6686 }
6687 {
6688 arg3 = wxString_in_helper(obj2);
6689 if (arg3 == NULL) SWIG_fail;
6690 temp3 = true;
6691 }
6692 ecode4 = SWIG_AsVal_long(obj3, &val4);
6693 if (!SWIG_IsOK(ecode4)) {
6694 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GetNumberFromUser" "', expected argument " "4"" of type '" "long""'");
6695 }
6696 arg4 = static_cast< long >(val4);
6697 if (obj4) {
6698 ecode5 = SWIG_AsVal_long(obj4, &val5);
6699 if (!SWIG_IsOK(ecode5)) {
6700 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetNumberFromUser" "', expected argument " "5"" of type '" "long""'");
6701 }
6702 arg5 = static_cast< long >(val5);
6703 }
6704 if (obj5) {
6705 ecode6 = SWIG_AsVal_long(obj5, &val6);
6706 if (!SWIG_IsOK(ecode6)) {
6707 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetNumberFromUser" "', expected argument " "6"" of type '" "long""'");
6708 }
6709 arg6 = static_cast< long >(val6);
6710 }
6711 if (obj6) {
6712 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_wxWindow, 0 | 0 );
6713 if (!SWIG_IsOK(res7)) {
6714 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "GetNumberFromUser" "', expected argument " "7"" of type '" "wxWindow *""'");
6715 }
6716 arg7 = reinterpret_cast< wxWindow * >(argp7);
6717 }
6718 if (obj7) {
6719 {
6720 arg8 = &temp8;
6721 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
6722 }
6723 }
6724 {
6725 if (!wxPyCheckForApp()) SWIG_fail;
6726 PyThreadState* __tstate = wxPyBeginAllowThreads();
6727 result = (long)wxGetNumberFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7,(wxPoint const &)*arg8);
6728 wxPyEndAllowThreads(__tstate);
6729 if (PyErr_Occurred()) SWIG_fail;
6730 }
6731 resultobj = SWIG_From_long(static_cast< long >(result));
6732 {
6733 if (temp1)
6734 delete arg1;
6735 }
6736 {
6737 if (temp2)
6738 delete arg2;
6739 }
6740 {
6741 if (temp3)
6742 delete arg3;
6743 }
6744 return resultobj;
6745 fail:
6746 {
6747 if (temp1)
6748 delete arg1;
6749 }
6750 {
6751 if (temp2)
6752 delete arg2;
6753 }
6754 {
6755 if (temp3)
6756 delete arg3;
6757 }
6758 return NULL;
6759 }
6760
6761
6762 SWIGINTERN PyObject *_wrap_ColourDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6763 PyObject *resultobj = 0;
6764 bool result;
6765
6766 if (!SWIG_Python_UnpackTuple(args,"ColourDisplay",0,0,0)) SWIG_fail;
6767 {
6768 if (!wxPyCheckForApp()) SWIG_fail;
6769 PyThreadState* __tstate = wxPyBeginAllowThreads();
6770 result = (bool)wxColourDisplay();
6771 wxPyEndAllowThreads(__tstate);
6772 if (PyErr_Occurred()) SWIG_fail;
6773 }
6774 {
6775 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6776 }
6777 return resultobj;
6778 fail:
6779 return NULL;
6780 }
6781
6782
6783 SWIGINTERN PyObject *_wrap_DisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6784 PyObject *resultobj = 0;
6785 int result;
6786
6787 if (!SWIG_Python_UnpackTuple(args,"DisplayDepth",0,0,0)) SWIG_fail;
6788 {
6789 if (!wxPyCheckForApp()) SWIG_fail;
6790 PyThreadState* __tstate = wxPyBeginAllowThreads();
6791 result = (int)wxDisplayDepth();
6792 wxPyEndAllowThreads(__tstate);
6793 if (PyErr_Occurred()) SWIG_fail;
6794 }
6795 resultobj = SWIG_From_int(static_cast< int >(result));
6796 return resultobj;
6797 fail:
6798 return NULL;
6799 }
6800
6801
6802 SWIGINTERN PyObject *_wrap_GetDisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6803 PyObject *resultobj = 0;
6804 int result;
6805
6806 if (!SWIG_Python_UnpackTuple(args,"GetDisplayDepth",0,0,0)) SWIG_fail;
6807 {
6808 if (!wxPyCheckForApp()) SWIG_fail;
6809 PyThreadState* __tstate = wxPyBeginAllowThreads();
6810 result = (int)wxGetDisplayDepth();
6811 wxPyEndAllowThreads(__tstate);
6812 if (PyErr_Occurred()) SWIG_fail;
6813 }
6814 resultobj = SWIG_From_int(static_cast< int >(result));
6815 return resultobj;
6816 fail:
6817 return NULL;
6818 }
6819
6820
6821 SWIGINTERN PyObject *_wrap_DisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6822 PyObject *resultobj = 0;
6823 int *arg1 = (int *) 0 ;
6824 int *arg2 = (int *) 0 ;
6825 int temp1 ;
6826 int res1 = SWIG_TMPOBJ ;
6827 int temp2 ;
6828 int res2 = SWIG_TMPOBJ ;
6829
6830 arg1 = &temp1;
6831 arg2 = &temp2;
6832 if (!SWIG_Python_UnpackTuple(args,"DisplaySize",0,0,0)) SWIG_fail;
6833 {
6834 if (!wxPyCheckForApp()) SWIG_fail;
6835 PyThreadState* __tstate = wxPyBeginAllowThreads();
6836 wxDisplaySize(arg1,arg2);
6837 wxPyEndAllowThreads(__tstate);
6838 if (PyErr_Occurred()) SWIG_fail;
6839 }
6840 resultobj = SWIG_Py_Void();
6841 if (SWIG_IsTmpObj(res1)) {
6842 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6843 } else {
6844 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6845 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6846 }
6847 if (SWIG_IsTmpObj(res2)) {
6848 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6849 } else {
6850 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6851 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6852 }
6853 return resultobj;
6854 fail:
6855 return NULL;
6856 }
6857
6858
6859 SWIGINTERN PyObject *_wrap_GetDisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6860 PyObject *resultobj = 0;
6861 wxSize result;
6862
6863 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySize",0,0,0)) SWIG_fail;
6864 {
6865 if (!wxPyCheckForApp()) SWIG_fail;
6866 PyThreadState* __tstate = wxPyBeginAllowThreads();
6867 result = wxGetDisplaySize();
6868 wxPyEndAllowThreads(__tstate);
6869 if (PyErr_Occurred()) SWIG_fail;
6870 }
6871 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6872 return resultobj;
6873 fail:
6874 return NULL;
6875 }
6876
6877
6878 SWIGINTERN PyObject *_wrap_DisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6879 PyObject *resultobj = 0;
6880 int *arg1 = (int *) 0 ;
6881 int *arg2 = (int *) 0 ;
6882 int temp1 ;
6883 int res1 = SWIG_TMPOBJ ;
6884 int temp2 ;
6885 int res2 = SWIG_TMPOBJ ;
6886
6887 arg1 = &temp1;
6888 arg2 = &temp2;
6889 if (!SWIG_Python_UnpackTuple(args,"DisplaySizeMM",0,0,0)) SWIG_fail;
6890 {
6891 if (!wxPyCheckForApp()) SWIG_fail;
6892 PyThreadState* __tstate = wxPyBeginAllowThreads();
6893 wxDisplaySizeMM(arg1,arg2);
6894 wxPyEndAllowThreads(__tstate);
6895 if (PyErr_Occurred()) SWIG_fail;
6896 }
6897 resultobj = SWIG_Py_Void();
6898 if (SWIG_IsTmpObj(res1)) {
6899 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6900 } else {
6901 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6902 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6903 }
6904 if (SWIG_IsTmpObj(res2)) {
6905 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6906 } else {
6907 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6908 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6909 }
6910 return resultobj;
6911 fail:
6912 return NULL;
6913 }
6914
6915
6916 SWIGINTERN PyObject *_wrap_GetDisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6917 PyObject *resultobj = 0;
6918 wxSize result;
6919
6920 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySizeMM",0,0,0)) SWIG_fail;
6921 {
6922 if (!wxPyCheckForApp()) SWIG_fail;
6923 PyThreadState* __tstate = wxPyBeginAllowThreads();
6924 result = wxGetDisplaySizeMM();
6925 wxPyEndAllowThreads(__tstate);
6926 if (PyErr_Occurred()) SWIG_fail;
6927 }
6928 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6929 return resultobj;
6930 fail:
6931 return NULL;
6932 }
6933
6934
6935 SWIGINTERN PyObject *_wrap_ClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6936 PyObject *resultobj = 0;
6937 int *arg1 = (int *) 0 ;
6938 int *arg2 = (int *) 0 ;
6939 int *arg3 = (int *) 0 ;
6940 int *arg4 = (int *) 0 ;
6941 int temp1 ;
6942 int res1 = SWIG_TMPOBJ ;
6943 int temp2 ;
6944 int res2 = SWIG_TMPOBJ ;
6945 int temp3 ;
6946 int res3 = SWIG_TMPOBJ ;
6947 int temp4 ;
6948 int res4 = SWIG_TMPOBJ ;
6949
6950 arg1 = &temp1;
6951 arg2 = &temp2;
6952 arg3 = &temp3;
6953 arg4 = &temp4;
6954 if (!SWIG_Python_UnpackTuple(args,"ClientDisplayRect",0,0,0)) SWIG_fail;
6955 {
6956 if (!wxPyCheckForApp()) SWIG_fail;
6957 PyThreadState* __tstate = wxPyBeginAllowThreads();
6958 wxClientDisplayRect(arg1,arg2,arg3,arg4);
6959 wxPyEndAllowThreads(__tstate);
6960 if (PyErr_Occurred()) SWIG_fail;
6961 }
6962 resultobj = SWIG_Py_Void();
6963 if (SWIG_IsTmpObj(res1)) {
6964 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6965 } else {
6966 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6967 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6968 }
6969 if (SWIG_IsTmpObj(res2)) {
6970 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6971 } else {
6972 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6973 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6974 }
6975 if (SWIG_IsTmpObj(res3)) {
6976 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6977 } else {
6978 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6979 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6980 }
6981 if (SWIG_IsTmpObj(res4)) {
6982 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
6983 } else {
6984 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6985 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
6986 }
6987 return resultobj;
6988 fail:
6989 return NULL;
6990 }
6991
6992
6993 SWIGINTERN PyObject *_wrap_GetClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6994 PyObject *resultobj = 0;
6995 wxRect result;
6996
6997 if (!SWIG_Python_UnpackTuple(args,"GetClientDisplayRect",0,0,0)) SWIG_fail;
6998 {
6999 if (!wxPyCheckForApp()) SWIG_fail;
7000 PyThreadState* __tstate = wxPyBeginAllowThreads();
7001 result = wxGetClientDisplayRect();
7002 wxPyEndAllowThreads(__tstate);
7003 if (PyErr_Occurred()) SWIG_fail;
7004 }
7005 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7006 return resultobj;
7007 fail:
7008 return NULL;
7009 }
7010
7011
7012 SWIGINTERN PyObject *_wrap_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7013 PyObject *resultobj = 0;
7014 wxCursor *arg1 = 0 ;
7015 void *argp1 = 0 ;
7016 int res1 = 0 ;
7017 PyObject * obj0 = 0 ;
7018 char * kwnames[] = {
7019 (char *) "cursor", NULL
7020 };
7021
7022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) SWIG_fail;
7023 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxCursor, 0 );
7024 if (!SWIG_IsOK(res1)) {
7025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
7026 }
7027 if (!argp1) {
7028 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
7029 }
7030 arg1 = reinterpret_cast< wxCursor * >(argp1);
7031 {
7032 if (!wxPyCheckForApp()) SWIG_fail;
7033 PyThreadState* __tstate = wxPyBeginAllowThreads();
7034 wxSetCursor(*arg1);
7035 wxPyEndAllowThreads(__tstate);
7036 if (PyErr_Occurred()) SWIG_fail;
7037 }
7038 resultobj = SWIG_Py_Void();
7039 return resultobj;
7040 fail:
7041 return NULL;
7042 }
7043
7044
7045 SWIGINTERN PyObject *_wrap_GetXDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7046 PyObject *resultobj = 0;
7047 void *result = 0 ;
7048
7049 if (!SWIG_Python_UnpackTuple(args,"GetXDisplay",0,0,0)) SWIG_fail;
7050 {
7051 if (!wxPyCheckForApp()) SWIG_fail;
7052 PyThreadState* __tstate = wxPyBeginAllowThreads();
7053 result = (void *)wxGetXDisplay();
7054 wxPyEndAllowThreads(__tstate);
7055 if (PyErr_Occurred()) SWIG_fail;
7056 }
7057 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
7058 return resultobj;
7059 fail:
7060 return NULL;
7061 }
7062
7063
7064 SWIGINTERN PyObject *_wrap_BeginBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7065 PyObject *resultobj = 0;
7066 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
7067 void *argp1 = 0 ;
7068 int res1 = 0 ;
7069 PyObject * obj0 = 0 ;
7070 char * kwnames[] = {
7071 (char *) "cursor", NULL
7072 };
7073
7074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) SWIG_fail;
7075 if (obj0) {
7076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
7077 if (!SWIG_IsOK(res1)) {
7078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeginBusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
7079 }
7080 arg1 = reinterpret_cast< wxCursor * >(argp1);
7081 }
7082 {
7083 if (!wxPyCheckForApp()) SWIG_fail;
7084 PyThreadState* __tstate = wxPyBeginAllowThreads();
7085 wxBeginBusyCursor(arg1);
7086 wxPyEndAllowThreads(__tstate);
7087 if (PyErr_Occurred()) SWIG_fail;
7088 }
7089 resultobj = SWIG_Py_Void();
7090 return resultobj;
7091 fail:
7092 return NULL;
7093 }
7094
7095
7096 SWIGINTERN PyObject *_wrap_GetMousePosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7097 PyObject *resultobj = 0;
7098 wxPoint result;
7099
7100 if (!SWIG_Python_UnpackTuple(args,"GetMousePosition",0,0,0)) SWIG_fail;
7101 {
7102 if (!wxPyCheckForApp()) SWIG_fail;
7103 PyThreadState* __tstate = wxPyBeginAllowThreads();
7104 result = wxGetMousePosition();
7105 wxPyEndAllowThreads(__tstate);
7106 if (PyErr_Occurred()) SWIG_fail;
7107 }
7108 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
7109 return resultobj;
7110 fail:
7111 return NULL;
7112 }
7113
7114
7115 SWIGINTERN PyObject *_wrap_FindWindowAtPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7116 PyObject *resultobj = 0;
7117 wxWindow *result = 0 ;
7118
7119 if (!SWIG_Python_UnpackTuple(args,"FindWindowAtPointer",0,0,0)) SWIG_fail;
7120 {
7121 if (!wxPyCheckForApp()) SWIG_fail;
7122 PyThreadState* __tstate = wxPyBeginAllowThreads();
7123 result = (wxWindow *)FindWindowAtPointer();
7124 wxPyEndAllowThreads(__tstate);
7125 if (PyErr_Occurred()) SWIG_fail;
7126 }
7127 {
7128 resultobj = wxPyMake_wxObject(result, 0);
7129 }
7130 return resultobj;
7131 fail:
7132 return NULL;
7133 }
7134
7135
7136 SWIGINTERN PyObject *_wrap_GetActiveWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7137 PyObject *resultobj = 0;
7138 wxWindow *result = 0 ;
7139
7140 if (!SWIG_Python_UnpackTuple(args,"GetActiveWindow",0,0,0)) SWIG_fail;
7141 {
7142 if (!wxPyCheckForApp()) SWIG_fail;
7143 PyThreadState* __tstate = wxPyBeginAllowThreads();
7144 result = (wxWindow *)wxGetActiveWindow();
7145 wxPyEndAllowThreads(__tstate);
7146 if (PyErr_Occurred()) SWIG_fail;
7147 }
7148 {
7149 resultobj = wxPyMake_wxObject(result, 0);
7150 }
7151 return resultobj;
7152 fail:
7153 return NULL;
7154 }
7155
7156
7157 SWIGINTERN PyObject *_wrap_GenericFindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7158 PyObject *resultobj = 0;
7159 wxPoint *arg1 = 0 ;
7160 wxWindow *result = 0 ;
7161 wxPoint temp1 ;
7162 PyObject * obj0 = 0 ;
7163 char * kwnames[] = {
7164 (char *) "pt", NULL
7165 };
7166
7167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
7168 {
7169 arg1 = &temp1;
7170 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
7171 }
7172 {
7173 if (!wxPyCheckForApp()) SWIG_fail;
7174 PyThreadState* __tstate = wxPyBeginAllowThreads();
7175 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
7176 wxPyEndAllowThreads(__tstate);
7177 if (PyErr_Occurred()) SWIG_fail;
7178 }
7179 {
7180 resultobj = wxPyMake_wxObject(result, 0);
7181 }
7182 return resultobj;
7183 fail:
7184 return NULL;
7185 }
7186
7187
7188 SWIGINTERN PyObject *_wrap_FindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7189 PyObject *resultobj = 0;
7190 wxPoint *arg1 = 0 ;
7191 wxWindow *result = 0 ;
7192 wxPoint temp1 ;
7193 PyObject * obj0 = 0 ;
7194 char * kwnames[] = {
7195 (char *) "pt", NULL
7196 };
7197
7198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
7199 {
7200 arg1 = &temp1;
7201 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
7202 }
7203 {
7204 if (!wxPyCheckForApp()) SWIG_fail;
7205 PyThreadState* __tstate = wxPyBeginAllowThreads();
7206 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
7207 wxPyEndAllowThreads(__tstate);
7208 if (PyErr_Occurred()) SWIG_fail;
7209 }
7210 {
7211 resultobj = wxPyMake_wxObject(result, 0);
7212 }
7213 return resultobj;
7214 fail:
7215 return NULL;
7216 }
7217
7218
7219 SWIGINTERN PyObject *_wrap_GetTopLevelParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7220 PyObject *resultobj = 0;
7221 wxWindow *arg1 = (wxWindow *) 0 ;
7222 wxWindow *result = 0 ;
7223 void *argp1 = 0 ;
7224 int res1 = 0 ;
7225 PyObject * obj0 = 0 ;
7226 char * kwnames[] = {
7227 (char *) "win", NULL
7228 };
7229
7230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) SWIG_fail;
7231 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
7232 if (!SWIG_IsOK(res1)) {
7233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetTopLevelParent" "', expected argument " "1"" of type '" "wxWindow *""'");
7234 }
7235 arg1 = reinterpret_cast< wxWindow * >(argp1);
7236 {
7237 if (!wxPyCheckForApp()) SWIG_fail;
7238 PyThreadState* __tstate = wxPyBeginAllowThreads();
7239 result = (wxWindow *)wxGetTopLevelParent(arg1);
7240 wxPyEndAllowThreads(__tstate);
7241 if (PyErr_Occurred()) SWIG_fail;
7242 }
7243 {
7244 resultobj = wxPyMake_wxObject(result, 0);
7245 }
7246 return resultobj;
7247 fail:
7248 return NULL;
7249 }
7250
7251
7252 SWIGINTERN PyObject *_wrap_LaunchDefaultBrowser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7253 PyObject *resultobj = 0;
7254 wxString *arg1 = 0 ;
7255 bool result;
7256 bool temp1 = false ;
7257 PyObject * obj0 = 0 ;
7258 char * kwnames[] = {
7259 (char *) "url", NULL
7260 };
7261
7262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LaunchDefaultBrowser",kwnames,&obj0)) SWIG_fail;
7263 {
7264 arg1 = wxString_in_helper(obj0);
7265 if (arg1 == NULL) SWIG_fail;
7266 temp1 = true;
7267 }
7268 {
7269 PyThreadState* __tstate = wxPyBeginAllowThreads();
7270 result = (bool)wxLaunchDefaultBrowser((wxString const &)*arg1);
7271 wxPyEndAllowThreads(__tstate);
7272 if (PyErr_Occurred()) SWIG_fail;
7273 }
7274 {
7275 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7276 }
7277 {
7278 if (temp1)
7279 delete arg1;
7280 }
7281 return resultobj;
7282 fail:
7283 {
7284 if (temp1)
7285 delete arg1;
7286 }
7287 return NULL;
7288 }
7289
7290
7291 SWIGINTERN PyObject *_wrap_GetKeyState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7292 PyObject *resultobj = 0;
7293 wxKeyCode arg1 ;
7294 bool result;
7295 int val1 ;
7296 int ecode1 = 0 ;
7297 PyObject * obj0 = 0 ;
7298 char * kwnames[] = {
7299 (char *) "key", NULL
7300 };
7301
7302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) SWIG_fail;
7303 ecode1 = SWIG_AsVal_int(obj0, &val1);
7304 if (!SWIG_IsOK(ecode1)) {
7305 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetKeyState" "', expected argument " "1"" of type '" "wxKeyCode""'");
7306 }
7307 arg1 = static_cast< wxKeyCode >(val1);
7308 {
7309 if (!wxPyCheckForApp()) SWIG_fail;
7310 PyThreadState* __tstate = wxPyBeginAllowThreads();
7311 result = (bool)wxGetKeyState(arg1);
7312 wxPyEndAllowThreads(__tstate);
7313 if (PyErr_Occurred()) SWIG_fail;
7314 }
7315 {
7316 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7317 }
7318 return resultobj;
7319 fail:
7320 return NULL;
7321 }
7322
7323
7324 SWIGINTERN PyObject *_wrap_new_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7325 PyObject *resultobj = 0;
7326 wxMouseState *result = 0 ;
7327
7328 if (!SWIG_Python_UnpackTuple(args,"new_MouseState",0,0,0)) SWIG_fail;
7329 {
7330 PyThreadState* __tstate = wxPyBeginAllowThreads();
7331 result = (wxMouseState *)new wxMouseState();
7332 wxPyEndAllowThreads(__tstate);
7333 if (PyErr_Occurred()) SWIG_fail;
7334 }
7335 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseState, SWIG_POINTER_NEW | 0 );
7336 return resultobj;
7337 fail:
7338 return NULL;
7339 }
7340
7341
7342 SWIGINTERN PyObject *_wrap_delete_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7343 PyObject *resultobj = 0;
7344 wxMouseState *arg1 = (wxMouseState *) 0 ;
7345 void *argp1 = 0 ;
7346 int res1 = 0 ;
7347 PyObject *swig_obj[1] ;
7348
7349 if (!args) SWIG_fail;
7350 swig_obj[0] = args;
7351 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, SWIG_POINTER_DISOWN | 0 );
7352 if (!SWIG_IsOK(res1)) {
7353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MouseState" "', expected argument " "1"" of type '" "wxMouseState *""'");
7354 }
7355 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7356 {
7357 PyThreadState* __tstate = wxPyBeginAllowThreads();
7358 delete arg1;
7359
7360 wxPyEndAllowThreads(__tstate);
7361 if (PyErr_Occurred()) SWIG_fail;
7362 }
7363 resultobj = SWIG_Py_Void();
7364 return resultobj;
7365 fail:
7366 return NULL;
7367 }
7368
7369
7370 SWIGINTERN PyObject *_wrap_MouseState_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7371 PyObject *resultobj = 0;
7372 wxMouseState *arg1 = (wxMouseState *) 0 ;
7373 int result;
7374 void *argp1 = 0 ;
7375 int res1 = 0 ;
7376 PyObject *swig_obj[1] ;
7377
7378 if (!args) SWIG_fail;
7379 swig_obj[0] = args;
7380 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7381 if (!SWIG_IsOK(res1)) {
7382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7383 }
7384 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7385 {
7386 PyThreadState* __tstate = wxPyBeginAllowThreads();
7387 result = (int)(arg1)->GetX();
7388 wxPyEndAllowThreads(__tstate);
7389 if (PyErr_Occurred()) SWIG_fail;
7390 }
7391 resultobj = SWIG_From_int(static_cast< int >(result));
7392 return resultobj;
7393 fail:
7394 return NULL;
7395 }
7396
7397
7398 SWIGINTERN PyObject *_wrap_MouseState_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7399 PyObject *resultobj = 0;
7400 wxMouseState *arg1 = (wxMouseState *) 0 ;
7401 int result;
7402 void *argp1 = 0 ;
7403 int res1 = 0 ;
7404 PyObject *swig_obj[1] ;
7405
7406 if (!args) SWIG_fail;
7407 swig_obj[0] = args;
7408 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7409 if (!SWIG_IsOK(res1)) {
7410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7411 }
7412 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7413 {
7414 PyThreadState* __tstate = wxPyBeginAllowThreads();
7415 result = (int)(arg1)->GetY();
7416 wxPyEndAllowThreads(__tstate);
7417 if (PyErr_Occurred()) SWIG_fail;
7418 }
7419 resultobj = SWIG_From_int(static_cast< int >(result));
7420 return resultobj;
7421 fail:
7422 return NULL;
7423 }
7424
7425
7426 SWIGINTERN PyObject *_wrap_MouseState_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7427 PyObject *resultobj = 0;
7428 wxMouseState *arg1 = (wxMouseState *) 0 ;
7429 bool result;
7430 void *argp1 = 0 ;
7431 int res1 = 0 ;
7432 PyObject *swig_obj[1] ;
7433
7434 if (!args) SWIG_fail;
7435 swig_obj[0] = args;
7436 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7437 if (!SWIG_IsOK(res1)) {
7438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_LeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7439 }
7440 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7441 {
7442 PyThreadState* __tstate = wxPyBeginAllowThreads();
7443 result = (bool)(arg1)->LeftDown();
7444 wxPyEndAllowThreads(__tstate);
7445 if (PyErr_Occurred()) SWIG_fail;
7446 }
7447 {
7448 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7449 }
7450 return resultobj;
7451 fail:
7452 return NULL;
7453 }
7454
7455
7456 SWIGINTERN PyObject *_wrap_MouseState_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7457 PyObject *resultobj = 0;
7458 wxMouseState *arg1 = (wxMouseState *) 0 ;
7459 bool result;
7460 void *argp1 = 0 ;
7461 int res1 = 0 ;
7462 PyObject *swig_obj[1] ;
7463
7464 if (!args) SWIG_fail;
7465 swig_obj[0] = args;
7466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7467 if (!SWIG_IsOK(res1)) {
7468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7469 }
7470 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7471 {
7472 PyThreadState* __tstate = wxPyBeginAllowThreads();
7473 result = (bool)(arg1)->MiddleDown();
7474 wxPyEndAllowThreads(__tstate);
7475 if (PyErr_Occurred()) SWIG_fail;
7476 }
7477 {
7478 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7479 }
7480 return resultobj;
7481 fail:
7482 return NULL;
7483 }
7484
7485
7486 SWIGINTERN PyObject *_wrap_MouseState_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7487 PyObject *resultobj = 0;
7488 wxMouseState *arg1 = (wxMouseState *) 0 ;
7489 bool result;
7490 void *argp1 = 0 ;
7491 int res1 = 0 ;
7492 PyObject *swig_obj[1] ;
7493
7494 if (!args) SWIG_fail;
7495 swig_obj[0] = args;
7496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7497 if (!SWIG_IsOK(res1)) {
7498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_RightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7499 }
7500 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7501 {
7502 PyThreadState* __tstate = wxPyBeginAllowThreads();
7503 result = (bool)(arg1)->RightDown();
7504 wxPyEndAllowThreads(__tstate);
7505 if (PyErr_Occurred()) SWIG_fail;
7506 }
7507 {
7508 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7509 }
7510 return resultobj;
7511 fail:
7512 return NULL;
7513 }
7514
7515
7516 SWIGINTERN PyObject *_wrap_MouseState_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7517 PyObject *resultobj = 0;
7518 wxMouseState *arg1 = (wxMouseState *) 0 ;
7519 bool result;
7520 void *argp1 = 0 ;
7521 int res1 = 0 ;
7522 PyObject *swig_obj[1] ;
7523
7524 if (!args) SWIG_fail;
7525 swig_obj[0] = args;
7526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7527 if (!SWIG_IsOK(res1)) {
7528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7529 }
7530 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7531 {
7532 PyThreadState* __tstate = wxPyBeginAllowThreads();
7533 result = (bool)(arg1)->ControlDown();
7534 wxPyEndAllowThreads(__tstate);
7535 if (PyErr_Occurred()) SWIG_fail;
7536 }
7537 {
7538 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7539 }
7540 return resultobj;
7541 fail:
7542 return NULL;
7543 }
7544
7545
7546 SWIGINTERN PyObject *_wrap_MouseState_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7547 PyObject *resultobj = 0;
7548 wxMouseState *arg1 = (wxMouseState *) 0 ;
7549 bool result;
7550 void *argp1 = 0 ;
7551 int res1 = 0 ;
7552 PyObject *swig_obj[1] ;
7553
7554 if (!args) SWIG_fail;
7555 swig_obj[0] = args;
7556 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7557 if (!SWIG_IsOK(res1)) {
7558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7559 }
7560 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7561 {
7562 PyThreadState* __tstate = wxPyBeginAllowThreads();
7563 result = (bool)(arg1)->ShiftDown();
7564 wxPyEndAllowThreads(__tstate);
7565 if (PyErr_Occurred()) SWIG_fail;
7566 }
7567 {
7568 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7569 }
7570 return resultobj;
7571 fail:
7572 return NULL;
7573 }
7574
7575
7576 SWIGINTERN PyObject *_wrap_MouseState_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7577 PyObject *resultobj = 0;
7578 wxMouseState *arg1 = (wxMouseState *) 0 ;
7579 bool result;
7580 void *argp1 = 0 ;
7581 int res1 = 0 ;
7582 PyObject *swig_obj[1] ;
7583
7584 if (!args) SWIG_fail;
7585 swig_obj[0] = args;
7586 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7587 if (!SWIG_IsOK(res1)) {
7588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_AltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7589 }
7590 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7591 {
7592 PyThreadState* __tstate = wxPyBeginAllowThreads();
7593 result = (bool)(arg1)->AltDown();
7594 wxPyEndAllowThreads(__tstate);
7595 if (PyErr_Occurred()) SWIG_fail;
7596 }
7597 {
7598 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7599 }
7600 return resultobj;
7601 fail:
7602 return NULL;
7603 }
7604
7605
7606 SWIGINTERN PyObject *_wrap_MouseState_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7607 PyObject *resultobj = 0;
7608 wxMouseState *arg1 = (wxMouseState *) 0 ;
7609 bool result;
7610 void *argp1 = 0 ;
7611 int res1 = 0 ;
7612 PyObject *swig_obj[1] ;
7613
7614 if (!args) SWIG_fail;
7615 swig_obj[0] = args;
7616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7617 if (!SWIG_IsOK(res1)) {
7618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7619 }
7620 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7621 {
7622 PyThreadState* __tstate = wxPyBeginAllowThreads();
7623 result = (bool)(arg1)->MetaDown();
7624 wxPyEndAllowThreads(__tstate);
7625 if (PyErr_Occurred()) SWIG_fail;
7626 }
7627 {
7628 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7629 }
7630 return resultobj;
7631 fail:
7632 return NULL;
7633 }
7634
7635
7636 SWIGINTERN PyObject *_wrap_MouseState_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7637 PyObject *resultobj = 0;
7638 wxMouseState *arg1 = (wxMouseState *) 0 ;
7639 bool result;
7640 void *argp1 = 0 ;
7641 int res1 = 0 ;
7642 PyObject *swig_obj[1] ;
7643
7644 if (!args) SWIG_fail;
7645 swig_obj[0] = args;
7646 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7647 if (!SWIG_IsOK(res1)) {
7648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_CmdDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7649 }
7650 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7651 {
7652 PyThreadState* __tstate = wxPyBeginAllowThreads();
7653 result = (bool)(arg1)->CmdDown();
7654 wxPyEndAllowThreads(__tstate);
7655 if (PyErr_Occurred()) SWIG_fail;
7656 }
7657 {
7658 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7659 }
7660 return resultobj;
7661 fail:
7662 return NULL;
7663 }
7664
7665
7666 SWIGINTERN PyObject *_wrap_MouseState_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7667 PyObject *resultobj = 0;
7668 wxMouseState *arg1 = (wxMouseState *) 0 ;
7669 int arg2 ;
7670 void *argp1 = 0 ;
7671 int res1 = 0 ;
7672 int val2 ;
7673 int ecode2 = 0 ;
7674 PyObject * obj0 = 0 ;
7675 PyObject * obj1 = 0 ;
7676 char * kwnames[] = {
7677 (char *) "self",(char *) "x", NULL
7678 };
7679
7680 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
7681 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7682 if (!SWIG_IsOK(res1)) {
7683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7684 }
7685 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7686 ecode2 = SWIG_AsVal_int(obj1, &val2);
7687 if (!SWIG_IsOK(ecode2)) {
7688 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetX" "', expected argument " "2"" of type '" "int""'");
7689 }
7690 arg2 = static_cast< int >(val2);
7691 {
7692 PyThreadState* __tstate = wxPyBeginAllowThreads();
7693 (arg1)->SetX(arg2);
7694 wxPyEndAllowThreads(__tstate);
7695 if (PyErr_Occurred()) SWIG_fail;
7696 }
7697 resultobj = SWIG_Py_Void();
7698 return resultobj;
7699 fail:
7700 return NULL;
7701 }
7702
7703
7704 SWIGINTERN PyObject *_wrap_MouseState_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7705 PyObject *resultobj = 0;
7706 wxMouseState *arg1 = (wxMouseState *) 0 ;
7707 int arg2 ;
7708 void *argp1 = 0 ;
7709 int res1 = 0 ;
7710 int val2 ;
7711 int ecode2 = 0 ;
7712 PyObject * obj0 = 0 ;
7713 PyObject * obj1 = 0 ;
7714 char * kwnames[] = {
7715 (char *) "self",(char *) "y", NULL
7716 };
7717
7718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
7719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7720 if (!SWIG_IsOK(res1)) {
7721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7722 }
7723 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7724 ecode2 = SWIG_AsVal_int(obj1, &val2);
7725 if (!SWIG_IsOK(ecode2)) {
7726 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetY" "', expected argument " "2"" of type '" "int""'");
7727 }
7728 arg2 = static_cast< int >(val2);
7729 {
7730 PyThreadState* __tstate = wxPyBeginAllowThreads();
7731 (arg1)->SetY(arg2);
7732 wxPyEndAllowThreads(__tstate);
7733 if (PyErr_Occurred()) SWIG_fail;
7734 }
7735 resultobj = SWIG_Py_Void();
7736 return resultobj;
7737 fail:
7738 return NULL;
7739 }
7740
7741
7742 SWIGINTERN PyObject *_wrap_MouseState_SetLeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7743 PyObject *resultobj = 0;
7744 wxMouseState *arg1 = (wxMouseState *) 0 ;
7745 bool arg2 ;
7746 void *argp1 = 0 ;
7747 int res1 = 0 ;
7748 bool val2 ;
7749 int ecode2 = 0 ;
7750 PyObject * obj0 = 0 ;
7751 PyObject * obj1 = 0 ;
7752 char * kwnames[] = {
7753 (char *) "self",(char *) "down", NULL
7754 };
7755
7756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetLeftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7758 if (!SWIG_IsOK(res1)) {
7759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetLeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7760 }
7761 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7762 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7763 if (!SWIG_IsOK(ecode2)) {
7764 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetLeftDown" "', expected argument " "2"" of type '" "bool""'");
7765 }
7766 arg2 = static_cast< bool >(val2);
7767 {
7768 PyThreadState* __tstate = wxPyBeginAllowThreads();
7769 (arg1)->SetLeftDown(arg2);
7770 wxPyEndAllowThreads(__tstate);
7771 if (PyErr_Occurred()) SWIG_fail;
7772 }
7773 resultobj = SWIG_Py_Void();
7774 return resultobj;
7775 fail:
7776 return NULL;
7777 }
7778
7779
7780 SWIGINTERN PyObject *_wrap_MouseState_SetMiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7781 PyObject *resultobj = 0;
7782 wxMouseState *arg1 = (wxMouseState *) 0 ;
7783 bool arg2 ;
7784 void *argp1 = 0 ;
7785 int res1 = 0 ;
7786 bool val2 ;
7787 int ecode2 = 0 ;
7788 PyObject * obj0 = 0 ;
7789 PyObject * obj1 = 0 ;
7790 char * kwnames[] = {
7791 (char *) "self",(char *) "down", NULL
7792 };
7793
7794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMiddleDown",kwnames,&obj0,&obj1)) SWIG_fail;
7795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7796 if (!SWIG_IsOK(res1)) {
7797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7798 }
7799 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7800 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7801 if (!SWIG_IsOK(ecode2)) {
7802 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMiddleDown" "', expected argument " "2"" of type '" "bool""'");
7803 }
7804 arg2 = static_cast< bool >(val2);
7805 {
7806 PyThreadState* __tstate = wxPyBeginAllowThreads();
7807 (arg1)->SetMiddleDown(arg2);
7808 wxPyEndAllowThreads(__tstate);
7809 if (PyErr_Occurred()) SWIG_fail;
7810 }
7811 resultobj = SWIG_Py_Void();
7812 return resultobj;
7813 fail:
7814 return NULL;
7815 }
7816
7817
7818 SWIGINTERN PyObject *_wrap_MouseState_SetRightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7819 PyObject *resultobj = 0;
7820 wxMouseState *arg1 = (wxMouseState *) 0 ;
7821 bool arg2 ;
7822 void *argp1 = 0 ;
7823 int res1 = 0 ;
7824 bool val2 ;
7825 int ecode2 = 0 ;
7826 PyObject * obj0 = 0 ;
7827 PyObject * obj1 = 0 ;
7828 char * kwnames[] = {
7829 (char *) "self",(char *) "down", NULL
7830 };
7831
7832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetRightDown",kwnames,&obj0,&obj1)) SWIG_fail;
7833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7834 if (!SWIG_IsOK(res1)) {
7835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetRightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7836 }
7837 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7838 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7839 if (!SWIG_IsOK(ecode2)) {
7840 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetRightDown" "', expected argument " "2"" of type '" "bool""'");
7841 }
7842 arg2 = static_cast< bool >(val2);
7843 {
7844 PyThreadState* __tstate = wxPyBeginAllowThreads();
7845 (arg1)->SetRightDown(arg2);
7846 wxPyEndAllowThreads(__tstate);
7847 if (PyErr_Occurred()) SWIG_fail;
7848 }
7849 resultobj = SWIG_Py_Void();
7850 return resultobj;
7851 fail:
7852 return NULL;
7853 }
7854
7855
7856 SWIGINTERN PyObject *_wrap_MouseState_SetControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7857 PyObject *resultobj = 0;
7858 wxMouseState *arg1 = (wxMouseState *) 0 ;
7859 bool arg2 ;
7860 void *argp1 = 0 ;
7861 int res1 = 0 ;
7862 bool val2 ;
7863 int ecode2 = 0 ;
7864 PyObject * obj0 = 0 ;
7865 PyObject * obj1 = 0 ;
7866 char * kwnames[] = {
7867 (char *) "self",(char *) "down", NULL
7868 };
7869
7870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetControlDown",kwnames,&obj0,&obj1)) SWIG_fail;
7871 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7872 if (!SWIG_IsOK(res1)) {
7873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7874 }
7875 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7876 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7877 if (!SWIG_IsOK(ecode2)) {
7878 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetControlDown" "', expected argument " "2"" of type '" "bool""'");
7879 }
7880 arg2 = static_cast< bool >(val2);
7881 {
7882 PyThreadState* __tstate = wxPyBeginAllowThreads();
7883 (arg1)->SetControlDown(arg2);
7884 wxPyEndAllowThreads(__tstate);
7885 if (PyErr_Occurred()) SWIG_fail;
7886 }
7887 resultobj = SWIG_Py_Void();
7888 return resultobj;
7889 fail:
7890 return NULL;
7891 }
7892
7893
7894 SWIGINTERN PyObject *_wrap_MouseState_SetShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7895 PyObject *resultobj = 0;
7896 wxMouseState *arg1 = (wxMouseState *) 0 ;
7897 bool arg2 ;
7898 void *argp1 = 0 ;
7899 int res1 = 0 ;
7900 bool val2 ;
7901 int ecode2 = 0 ;
7902 PyObject * obj0 = 0 ;
7903 PyObject * obj1 = 0 ;
7904 char * kwnames[] = {
7905 (char *) "self",(char *) "down", NULL
7906 };
7907
7908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetShiftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7910 if (!SWIG_IsOK(res1)) {
7911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7912 }
7913 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7914 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7915 if (!SWIG_IsOK(ecode2)) {
7916 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetShiftDown" "', expected argument " "2"" of type '" "bool""'");
7917 }
7918 arg2 = static_cast< bool >(val2);
7919 {
7920 PyThreadState* __tstate = wxPyBeginAllowThreads();
7921 (arg1)->SetShiftDown(arg2);
7922 wxPyEndAllowThreads(__tstate);
7923 if (PyErr_Occurred()) SWIG_fail;
7924 }
7925 resultobj = SWIG_Py_Void();
7926 return resultobj;
7927 fail:
7928 return NULL;
7929 }
7930
7931
7932 SWIGINTERN PyObject *_wrap_MouseState_SetAltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7933 PyObject *resultobj = 0;
7934 wxMouseState *arg1 = (wxMouseState *) 0 ;
7935 bool arg2 ;
7936 void *argp1 = 0 ;
7937 int res1 = 0 ;
7938 bool val2 ;
7939 int ecode2 = 0 ;
7940 PyObject * obj0 = 0 ;
7941 PyObject * obj1 = 0 ;
7942 char * kwnames[] = {
7943 (char *) "self",(char *) "down", NULL
7944 };
7945
7946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetAltDown",kwnames,&obj0,&obj1)) SWIG_fail;
7947 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7948 if (!SWIG_IsOK(res1)) {
7949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetAltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7950 }
7951 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7952 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7953 if (!SWIG_IsOK(ecode2)) {
7954 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetAltDown" "', expected argument " "2"" of type '" "bool""'");
7955 }
7956 arg2 = static_cast< bool >(val2);
7957 {
7958 PyThreadState* __tstate = wxPyBeginAllowThreads();
7959 (arg1)->SetAltDown(arg2);
7960 wxPyEndAllowThreads(__tstate);
7961 if (PyErr_Occurred()) SWIG_fail;
7962 }
7963 resultobj = SWIG_Py_Void();
7964 return resultobj;
7965 fail:
7966 return NULL;
7967 }
7968
7969
7970 SWIGINTERN PyObject *_wrap_MouseState_SetMetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7971 PyObject *resultobj = 0;
7972 wxMouseState *arg1 = (wxMouseState *) 0 ;
7973 bool arg2 ;
7974 void *argp1 = 0 ;
7975 int res1 = 0 ;
7976 bool val2 ;
7977 int ecode2 = 0 ;
7978 PyObject * obj0 = 0 ;
7979 PyObject * obj1 = 0 ;
7980 char * kwnames[] = {
7981 (char *) "self",(char *) "down", NULL
7982 };
7983
7984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMetaDown",kwnames,&obj0,&obj1)) SWIG_fail;
7985 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7986 if (!SWIG_IsOK(res1)) {
7987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7988 }
7989 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7990 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7991 if (!SWIG_IsOK(ecode2)) {
7992 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMetaDown" "', expected argument " "2"" of type '" "bool""'");
7993 }
7994 arg2 = static_cast< bool >(val2);
7995 {
7996 PyThreadState* __tstate = wxPyBeginAllowThreads();
7997 (arg1)->SetMetaDown(arg2);
7998 wxPyEndAllowThreads(__tstate);
7999 if (PyErr_Occurred()) SWIG_fail;
8000 }
8001 resultobj = SWIG_Py_Void();
8002 return resultobj;
8003 fail:
8004 return NULL;
8005 }
8006
8007
8008 SWIGINTERN PyObject *MouseState_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8009 PyObject *obj;
8010 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8011 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseState, SWIG_NewClientData(obj));
8012 return SWIG_Py_Void();
8013 }
8014
8015 SWIGINTERN PyObject *MouseState_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8016 return SWIG_Python_InitShadowInstance(args);
8017 }
8018
8019 SWIGINTERN PyObject *_wrap_GetMouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8020 PyObject *resultobj = 0;
8021 wxMouseState result;
8022
8023 if (!SWIG_Python_UnpackTuple(args,"GetMouseState",0,0,0)) SWIG_fail;
8024 {
8025 PyThreadState* __tstate = wxPyBeginAllowThreads();
8026 result = wxGetMouseState();
8027 wxPyEndAllowThreads(__tstate);
8028 if (PyErr_Occurred()) SWIG_fail;
8029 }
8030 resultobj = SWIG_NewPointerObj((new wxMouseState(static_cast< const wxMouseState& >(result))), SWIGTYPE_p_wxMouseState, SWIG_POINTER_OWN | 0 );
8031 return resultobj;
8032 fail:
8033 return NULL;
8034 }
8035
8036
8037 SWIGINTERN PyObject *_wrap_WakeUpMainThread(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8038 PyObject *resultobj = 0;
8039
8040 if (!SWIG_Python_UnpackTuple(args,"WakeUpMainThread",0,0,0)) SWIG_fail;
8041 {
8042 if (!wxPyCheckForApp()) SWIG_fail;
8043 PyThreadState* __tstate = wxPyBeginAllowThreads();
8044 wxWakeUpMainThread();
8045 wxPyEndAllowThreads(__tstate);
8046 if (PyErr_Occurred()) SWIG_fail;
8047 }
8048 resultobj = SWIG_Py_Void();
8049 return resultobj;
8050 fail:
8051 return NULL;
8052 }
8053
8054
8055 SWIGINTERN PyObject *_wrap_MutexGuiEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8056 PyObject *resultobj = 0;
8057
8058 if (!SWIG_Python_UnpackTuple(args,"MutexGuiEnter",0,0,0)) SWIG_fail;
8059 {
8060 if (!wxPyCheckForApp()) SWIG_fail;
8061 PyThreadState* __tstate = wxPyBeginAllowThreads();
8062 wxMutexGuiEnter();
8063 wxPyEndAllowThreads(__tstate);
8064 if (PyErr_Occurred()) SWIG_fail;
8065 }
8066 resultobj = SWIG_Py_Void();
8067 return resultobj;
8068 fail:
8069 return NULL;
8070 }
8071
8072
8073 SWIGINTERN PyObject *_wrap_MutexGuiLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8074 PyObject *resultobj = 0;
8075
8076 if (!SWIG_Python_UnpackTuple(args,"MutexGuiLeave",0,0,0)) SWIG_fail;
8077 {
8078 if (!wxPyCheckForApp()) SWIG_fail;
8079 PyThreadState* __tstate = wxPyBeginAllowThreads();
8080 wxMutexGuiLeave();
8081 wxPyEndAllowThreads(__tstate);
8082 if (PyErr_Occurred()) SWIG_fail;
8083 }
8084 resultobj = SWIG_Py_Void();
8085 return resultobj;
8086 fail:
8087 return NULL;
8088 }
8089
8090
8091 SWIGINTERN PyObject *_wrap_new_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8092 PyObject *resultobj = 0;
8093 wxMutexGuiLocker *result = 0 ;
8094
8095 if (!SWIG_Python_UnpackTuple(args,"new_MutexGuiLocker",0,0,0)) SWIG_fail;
8096 {
8097 if (!wxPyCheckForApp()) SWIG_fail;
8098 PyThreadState* __tstate = wxPyBeginAllowThreads();
8099 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
8100 wxPyEndAllowThreads(__tstate);
8101 if (PyErr_Occurred()) SWIG_fail;
8102 }
8103 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_NEW | 0 );
8104 return resultobj;
8105 fail:
8106 return NULL;
8107 }
8108
8109
8110 SWIGINTERN PyObject *_wrap_delete_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8111 PyObject *resultobj = 0;
8112 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
8113 void *argp1 = 0 ;
8114 int res1 = 0 ;
8115 PyObject *swig_obj[1] ;
8116
8117 if (!args) SWIG_fail;
8118 swig_obj[0] = args;
8119 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_DISOWN | 0 );
8120 if (!SWIG_IsOK(res1)) {
8121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MutexGuiLocker" "', expected argument " "1"" of type '" "wxMutexGuiLocker *""'");
8122 }
8123 arg1 = reinterpret_cast< wxMutexGuiLocker * >(argp1);
8124 {
8125 PyThreadState* __tstate = wxPyBeginAllowThreads();
8126 delete arg1;
8127
8128 wxPyEndAllowThreads(__tstate);
8129 if (PyErr_Occurred()) SWIG_fail;
8130 }
8131 resultobj = SWIG_Py_Void();
8132 return resultobj;
8133 fail:
8134 return NULL;
8135 }
8136
8137
8138 SWIGINTERN PyObject *MutexGuiLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8139 PyObject *obj;
8140 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8141 SWIG_TypeNewClientData(SWIGTYPE_p_wxMutexGuiLocker, SWIG_NewClientData(obj));
8142 return SWIG_Py_Void();
8143 }
8144
8145 SWIGINTERN PyObject *MutexGuiLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8146 return SWIG_Python_InitShadowInstance(args);
8147 }
8148
8149 SWIGINTERN PyObject *_wrap_Thread_IsMain(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8150 PyObject *resultobj = 0;
8151 bool result;
8152
8153 if (!SWIG_Python_UnpackTuple(args,"Thread_IsMain",0,0,0)) SWIG_fail;
8154 {
8155 PyThreadState* __tstate = wxPyBeginAllowThreads();
8156 result = (bool)wxThread_IsMain();
8157 wxPyEndAllowThreads(__tstate);
8158 if (PyErr_Occurred()) SWIG_fail;
8159 }
8160 {
8161 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8162 }
8163 return resultobj;
8164 fail:
8165 return NULL;
8166 }
8167
8168
8169 SWIGINTERN PyObject *_wrap_new_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8170 PyObject *resultobj = 0;
8171 wxString *arg1 = 0 ;
8172 wxToolTip *result = 0 ;
8173 bool temp1 = false ;
8174 PyObject * obj0 = 0 ;
8175 char * kwnames[] = {
8176 (char *) "tip", NULL
8177 };
8178
8179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) SWIG_fail;
8180 {
8181 arg1 = wxString_in_helper(obj0);
8182 if (arg1 == NULL) SWIG_fail;
8183 temp1 = true;
8184 }
8185 {
8186 if (!wxPyCheckForApp()) SWIG_fail;
8187 PyThreadState* __tstate = wxPyBeginAllowThreads();
8188 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
8189 wxPyEndAllowThreads(__tstate);
8190 if (PyErr_Occurred()) SWIG_fail;
8191 }
8192 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxToolTip, SWIG_POINTER_NEW | 0 );
8193 {
8194 if (temp1)
8195 delete arg1;
8196 }
8197 return resultobj;
8198 fail:
8199 {
8200 if (temp1)
8201 delete arg1;
8202 }
8203 return NULL;
8204 }
8205
8206
8207 SWIGINTERN PyObject *_wrap_delete_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8208 PyObject *resultobj = 0;
8209 wxToolTip *arg1 = (wxToolTip *) 0 ;
8210 void *argp1 = 0 ;
8211 int res1 = 0 ;
8212 PyObject *swig_obj[1] ;
8213
8214 if (!args) SWIG_fail;
8215 swig_obj[0] = args;
8216 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
8217 if (!SWIG_IsOK(res1)) {
8218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ToolTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8219 }
8220 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8221 {
8222 PyThreadState* __tstate = wxPyBeginAllowThreads();
8223 delete arg1;
8224
8225 wxPyEndAllowThreads(__tstate);
8226 if (PyErr_Occurred()) SWIG_fail;
8227 }
8228 resultobj = SWIG_Py_Void();
8229 return resultobj;
8230 fail:
8231 return NULL;
8232 }
8233
8234
8235 SWIGINTERN PyObject *_wrap_ToolTip_SetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8236 PyObject *resultobj = 0;
8237 wxToolTip *arg1 = (wxToolTip *) 0 ;
8238 wxString *arg2 = 0 ;
8239 void *argp1 = 0 ;
8240 int res1 = 0 ;
8241 bool temp2 = false ;
8242 PyObject * obj0 = 0 ;
8243 PyObject * obj1 = 0 ;
8244 char * kwnames[] = {
8245 (char *) "self",(char *) "tip", NULL
8246 };
8247
8248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) SWIG_fail;
8249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8250 if (!SWIG_IsOK(res1)) {
8251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_SetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8252 }
8253 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8254 {
8255 arg2 = wxString_in_helper(obj1);
8256 if (arg2 == NULL) SWIG_fail;
8257 temp2 = true;
8258 }
8259 {
8260 PyThreadState* __tstate = wxPyBeginAllowThreads();
8261 (arg1)->SetTip((wxString const &)*arg2);
8262 wxPyEndAllowThreads(__tstate);
8263 if (PyErr_Occurred()) SWIG_fail;
8264 }
8265 resultobj = SWIG_Py_Void();
8266 {
8267 if (temp2)
8268 delete arg2;
8269 }
8270 return resultobj;
8271 fail:
8272 {
8273 if (temp2)
8274 delete arg2;
8275 }
8276 return NULL;
8277 }
8278
8279
8280 SWIGINTERN PyObject *_wrap_ToolTip_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8281 PyObject *resultobj = 0;
8282 wxToolTip *arg1 = (wxToolTip *) 0 ;
8283 wxString result;
8284 void *argp1 = 0 ;
8285 int res1 = 0 ;
8286 PyObject *swig_obj[1] ;
8287
8288 if (!args) SWIG_fail;
8289 swig_obj[0] = args;
8290 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8291 if (!SWIG_IsOK(res1)) {
8292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8293 }
8294 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8295 {
8296 PyThreadState* __tstate = wxPyBeginAllowThreads();
8297 result = (arg1)->GetTip();
8298 wxPyEndAllowThreads(__tstate);
8299 if (PyErr_Occurred()) SWIG_fail;
8300 }
8301 {
8302 #if wxUSE_UNICODE
8303 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8304 #else
8305 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8306 #endif
8307 }
8308 return resultobj;
8309 fail:
8310 return NULL;
8311 }
8312
8313
8314 SWIGINTERN PyObject *_wrap_ToolTip_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8315 PyObject *resultobj = 0;
8316 wxToolTip *arg1 = (wxToolTip *) 0 ;
8317 wxWindow *result = 0 ;
8318 void *argp1 = 0 ;
8319 int res1 = 0 ;
8320 PyObject *swig_obj[1] ;
8321
8322 if (!args) SWIG_fail;
8323 swig_obj[0] = args;
8324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8325 if (!SWIG_IsOK(res1)) {
8326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetWindow" "', expected argument " "1"" of type '" "wxToolTip *""'");
8327 }
8328 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8329 {
8330 PyThreadState* __tstate = wxPyBeginAllowThreads();
8331 result = (wxWindow *)(arg1)->GetWindow();
8332 wxPyEndAllowThreads(__tstate);
8333 if (PyErr_Occurred()) SWIG_fail;
8334 }
8335 {
8336 resultobj = wxPyMake_wxObject(result, 0);
8337 }
8338 return resultobj;
8339 fail:
8340 return NULL;
8341 }
8342
8343
8344 SWIGINTERN PyObject *_wrap_ToolTip_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8345 PyObject *resultobj = 0;
8346 bool arg1 ;
8347 bool val1 ;
8348 int ecode1 = 0 ;
8349 PyObject * obj0 = 0 ;
8350 char * kwnames[] = {
8351 (char *) "flag", NULL
8352 };
8353
8354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) SWIG_fail;
8355 ecode1 = SWIG_AsVal_bool(obj0, &val1);
8356 if (!SWIG_IsOK(ecode1)) {
8357 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_Enable" "', expected argument " "1"" of type '" "bool""'");
8358 }
8359 arg1 = static_cast< bool >(val1);
8360 {
8361 PyThreadState* __tstate = wxPyBeginAllowThreads();
8362 wxToolTip::Enable(arg1);
8363 wxPyEndAllowThreads(__tstate);
8364 if (PyErr_Occurred()) SWIG_fail;
8365 }
8366 resultobj = SWIG_Py_Void();
8367 return resultobj;
8368 fail:
8369 return NULL;
8370 }
8371
8372
8373 SWIGINTERN PyObject *_wrap_ToolTip_SetDelay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8374 PyObject *resultobj = 0;
8375 long arg1 ;
8376 long val1 ;
8377 int ecode1 = 0 ;
8378 PyObject * obj0 = 0 ;
8379 char * kwnames[] = {
8380 (char *) "milliseconds", NULL
8381 };
8382
8383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) SWIG_fail;
8384 ecode1 = SWIG_AsVal_long(obj0, &val1);
8385 if (!SWIG_IsOK(ecode1)) {
8386 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_SetDelay" "', expected argument " "1"" of type '" "long""'");
8387 }
8388 arg1 = static_cast< long >(val1);
8389 {
8390 PyThreadState* __tstate = wxPyBeginAllowThreads();
8391 wxToolTip::SetDelay(arg1);
8392 wxPyEndAllowThreads(__tstate);
8393 if (PyErr_Occurred()) SWIG_fail;
8394 }
8395 resultobj = SWIG_Py_Void();
8396 return resultobj;
8397 fail:
8398 return NULL;
8399 }
8400
8401
8402 SWIGINTERN PyObject *ToolTip_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8403 PyObject *obj;
8404 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8405 SWIG_TypeNewClientData(SWIGTYPE_p_wxToolTip, SWIG_NewClientData(obj));
8406 return SWIG_Py_Void();
8407 }
8408
8409 SWIGINTERN PyObject *ToolTip_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8410 return SWIG_Python_InitShadowInstance(args);
8411 }
8412
8413 SWIGINTERN PyObject *_wrap_new_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8414 PyObject *resultobj = 0;
8415 wxWindow *arg1 = (wxWindow *) 0 ;
8416 wxSize *arg2 = 0 ;
8417 wxCaret *result = 0 ;
8418 void *argp1 = 0 ;
8419 int res1 = 0 ;
8420 wxSize temp2 ;
8421 PyObject * obj0 = 0 ;
8422 PyObject * obj1 = 0 ;
8423 char * kwnames[] = {
8424 (char *) "window",(char *) "size", NULL
8425 };
8426
8427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) SWIG_fail;
8428 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
8429 if (!SWIG_IsOK(res1)) {
8430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Caret" "', expected argument " "1"" of type '" "wxWindow *""'");
8431 }
8432 arg1 = reinterpret_cast< wxWindow * >(argp1);
8433 {
8434 arg2 = &temp2;
8435 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8436 }
8437 {
8438 if (!wxPyCheckForApp()) SWIG_fail;
8439 PyThreadState* __tstate = wxPyBeginAllowThreads();
8440 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
8441 wxPyEndAllowThreads(__tstate);
8442 if (PyErr_Occurred()) SWIG_fail;
8443 }
8444 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, SWIG_POINTER_NEW | 0 );
8445 return resultobj;
8446 fail:
8447 return NULL;
8448 }
8449
8450
8451 SWIGINTERN PyObject *_wrap_delete_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8452 PyObject *resultobj = 0;
8453 wxCaret *arg1 = (wxCaret *) 0 ;
8454 void *argp1 = 0 ;
8455 int res1 = 0 ;
8456 PyObject *swig_obj[1] ;
8457
8458 if (!args) SWIG_fail;
8459 swig_obj[0] = args;
8460 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
8461 if (!SWIG_IsOK(res1)) {
8462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Caret" "', expected argument " "1"" of type '" "wxCaret *""'");
8463 }
8464 arg1 = reinterpret_cast< wxCaret * >(argp1);
8465 {
8466 PyThreadState* __tstate = wxPyBeginAllowThreads();
8467 delete arg1;
8468
8469 wxPyEndAllowThreads(__tstate);
8470 if (PyErr_Occurred()) SWIG_fail;
8471 }
8472 resultobj = SWIG_Py_Void();
8473 return resultobj;
8474 fail:
8475 return NULL;
8476 }
8477
8478
8479 SWIGINTERN PyObject *_wrap_Caret_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8480 PyObject *resultobj = 0;
8481 wxCaret *arg1 = (wxCaret *) 0 ;
8482 void *argp1 = 0 ;
8483 int res1 = 0 ;
8484 PyObject *swig_obj[1] ;
8485
8486 if (!args) SWIG_fail;
8487 swig_obj[0] = args;
8488 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8489 if (!SWIG_IsOK(res1)) {
8490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Destroy" "', expected argument " "1"" of type '" "wxCaret *""'");
8491 }
8492 arg1 = reinterpret_cast< wxCaret * >(argp1);
8493 {
8494 PyThreadState* __tstate = wxPyBeginAllowThreads();
8495 wxCaret_Destroy(arg1);
8496 wxPyEndAllowThreads(__tstate);
8497 if (PyErr_Occurred()) SWIG_fail;
8498 }
8499 resultobj = SWIG_Py_Void();
8500 return resultobj;
8501 fail:
8502 return NULL;
8503 }
8504
8505
8506 SWIGINTERN PyObject *_wrap_Caret_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8507 PyObject *resultobj = 0;
8508 wxCaret *arg1 = (wxCaret *) 0 ;
8509 bool result;
8510 void *argp1 = 0 ;
8511 int res1 = 0 ;
8512 PyObject *swig_obj[1] ;
8513
8514 if (!args) SWIG_fail;
8515 swig_obj[0] = args;
8516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8517 if (!SWIG_IsOK(res1)) {
8518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsOk" "', expected argument " "1"" of type '" "wxCaret *""'");
8519 }
8520 arg1 = reinterpret_cast< wxCaret * >(argp1);
8521 {
8522 PyThreadState* __tstate = wxPyBeginAllowThreads();
8523 result = (bool)(arg1)->IsOk();
8524 wxPyEndAllowThreads(__tstate);
8525 if (PyErr_Occurred()) SWIG_fail;
8526 }
8527 {
8528 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8529 }
8530 return resultobj;
8531 fail:
8532 return NULL;
8533 }
8534
8535
8536 SWIGINTERN PyObject *_wrap_Caret_IsVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8537 PyObject *resultobj = 0;
8538 wxCaret *arg1 = (wxCaret *) 0 ;
8539 bool result;
8540 void *argp1 = 0 ;
8541 int res1 = 0 ;
8542 PyObject *swig_obj[1] ;
8543
8544 if (!args) SWIG_fail;
8545 swig_obj[0] = args;
8546 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8547 if (!SWIG_IsOK(res1)) {
8548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsVisible" "', expected argument " "1"" of type '" "wxCaret *""'");
8549 }
8550 arg1 = reinterpret_cast< wxCaret * >(argp1);
8551 {
8552 PyThreadState* __tstate = wxPyBeginAllowThreads();
8553 result = (bool)(arg1)->IsVisible();
8554 wxPyEndAllowThreads(__tstate);
8555 if (PyErr_Occurred()) SWIG_fail;
8556 }
8557 {
8558 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8559 }
8560 return resultobj;
8561 fail:
8562 return NULL;
8563 }
8564
8565
8566 SWIGINTERN PyObject *_wrap_Caret_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8567 PyObject *resultobj = 0;
8568 wxCaret *arg1 = (wxCaret *) 0 ;
8569 wxPoint result;
8570 void *argp1 = 0 ;
8571 int res1 = 0 ;
8572 PyObject *swig_obj[1] ;
8573
8574 if (!args) SWIG_fail;
8575 swig_obj[0] = args;
8576 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8577 if (!SWIG_IsOK(res1)) {
8578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPosition" "', expected argument " "1"" of type '" "wxCaret *""'");
8579 }
8580 arg1 = reinterpret_cast< wxCaret * >(argp1);
8581 {
8582 PyThreadState* __tstate = wxPyBeginAllowThreads();
8583 result = (arg1)->GetPosition();
8584 wxPyEndAllowThreads(__tstate);
8585 if (PyErr_Occurred()) SWIG_fail;
8586 }
8587 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
8588 return resultobj;
8589 fail:
8590 return NULL;
8591 }
8592
8593
8594 SWIGINTERN PyObject *_wrap_Caret_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8595 PyObject *resultobj = 0;
8596 wxCaret *arg1 = (wxCaret *) 0 ;
8597 int *arg2 = (int *) 0 ;
8598 int *arg3 = (int *) 0 ;
8599 void *argp1 = 0 ;
8600 int res1 = 0 ;
8601 int temp2 ;
8602 int res2 = SWIG_TMPOBJ ;
8603 int temp3 ;
8604 int res3 = SWIG_TMPOBJ ;
8605 PyObject *swig_obj[1] ;
8606
8607 arg2 = &temp2;
8608 arg3 = &temp3;
8609 if (!args) SWIG_fail;
8610 swig_obj[0] = args;
8611 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8612 if (!SWIG_IsOK(res1)) {
8613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPositionTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8614 }
8615 arg1 = reinterpret_cast< wxCaret * >(argp1);
8616 {
8617 PyThreadState* __tstate = wxPyBeginAllowThreads();
8618 (arg1)->GetPosition(arg2,arg3);
8619 wxPyEndAllowThreads(__tstate);
8620 if (PyErr_Occurred()) SWIG_fail;
8621 }
8622 resultobj = SWIG_Py_Void();
8623 if (SWIG_IsTmpObj(res2)) {
8624 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8625 } else {
8626 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8627 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8628 }
8629 if (SWIG_IsTmpObj(res3)) {
8630 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8631 } else {
8632 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8633 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8634 }
8635 return resultobj;
8636 fail:
8637 return NULL;
8638 }
8639
8640
8641 SWIGINTERN PyObject *_wrap_Caret_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8642 PyObject *resultobj = 0;
8643 wxCaret *arg1 = (wxCaret *) 0 ;
8644 wxSize result;
8645 void *argp1 = 0 ;
8646 int res1 = 0 ;
8647 PyObject *swig_obj[1] ;
8648
8649 if (!args) SWIG_fail;
8650 swig_obj[0] = args;
8651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8652 if (!SWIG_IsOK(res1)) {
8653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8654 }
8655 arg1 = reinterpret_cast< wxCaret * >(argp1);
8656 {
8657 PyThreadState* __tstate = wxPyBeginAllowThreads();
8658 result = (arg1)->GetSize();
8659 wxPyEndAllowThreads(__tstate);
8660 if (PyErr_Occurred()) SWIG_fail;
8661 }
8662 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
8663 return resultobj;
8664 fail:
8665 return NULL;
8666 }
8667
8668
8669 SWIGINTERN PyObject *_wrap_Caret_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8670 PyObject *resultobj = 0;
8671 wxCaret *arg1 = (wxCaret *) 0 ;
8672 int *arg2 = (int *) 0 ;
8673 int *arg3 = (int *) 0 ;
8674 void *argp1 = 0 ;
8675 int res1 = 0 ;
8676 int temp2 ;
8677 int res2 = SWIG_TMPOBJ ;
8678 int temp3 ;
8679 int res3 = SWIG_TMPOBJ ;
8680 PyObject *swig_obj[1] ;
8681
8682 arg2 = &temp2;
8683 arg3 = &temp3;
8684 if (!args) SWIG_fail;
8685 swig_obj[0] = args;
8686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8687 if (!SWIG_IsOK(res1)) {
8688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSizeTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8689 }
8690 arg1 = reinterpret_cast< wxCaret * >(argp1);
8691 {
8692 PyThreadState* __tstate = wxPyBeginAllowThreads();
8693 (arg1)->GetSize(arg2,arg3);
8694 wxPyEndAllowThreads(__tstate);
8695 if (PyErr_Occurred()) SWIG_fail;
8696 }
8697 resultobj = SWIG_Py_Void();
8698 if (SWIG_IsTmpObj(res2)) {
8699 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8700 } else {
8701 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8702 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8703 }
8704 if (SWIG_IsTmpObj(res3)) {
8705 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8706 } else {
8707 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8708 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8709 }
8710 return resultobj;
8711 fail:
8712 return NULL;
8713 }
8714
8715
8716 SWIGINTERN PyObject *_wrap_Caret_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8717 PyObject *resultobj = 0;
8718 wxCaret *arg1 = (wxCaret *) 0 ;
8719 wxWindow *result = 0 ;
8720 void *argp1 = 0 ;
8721 int res1 = 0 ;
8722 PyObject *swig_obj[1] ;
8723
8724 if (!args) SWIG_fail;
8725 swig_obj[0] = args;
8726 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8727 if (!SWIG_IsOK(res1)) {
8728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetWindow" "', expected argument " "1"" of type '" "wxCaret *""'");
8729 }
8730 arg1 = reinterpret_cast< wxCaret * >(argp1);
8731 {
8732 PyThreadState* __tstate = wxPyBeginAllowThreads();
8733 result = (wxWindow *)(arg1)->GetWindow();
8734 wxPyEndAllowThreads(__tstate);
8735 if (PyErr_Occurred()) SWIG_fail;
8736 }
8737 {
8738 resultobj = wxPyMake_wxObject(result, 0);
8739 }
8740 return resultobj;
8741 fail:
8742 return NULL;
8743 }
8744
8745
8746 SWIGINTERN PyObject *_wrap_Caret_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8747 PyObject *resultobj = 0;
8748 wxCaret *arg1 = (wxCaret *) 0 ;
8749 int arg2 ;
8750 int arg3 ;
8751 void *argp1 = 0 ;
8752 int res1 = 0 ;
8753 int val2 ;
8754 int ecode2 = 0 ;
8755 int val3 ;
8756 int ecode3 = 0 ;
8757 PyObject * obj0 = 0 ;
8758 PyObject * obj1 = 0 ;
8759 PyObject * obj2 = 0 ;
8760 char * kwnames[] = {
8761 (char *) "self",(char *) "x",(char *) "y", NULL
8762 };
8763
8764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8766 if (!SWIG_IsOK(res1)) {
8767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_MoveXY" "', expected argument " "1"" of type '" "wxCaret *""'");
8768 }
8769 arg1 = reinterpret_cast< wxCaret * >(argp1);
8770 ecode2 = SWIG_AsVal_int(obj1, &val2);
8771 if (!SWIG_IsOK(ecode2)) {
8772 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_MoveXY" "', expected argument " "2"" of type '" "int""'");
8773 }
8774 arg2 = static_cast< int >(val2);
8775 ecode3 = SWIG_AsVal_int(obj2, &val3);
8776 if (!SWIG_IsOK(ecode3)) {
8777 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_MoveXY" "', expected argument " "3"" of type '" "int""'");
8778 }
8779 arg3 = static_cast< int >(val3);
8780 {
8781 PyThreadState* __tstate = wxPyBeginAllowThreads();
8782 (arg1)->Move(arg2,arg3);
8783 wxPyEndAllowThreads(__tstate);
8784 if (PyErr_Occurred()) SWIG_fail;
8785 }
8786 resultobj = SWIG_Py_Void();
8787 return resultobj;
8788 fail:
8789 return NULL;
8790 }
8791
8792
8793 SWIGINTERN PyObject *_wrap_Caret_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8794 PyObject *resultobj = 0;
8795 wxCaret *arg1 = (wxCaret *) 0 ;
8796 wxPoint *arg2 = 0 ;
8797 void *argp1 = 0 ;
8798 int res1 = 0 ;
8799 wxPoint temp2 ;
8800 PyObject * obj0 = 0 ;
8801 PyObject * obj1 = 0 ;
8802 char * kwnames[] = {
8803 (char *) "self",(char *) "pt", NULL
8804 };
8805
8806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) 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_Move" "', expected argument " "1"" of type '" "wxCaret *""'");
8810 }
8811 arg1 = reinterpret_cast< wxCaret * >(argp1);
8812 {
8813 arg2 = &temp2;
8814 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
8815 }
8816 {
8817 PyThreadState* __tstate = wxPyBeginAllowThreads();
8818 (arg1)->Move((wxPoint const &)*arg2);
8819 wxPyEndAllowThreads(__tstate);
8820 if (PyErr_Occurred()) SWIG_fail;
8821 }
8822 resultobj = SWIG_Py_Void();
8823 return resultobj;
8824 fail:
8825 return NULL;
8826 }
8827
8828
8829 SWIGINTERN PyObject *_wrap_Caret_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8830 PyObject *resultobj = 0;
8831 wxCaret *arg1 = (wxCaret *) 0 ;
8832 int arg2 ;
8833 int arg3 ;
8834 void *argp1 = 0 ;
8835 int res1 = 0 ;
8836 int val2 ;
8837 int ecode2 = 0 ;
8838 int val3 ;
8839 int ecode3 = 0 ;
8840 PyObject * obj0 = 0 ;
8841 PyObject * obj1 = 0 ;
8842 PyObject * obj2 = 0 ;
8843 char * kwnames[] = {
8844 (char *) "self",(char *) "width",(char *) "height", NULL
8845 };
8846
8847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8849 if (!SWIG_IsOK(res1)) {
8850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSizeWH" "', expected argument " "1"" of type '" "wxCaret *""'");
8851 }
8852 arg1 = reinterpret_cast< wxCaret * >(argp1);
8853 ecode2 = SWIG_AsVal_int(obj1, &val2);
8854 if (!SWIG_IsOK(ecode2)) {
8855 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
8856 }
8857 arg2 = static_cast< int >(val2);
8858 ecode3 = SWIG_AsVal_int(obj2, &val3);
8859 if (!SWIG_IsOK(ecode3)) {
8860 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
8861 }
8862 arg3 = static_cast< int >(val3);
8863 {
8864 PyThreadState* __tstate = wxPyBeginAllowThreads();
8865 (arg1)->SetSize(arg2,arg3);
8866 wxPyEndAllowThreads(__tstate);
8867 if (PyErr_Occurred()) SWIG_fail;
8868 }
8869 resultobj = SWIG_Py_Void();
8870 return resultobj;
8871 fail:
8872 return NULL;
8873 }
8874
8875
8876 SWIGINTERN PyObject *_wrap_Caret_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8877 PyObject *resultobj = 0;
8878 wxCaret *arg1 = (wxCaret *) 0 ;
8879 wxSize *arg2 = 0 ;
8880 void *argp1 = 0 ;
8881 int res1 = 0 ;
8882 wxSize temp2 ;
8883 PyObject * obj0 = 0 ;
8884 PyObject * obj1 = 0 ;
8885 char * kwnames[] = {
8886 (char *) "self",(char *) "size", NULL
8887 };
8888
8889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
8890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8891 if (!SWIG_IsOK(res1)) {
8892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8893 }
8894 arg1 = reinterpret_cast< wxCaret * >(argp1);
8895 {
8896 arg2 = &temp2;
8897 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8898 }
8899 {
8900 PyThreadState* __tstate = wxPyBeginAllowThreads();
8901 (arg1)->SetSize((wxSize const &)*arg2);
8902 wxPyEndAllowThreads(__tstate);
8903 if (PyErr_Occurred()) SWIG_fail;
8904 }
8905 resultobj = SWIG_Py_Void();
8906 return resultobj;
8907 fail:
8908 return NULL;
8909 }
8910
8911
8912 SWIGINTERN PyObject *_wrap_Caret_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8913 PyObject *resultobj = 0;
8914 wxCaret *arg1 = (wxCaret *) 0 ;
8915 int arg2 = (int) true ;
8916 void *argp1 = 0 ;
8917 int res1 = 0 ;
8918 int val2 ;
8919 int ecode2 = 0 ;
8920 PyObject * obj0 = 0 ;
8921 PyObject * obj1 = 0 ;
8922 char * kwnames[] = {
8923 (char *) "self",(char *) "show", NULL
8924 };
8925
8926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) SWIG_fail;
8927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8928 if (!SWIG_IsOK(res1)) {
8929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Show" "', expected argument " "1"" of type '" "wxCaret *""'");
8930 }
8931 arg1 = reinterpret_cast< wxCaret * >(argp1);
8932 if (obj1) {
8933 ecode2 = SWIG_AsVal_int(obj1, &val2);
8934 if (!SWIG_IsOK(ecode2)) {
8935 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_Show" "', expected argument " "2"" of type '" "int""'");
8936 }
8937 arg2 = static_cast< int >(val2);
8938 }
8939 {
8940 PyThreadState* __tstate = wxPyBeginAllowThreads();
8941 (arg1)->Show(arg2);
8942 wxPyEndAllowThreads(__tstate);
8943 if (PyErr_Occurred()) SWIG_fail;
8944 }
8945 resultobj = SWIG_Py_Void();
8946 return resultobj;
8947 fail:
8948 return NULL;
8949 }
8950
8951
8952 SWIGINTERN PyObject *_wrap_Caret_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8953 PyObject *resultobj = 0;
8954 wxCaret *arg1 = (wxCaret *) 0 ;
8955 void *argp1 = 0 ;
8956 int res1 = 0 ;
8957 PyObject *swig_obj[1] ;
8958
8959 if (!args) SWIG_fail;
8960 swig_obj[0] = args;
8961 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8962 if (!SWIG_IsOK(res1)) {
8963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Hide" "', expected argument " "1"" of type '" "wxCaret *""'");
8964 }
8965 arg1 = reinterpret_cast< wxCaret * >(argp1);
8966 {
8967 PyThreadState* __tstate = wxPyBeginAllowThreads();
8968 (arg1)->Hide();
8969 wxPyEndAllowThreads(__tstate);
8970 if (PyErr_Occurred()) SWIG_fail;
8971 }
8972 resultobj = SWIG_Py_Void();
8973 return resultobj;
8974 fail:
8975 return NULL;
8976 }
8977
8978
8979 SWIGINTERN PyObject *_wrap_Caret_GetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8980 PyObject *resultobj = 0;
8981 int result;
8982
8983 if (!SWIG_Python_UnpackTuple(args,"Caret_GetBlinkTime",0,0,0)) SWIG_fail;
8984 {
8985 PyThreadState* __tstate = wxPyBeginAllowThreads();
8986 result = (int)wxCaret::GetBlinkTime();
8987 wxPyEndAllowThreads(__tstate);
8988 if (PyErr_Occurred()) SWIG_fail;
8989 }
8990 resultobj = SWIG_From_int(static_cast< int >(result));
8991 return resultobj;
8992 fail:
8993 return NULL;
8994 }
8995
8996
8997 SWIGINTERN PyObject *_wrap_Caret_SetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8998 PyObject *resultobj = 0;
8999 int arg1 ;
9000 int val1 ;
9001 int ecode1 = 0 ;
9002 PyObject * obj0 = 0 ;
9003 char * kwnames[] = {
9004 (char *) "milliseconds", NULL
9005 };
9006
9007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) SWIG_fail;
9008 ecode1 = SWIG_AsVal_int(obj0, &val1);
9009 if (!SWIG_IsOK(ecode1)) {
9010 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Caret_SetBlinkTime" "', expected argument " "1"" of type '" "int""'");
9011 }
9012 arg1 = static_cast< int >(val1);
9013 {
9014 PyThreadState* __tstate = wxPyBeginAllowThreads();
9015 wxCaret::SetBlinkTime(arg1);
9016 wxPyEndAllowThreads(__tstate);
9017 if (PyErr_Occurred()) SWIG_fail;
9018 }
9019 resultobj = SWIG_Py_Void();
9020 return resultobj;
9021 fail:
9022 return NULL;
9023 }
9024
9025
9026 SWIGINTERN PyObject *Caret_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9027 PyObject *obj;
9028 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9029 SWIG_TypeNewClientData(SWIGTYPE_p_wxCaret, SWIG_NewClientData(obj));
9030 return SWIG_Py_Void();
9031 }
9032
9033 SWIGINTERN PyObject *Caret_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9034 return SWIG_Python_InitShadowInstance(args);
9035 }
9036
9037 SWIGINTERN PyObject *_wrap_new_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9038 PyObject *resultobj = 0;
9039 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
9040 wxBusyCursor *result = 0 ;
9041 void *argp1 = 0 ;
9042 int res1 = 0 ;
9043 PyObject * obj0 = 0 ;
9044 char * kwnames[] = {
9045 (char *) "cursor", NULL
9046 };
9047
9048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) SWIG_fail;
9049 if (obj0) {
9050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
9051 if (!SWIG_IsOK(res1)) {
9052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
9053 }
9054 arg1 = reinterpret_cast< wxCursor * >(argp1);
9055 }
9056 {
9057 if (!wxPyCheckForApp()) SWIG_fail;
9058 PyThreadState* __tstate = wxPyBeginAllowThreads();
9059 result = (wxBusyCursor *)new wxBusyCursor(arg1);
9060 wxPyEndAllowThreads(__tstate);
9061 if (PyErr_Occurred()) SWIG_fail;
9062 }
9063 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_NEW | 0 );
9064 return resultobj;
9065 fail:
9066 return NULL;
9067 }
9068
9069
9070 SWIGINTERN PyObject *_wrap_delete_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9071 PyObject *resultobj = 0;
9072 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
9073 void *argp1 = 0 ;
9074 int res1 = 0 ;
9075 PyObject *swig_obj[1] ;
9076
9077 if (!args) SWIG_fail;
9078 swig_obj[0] = args;
9079 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_DISOWN | 0 );
9080 if (!SWIG_IsOK(res1)) {
9081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyCursor" "', expected argument " "1"" of type '" "wxBusyCursor *""'");
9082 }
9083 arg1 = reinterpret_cast< wxBusyCursor * >(argp1);
9084 {
9085 PyThreadState* __tstate = wxPyBeginAllowThreads();
9086 delete arg1;
9087
9088 wxPyEndAllowThreads(__tstate);
9089 if (PyErr_Occurred()) SWIG_fail;
9090 }
9091 resultobj = SWIG_Py_Void();
9092 return resultobj;
9093 fail:
9094 return NULL;
9095 }
9096
9097
9098 SWIGINTERN PyObject *BusyCursor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9099 PyObject *obj;
9100 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9101 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyCursor, SWIG_NewClientData(obj));
9102 return SWIG_Py_Void();
9103 }
9104
9105 SWIGINTERN PyObject *BusyCursor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9106 return SWIG_Python_InitShadowInstance(args);
9107 }
9108
9109 SWIGINTERN PyObject *_wrap_new_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9110 PyObject *resultobj = 0;
9111 wxWindow *arg1 = (wxWindow *) NULL ;
9112 wxWindowDisabler *result = 0 ;
9113 void *argp1 = 0 ;
9114 int res1 = 0 ;
9115 PyObject * obj0 = 0 ;
9116 char * kwnames[] = {
9117 (char *) "winToSkip", NULL
9118 };
9119
9120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) SWIG_fail;
9121 if (obj0) {
9122 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
9123 if (!SWIG_IsOK(res1)) {
9124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDisabler" "', expected argument " "1"" of type '" "wxWindow *""'");
9125 }
9126 arg1 = reinterpret_cast< wxWindow * >(argp1);
9127 }
9128 {
9129 if (!wxPyCheckForApp()) SWIG_fail;
9130 PyThreadState* __tstate = wxPyBeginAllowThreads();
9131 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
9132 wxPyEndAllowThreads(__tstate);
9133 if (PyErr_Occurred()) SWIG_fail;
9134 }
9135 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_NEW | 0 );
9136 return resultobj;
9137 fail:
9138 return NULL;
9139 }
9140
9141
9142 SWIGINTERN PyObject *_wrap_delete_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9143 PyObject *resultobj = 0;
9144 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
9145 void *argp1 = 0 ;
9146 int res1 = 0 ;
9147 PyObject *swig_obj[1] ;
9148
9149 if (!args) SWIG_fail;
9150 swig_obj[0] = args;
9151 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_DISOWN | 0 );
9152 if (!SWIG_IsOK(res1)) {
9153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_WindowDisabler" "', expected argument " "1"" of type '" "wxWindowDisabler *""'");
9154 }
9155 arg1 = reinterpret_cast< wxWindowDisabler * >(argp1);
9156 {
9157 PyThreadState* __tstate = wxPyBeginAllowThreads();
9158 delete arg1;
9159
9160 wxPyEndAllowThreads(__tstate);
9161 if (PyErr_Occurred()) SWIG_fail;
9162 }
9163 resultobj = SWIG_Py_Void();
9164 return resultobj;
9165 fail:
9166 return NULL;
9167 }
9168
9169
9170 SWIGINTERN PyObject *WindowDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9171 PyObject *obj;
9172 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9173 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDisabler, SWIG_NewClientData(obj));
9174 return SWIG_Py_Void();
9175 }
9176
9177 SWIGINTERN PyObject *WindowDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9178 return SWIG_Python_InitShadowInstance(args);
9179 }
9180
9181 SWIGINTERN PyObject *_wrap_new_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9182 PyObject *resultobj = 0;
9183 wxString *arg1 = 0 ;
9184 wxBusyInfo *result = 0 ;
9185 bool temp1 = false ;
9186 PyObject * obj0 = 0 ;
9187 char * kwnames[] = {
9188 (char *) "message", NULL
9189 };
9190
9191 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) SWIG_fail;
9192 {
9193 arg1 = wxString_in_helper(obj0);
9194 if (arg1 == NULL) SWIG_fail;
9195 temp1 = true;
9196 }
9197 {
9198 if (!wxPyCheckForApp()) SWIG_fail;
9199 PyThreadState* __tstate = wxPyBeginAllowThreads();
9200 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
9201 wxPyEndAllowThreads(__tstate);
9202 if (PyErr_Occurred()) SWIG_fail;
9203 }
9204 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_NEW | 0 );
9205 {
9206 if (temp1)
9207 delete arg1;
9208 }
9209 return resultobj;
9210 fail:
9211 {
9212 if (temp1)
9213 delete arg1;
9214 }
9215 return NULL;
9216 }
9217
9218
9219 SWIGINTERN PyObject *_wrap_delete_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9220 PyObject *resultobj = 0;
9221 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
9222 void *argp1 = 0 ;
9223 int res1 = 0 ;
9224 PyObject *swig_obj[1] ;
9225
9226 if (!args) SWIG_fail;
9227 swig_obj[0] = args;
9228 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_DISOWN | 0 );
9229 if (!SWIG_IsOK(res1)) {
9230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyInfo" "', expected argument " "1"" of type '" "wxBusyInfo *""'");
9231 }
9232 arg1 = reinterpret_cast< wxBusyInfo * >(argp1);
9233 {
9234 PyThreadState* __tstate = wxPyBeginAllowThreads();
9235 delete arg1;
9236
9237 wxPyEndAllowThreads(__tstate);
9238 if (PyErr_Occurred()) SWIG_fail;
9239 }
9240 resultobj = SWIG_Py_Void();
9241 return resultobj;
9242 fail:
9243 return NULL;
9244 }
9245
9246
9247 SWIGINTERN PyObject *BusyInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9248 PyObject *obj;
9249 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9250 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyInfo, SWIG_NewClientData(obj));
9251 return SWIG_Py_Void();
9252 }
9253
9254 SWIGINTERN PyObject *BusyInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9255 return SWIG_Python_InitShadowInstance(args);
9256 }
9257
9258 SWIGINTERN PyObject *_wrap_new_StopWatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9259 PyObject *resultobj = 0;
9260 wxStopWatch *result = 0 ;
9261
9262 if (!SWIG_Python_UnpackTuple(args,"new_StopWatch",0,0,0)) SWIG_fail;
9263 {
9264 PyThreadState* __tstate = wxPyBeginAllowThreads();
9265 result = (wxStopWatch *)new wxStopWatch();
9266 wxPyEndAllowThreads(__tstate);
9267 if (PyErr_Occurred()) SWIG_fail;
9268 }
9269 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStopWatch, SWIG_POINTER_NEW | 0 );
9270 return resultobj;
9271 fail:
9272 return NULL;
9273 }
9274
9275
9276 SWIGINTERN PyObject *_wrap_delete_StopWatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9277 PyObject *resultobj = 0;
9278 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9279 void *argp1 = 0 ;
9280 int res1 = 0 ;
9281 PyObject *swig_obj[1] ;
9282
9283 if (!args) SWIG_fail;
9284 swig_obj[0] = args;
9285 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, SWIG_POINTER_DISOWN | 0 );
9286 if (!SWIG_IsOK(res1)) {
9287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StopWatch" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9288 }
9289 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9290 {
9291 PyThreadState* __tstate = wxPyBeginAllowThreads();
9292 delete arg1;
9293
9294 wxPyEndAllowThreads(__tstate);
9295 if (PyErr_Occurred()) SWIG_fail;
9296 }
9297 resultobj = SWIG_Py_Void();
9298 return resultobj;
9299 fail:
9300 return NULL;
9301 }
9302
9303
9304 SWIGINTERN PyObject *_wrap_StopWatch_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9305 PyObject *resultobj = 0;
9306 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9307 long arg2 = (long) 0 ;
9308 void *argp1 = 0 ;
9309 int res1 = 0 ;
9310 long val2 ;
9311 int ecode2 = 0 ;
9312 PyObject * obj0 = 0 ;
9313 PyObject * obj1 = 0 ;
9314 char * kwnames[] = {
9315 (char *) "self",(char *) "t0", NULL
9316 };
9317
9318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) SWIG_fail;
9319 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9320 if (!SWIG_IsOK(res1)) {
9321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Start" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9322 }
9323 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9324 if (obj1) {
9325 ecode2 = SWIG_AsVal_long(obj1, &val2);
9326 if (!SWIG_IsOK(ecode2)) {
9327 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StopWatch_Start" "', expected argument " "2"" of type '" "long""'");
9328 }
9329 arg2 = static_cast< long >(val2);
9330 }
9331 {
9332 PyThreadState* __tstate = wxPyBeginAllowThreads();
9333 (arg1)->Start(arg2);
9334 wxPyEndAllowThreads(__tstate);
9335 if (PyErr_Occurred()) SWIG_fail;
9336 }
9337 resultobj = SWIG_Py_Void();
9338 return resultobj;
9339 fail:
9340 return NULL;
9341 }
9342
9343
9344 SWIGINTERN PyObject *_wrap_StopWatch_Pause(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9345 PyObject *resultobj = 0;
9346 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9347 void *argp1 = 0 ;
9348 int res1 = 0 ;
9349 PyObject *swig_obj[1] ;
9350
9351 if (!args) SWIG_fail;
9352 swig_obj[0] = args;
9353 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9354 if (!SWIG_IsOK(res1)) {
9355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Pause" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9356 }
9357 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9358 {
9359 PyThreadState* __tstate = wxPyBeginAllowThreads();
9360 (arg1)->Pause();
9361 wxPyEndAllowThreads(__tstate);
9362 if (PyErr_Occurred()) SWIG_fail;
9363 }
9364 resultobj = SWIG_Py_Void();
9365 return resultobj;
9366 fail:
9367 return NULL;
9368 }
9369
9370
9371 SWIGINTERN PyObject *_wrap_StopWatch_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9372 PyObject *resultobj = 0;
9373 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9374 void *argp1 = 0 ;
9375 int res1 = 0 ;
9376 PyObject *swig_obj[1] ;
9377
9378 if (!args) SWIG_fail;
9379 swig_obj[0] = args;
9380 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9381 if (!SWIG_IsOK(res1)) {
9382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Resume" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9383 }
9384 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9385 {
9386 PyThreadState* __tstate = wxPyBeginAllowThreads();
9387 (arg1)->Resume();
9388 wxPyEndAllowThreads(__tstate);
9389 if (PyErr_Occurred()) SWIG_fail;
9390 }
9391 resultobj = SWIG_Py_Void();
9392 return resultobj;
9393 fail:
9394 return NULL;
9395 }
9396
9397
9398 SWIGINTERN PyObject *_wrap_StopWatch_Time(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9399 PyObject *resultobj = 0;
9400 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9401 long result;
9402 void *argp1 = 0 ;
9403 int res1 = 0 ;
9404 PyObject *swig_obj[1] ;
9405
9406 if (!args) SWIG_fail;
9407 swig_obj[0] = args;
9408 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9409 if (!SWIG_IsOK(res1)) {
9410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Time" "', expected argument " "1"" of type '" "wxStopWatch const *""'");
9411 }
9412 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9413 {
9414 PyThreadState* __tstate = wxPyBeginAllowThreads();
9415 result = (long)((wxStopWatch const *)arg1)->Time();
9416 wxPyEndAllowThreads(__tstate);
9417 if (PyErr_Occurred()) SWIG_fail;
9418 }
9419 resultobj = SWIG_From_long(static_cast< long >(result));
9420 return resultobj;
9421 fail:
9422 return NULL;
9423 }
9424
9425
9426 SWIGINTERN PyObject *StopWatch_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9427 PyObject *obj;
9428 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9429 SWIG_TypeNewClientData(SWIGTYPE_p_wxStopWatch, SWIG_NewClientData(obj));
9430 return SWIG_Py_Void();
9431 }
9432
9433 SWIGINTERN PyObject *StopWatch_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9434 return SWIG_Python_InitShadowInstance(args);
9435 }
9436
9437 SWIGINTERN PyObject *_wrap_new_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9438 PyObject *resultobj = 0;
9439 int arg1 = (int) 9 ;
9440 int arg2 = (int) wxID_FILE1 ;
9441 wxFileHistory *result = 0 ;
9442 int val1 ;
9443 int ecode1 = 0 ;
9444 int val2 ;
9445 int ecode2 = 0 ;
9446 PyObject * obj0 = 0 ;
9447 PyObject * obj1 = 0 ;
9448 char * kwnames[] = {
9449 (char *) "maxFiles",(char *) "idBase", NULL
9450 };
9451
9452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9453 if (obj0) {
9454 ecode1 = SWIG_AsVal_int(obj0, &val1);
9455 if (!SWIG_IsOK(ecode1)) {
9456 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FileHistory" "', expected argument " "1"" of type '" "int""'");
9457 }
9458 arg1 = static_cast< int >(val1);
9459 }
9460 if (obj1) {
9461 ecode2 = SWIG_AsVal_int(obj1, &val2);
9462 if (!SWIG_IsOK(ecode2)) {
9463 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FileHistory" "', expected argument " "2"" of type '" "int""'");
9464 }
9465 arg2 = static_cast< int >(val2);
9466 }
9467 {
9468 PyThreadState* __tstate = wxPyBeginAllowThreads();
9469 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
9470 wxPyEndAllowThreads(__tstate);
9471 if (PyErr_Occurred()) SWIG_fail;
9472 }
9473 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileHistory, SWIG_POINTER_NEW | 0 );
9474 return resultobj;
9475 fail:
9476 return NULL;
9477 }
9478
9479
9480 SWIGINTERN PyObject *_wrap_delete_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9481 PyObject *resultobj = 0;
9482 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9483 void *argp1 = 0 ;
9484 int res1 = 0 ;
9485 PyObject *swig_obj[1] ;
9486
9487 if (!args) SWIG_fail;
9488 swig_obj[0] = args;
9489 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, SWIG_POINTER_DISOWN | 0 );
9490 if (!SWIG_IsOK(res1)) {
9491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9492 }
9493 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9494 {
9495 PyThreadState* __tstate = wxPyBeginAllowThreads();
9496 delete arg1;
9497
9498 wxPyEndAllowThreads(__tstate);
9499 if (PyErr_Occurred()) SWIG_fail;
9500 }
9501 resultobj = SWIG_Py_Void();
9502 return resultobj;
9503 fail:
9504 return NULL;
9505 }
9506
9507
9508 SWIGINTERN PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9509 PyObject *resultobj = 0;
9510 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9511 wxString *arg2 = 0 ;
9512 void *argp1 = 0 ;
9513 int res1 = 0 ;
9514 bool temp2 = false ;
9515 PyObject * obj0 = 0 ;
9516 PyObject * obj1 = 0 ;
9517 char * kwnames[] = {
9518 (char *) "self",(char *) "file", NULL
9519 };
9520
9521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9522 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9523 if (!SWIG_IsOK(res1)) {
9524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFileToHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9525 }
9526 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9527 {
9528 arg2 = wxString_in_helper(obj1);
9529 if (arg2 == NULL) SWIG_fail;
9530 temp2 = true;
9531 }
9532 {
9533 PyThreadState* __tstate = wxPyBeginAllowThreads();
9534 (arg1)->AddFileToHistory((wxString const &)*arg2);
9535 wxPyEndAllowThreads(__tstate);
9536 if (PyErr_Occurred()) SWIG_fail;
9537 }
9538 resultobj = SWIG_Py_Void();
9539 {
9540 if (temp2)
9541 delete arg2;
9542 }
9543 return resultobj;
9544 fail:
9545 {
9546 if (temp2)
9547 delete arg2;
9548 }
9549 return NULL;
9550 }
9551
9552
9553 SWIGINTERN PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9554 PyObject *resultobj = 0;
9555 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9556 int arg2 ;
9557 void *argp1 = 0 ;
9558 int res1 = 0 ;
9559 int val2 ;
9560 int ecode2 = 0 ;
9561 PyObject * obj0 = 0 ;
9562 PyObject * obj1 = 0 ;
9563 char * kwnames[] = {
9564 (char *) "self",(char *) "i", NULL
9565 };
9566
9567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9569 if (!SWIG_IsOK(res1)) {
9570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9571 }
9572 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9573 ecode2 = SWIG_AsVal_int(obj1, &val2);
9574 if (!SWIG_IsOK(ecode2)) {
9575 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "2"" of type '" "int""'");
9576 }
9577 arg2 = static_cast< int >(val2);
9578 {
9579 PyThreadState* __tstate = wxPyBeginAllowThreads();
9580 (arg1)->RemoveFileFromHistory(arg2);
9581 wxPyEndAllowThreads(__tstate);
9582 if (PyErr_Occurred()) SWIG_fail;
9583 }
9584 resultobj = SWIG_Py_Void();
9585 return resultobj;
9586 fail:
9587 return NULL;
9588 }
9589
9590
9591 SWIGINTERN PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9592 PyObject *resultobj = 0;
9593 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9594 int result;
9595 void *argp1 = 0 ;
9596 int res1 = 0 ;
9597 PyObject *swig_obj[1] ;
9598
9599 if (!args) SWIG_fail;
9600 swig_obj[0] = args;
9601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9602 if (!SWIG_IsOK(res1)) {
9603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetMaxFiles" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9604 }
9605 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9606 {
9607 PyThreadState* __tstate = wxPyBeginAllowThreads();
9608 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
9609 wxPyEndAllowThreads(__tstate);
9610 if (PyErr_Occurred()) SWIG_fail;
9611 }
9612 resultobj = SWIG_From_int(static_cast< int >(result));
9613 return resultobj;
9614 fail:
9615 return NULL;
9616 }
9617
9618
9619 SWIGINTERN PyObject *_wrap_FileHistory_UseMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9620 PyObject *resultobj = 0;
9621 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9622 wxMenu *arg2 = (wxMenu *) 0 ;
9623 void *argp1 = 0 ;
9624 int res1 = 0 ;
9625 void *argp2 = 0 ;
9626 int res2 = 0 ;
9627 PyObject * obj0 = 0 ;
9628 PyObject * obj1 = 0 ;
9629 char * kwnames[] = {
9630 (char *) "self",(char *) "menu", NULL
9631 };
9632
9633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9634 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9635 if (!SWIG_IsOK(res1)) {
9636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_UseMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9637 }
9638 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9639 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9640 if (!SWIG_IsOK(res2)) {
9641 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_UseMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9642 }
9643 arg2 = reinterpret_cast< wxMenu * >(argp2);
9644 {
9645 PyThreadState* __tstate = wxPyBeginAllowThreads();
9646 (arg1)->UseMenu(arg2);
9647 wxPyEndAllowThreads(__tstate);
9648 if (PyErr_Occurred()) SWIG_fail;
9649 }
9650 resultobj = SWIG_Py_Void();
9651 return resultobj;
9652 fail:
9653 return NULL;
9654 }
9655
9656
9657 SWIGINTERN PyObject *_wrap_FileHistory_RemoveMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9658 PyObject *resultobj = 0;
9659 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9660 wxMenu *arg2 = (wxMenu *) 0 ;
9661 void *argp1 = 0 ;
9662 int res1 = 0 ;
9663 void *argp2 = 0 ;
9664 int res2 = 0 ;
9665 PyObject * obj0 = 0 ;
9666 PyObject * obj1 = 0 ;
9667 char * kwnames[] = {
9668 (char *) "self",(char *) "menu", NULL
9669 };
9670
9671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9673 if (!SWIG_IsOK(res1)) {
9674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9675 }
9676 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9677 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9678 if (!SWIG_IsOK(res2)) {
9679 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_RemoveMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9680 }
9681 arg2 = reinterpret_cast< wxMenu * >(argp2);
9682 {
9683 PyThreadState* __tstate = wxPyBeginAllowThreads();
9684 (arg1)->RemoveMenu(arg2);
9685 wxPyEndAllowThreads(__tstate);
9686 if (PyErr_Occurred()) SWIG_fail;
9687 }
9688 resultobj = SWIG_Py_Void();
9689 return resultobj;
9690 fail:
9691 return NULL;
9692 }
9693
9694
9695 SWIGINTERN PyObject *_wrap_FileHistory_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9696 PyObject *resultobj = 0;
9697 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9698 wxConfigBase *arg2 = 0 ;
9699 void *argp1 = 0 ;
9700 int res1 = 0 ;
9701 void *argp2 = 0 ;
9702 int res2 = 0 ;
9703 PyObject * obj0 = 0 ;
9704 PyObject * obj1 = 0 ;
9705 char * kwnames[] = {
9706 (char *) "self",(char *) "config", NULL
9707 };
9708
9709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) SWIG_fail;
9710 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9711 if (!SWIG_IsOK(res1)) {
9712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Load" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9713 }
9714 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9715 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9716 if (!SWIG_IsOK(res2)) {
9717 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9718 }
9719 if (!argp2) {
9720 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9721 }
9722 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9723 {
9724 PyThreadState* __tstate = wxPyBeginAllowThreads();
9725 (arg1)->Load(*arg2);
9726 wxPyEndAllowThreads(__tstate);
9727 if (PyErr_Occurred()) SWIG_fail;
9728 }
9729 resultobj = SWIG_Py_Void();
9730 return resultobj;
9731 fail:
9732 return NULL;
9733 }
9734
9735
9736 SWIGINTERN PyObject *_wrap_FileHistory_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9737 PyObject *resultobj = 0;
9738 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9739 wxConfigBase *arg2 = 0 ;
9740 void *argp1 = 0 ;
9741 int res1 = 0 ;
9742 void *argp2 = 0 ;
9743 int res2 = 0 ;
9744 PyObject * obj0 = 0 ;
9745 PyObject * obj1 = 0 ;
9746 char * kwnames[] = {
9747 (char *) "self",(char *) "config", NULL
9748 };
9749
9750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) SWIG_fail;
9751 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9752 if (!SWIG_IsOK(res1)) {
9753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Save" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9754 }
9755 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9756 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9757 if (!SWIG_IsOK(res2)) {
9758 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9759 }
9760 if (!argp2) {
9761 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9762 }
9763 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9764 {
9765 PyThreadState* __tstate = wxPyBeginAllowThreads();
9766 (arg1)->Save(*arg2);
9767 wxPyEndAllowThreads(__tstate);
9768 if (PyErr_Occurred()) SWIG_fail;
9769 }
9770 resultobj = SWIG_Py_Void();
9771 return resultobj;
9772 fail:
9773 return NULL;
9774 }
9775
9776
9777 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9778 PyObject *resultobj = 0;
9779 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9780 void *argp1 = 0 ;
9781 int res1 = 0 ;
9782 PyObject *swig_obj[1] ;
9783
9784 if (!args) SWIG_fail;
9785 swig_obj[0] = args;
9786 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9787 if (!SWIG_IsOK(res1)) {
9788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9789 }
9790 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9791 {
9792 PyThreadState* __tstate = wxPyBeginAllowThreads();
9793 (arg1)->AddFilesToMenu();
9794 wxPyEndAllowThreads(__tstate);
9795 if (PyErr_Occurred()) SWIG_fail;
9796 }
9797 resultobj = SWIG_Py_Void();
9798 return resultobj;
9799 fail:
9800 return NULL;
9801 }
9802
9803
9804 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9805 PyObject *resultobj = 0;
9806 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9807 wxMenu *arg2 = (wxMenu *) 0 ;
9808 void *argp1 = 0 ;
9809 int res1 = 0 ;
9810 void *argp2 = 0 ;
9811 int res2 = 0 ;
9812 PyObject * obj0 = 0 ;
9813 PyObject * obj1 = 0 ;
9814 char * kwnames[] = {
9815 (char *) "self",(char *) "menu", NULL
9816 };
9817
9818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9819 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9820 if (!SWIG_IsOK(res1)) {
9821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9822 }
9823 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9824 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9825 if (!SWIG_IsOK(res2)) {
9826 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9827 }
9828 arg2 = reinterpret_cast< wxMenu * >(argp2);
9829 {
9830 PyThreadState* __tstate = wxPyBeginAllowThreads();
9831 (arg1)->AddFilesToMenu(arg2);
9832 wxPyEndAllowThreads(__tstate);
9833 if (PyErr_Occurred()) SWIG_fail;
9834 }
9835 resultobj = SWIG_Py_Void();
9836 return resultobj;
9837 fail:
9838 return NULL;
9839 }
9840
9841
9842 SWIGINTERN PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9843 PyObject *resultobj = 0;
9844 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9845 int arg2 ;
9846 wxString result;
9847 void *argp1 = 0 ;
9848 int res1 = 0 ;
9849 int val2 ;
9850 int ecode2 = 0 ;
9851 PyObject * obj0 = 0 ;
9852 PyObject * obj1 = 0 ;
9853 char * kwnames[] = {
9854 (char *) "self",(char *) "i", NULL
9855 };
9856
9857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) SWIG_fail;
9858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9859 if (!SWIG_IsOK(res1)) {
9860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9861 }
9862 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9863 ecode2 = SWIG_AsVal_int(obj1, &val2);
9864 if (!SWIG_IsOK(ecode2)) {
9865 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "2"" of type '" "int""'");
9866 }
9867 arg2 = static_cast< int >(val2);
9868 {
9869 PyThreadState* __tstate = wxPyBeginAllowThreads();
9870 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
9871 wxPyEndAllowThreads(__tstate);
9872 if (PyErr_Occurred()) SWIG_fail;
9873 }
9874 {
9875 #if wxUSE_UNICODE
9876 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9877 #else
9878 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9879 #endif
9880 }
9881 return resultobj;
9882 fail:
9883 return NULL;
9884 }
9885
9886
9887 SWIGINTERN PyObject *_wrap_FileHistory_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9888 PyObject *resultobj = 0;
9889 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9890 int result;
9891 void *argp1 = 0 ;
9892 int res1 = 0 ;
9893 PyObject *swig_obj[1] ;
9894
9895 if (!args) SWIG_fail;
9896 swig_obj[0] = args;
9897 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9898 if (!SWIG_IsOK(res1)) {
9899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetCount" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9900 }
9901 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9902 {
9903 PyThreadState* __tstate = wxPyBeginAllowThreads();
9904 result = (int)((wxFileHistory const *)arg1)->GetCount();
9905 wxPyEndAllowThreads(__tstate);
9906 if (PyErr_Occurred()) SWIG_fail;
9907 }
9908 resultobj = SWIG_From_int(static_cast< int >(result));
9909 return resultobj;
9910 fail:
9911 return NULL;
9912 }
9913
9914
9915 SWIGINTERN PyObject *FileHistory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9916 PyObject *obj;
9917 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9918 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileHistory, SWIG_NewClientData(obj));
9919 return SWIG_Py_Void();
9920 }
9921
9922 SWIGINTERN PyObject *FileHistory_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9923 return SWIG_Python_InitShadowInstance(args);
9924 }
9925
9926 SWIGINTERN PyObject *_wrap_new_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9927 PyObject *resultobj = 0;
9928 wxString *arg1 = 0 ;
9929 wxString const &arg2_defvalue = wxPyEmptyString ;
9930 wxString *arg2 = (wxString *) &arg2_defvalue ;
9931 wxSingleInstanceChecker *result = 0 ;
9932 bool temp1 = false ;
9933 bool temp2 = false ;
9934 PyObject * obj0 = 0 ;
9935 PyObject * obj1 = 0 ;
9936 char * kwnames[] = {
9937 (char *) "name",(char *) "path", NULL
9938 };
9939
9940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) SWIG_fail;
9941 {
9942 arg1 = wxString_in_helper(obj0);
9943 if (arg1 == NULL) SWIG_fail;
9944 temp1 = true;
9945 }
9946 if (obj1) {
9947 {
9948 arg2 = wxString_in_helper(obj1);
9949 if (arg2 == NULL) SWIG_fail;
9950 temp2 = true;
9951 }
9952 }
9953 {
9954 PyThreadState* __tstate = wxPyBeginAllowThreads();
9955 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
9956 wxPyEndAllowThreads(__tstate);
9957 if (PyErr_Occurred()) SWIG_fail;
9958 }
9959 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_NEW | 0 );
9960 {
9961 if (temp1)
9962 delete arg1;
9963 }
9964 {
9965 if (temp2)
9966 delete arg2;
9967 }
9968 return resultobj;
9969 fail:
9970 {
9971 if (temp1)
9972 delete arg1;
9973 }
9974 {
9975 if (temp2)
9976 delete arg2;
9977 }
9978 return NULL;
9979 }
9980
9981
9982 SWIGINTERN PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9983 PyObject *resultobj = 0;
9984 wxSingleInstanceChecker *result = 0 ;
9985
9986 if (!SWIG_Python_UnpackTuple(args,"new_PreSingleInstanceChecker",0,0,0)) SWIG_fail;
9987 {
9988 PyThreadState* __tstate = wxPyBeginAllowThreads();
9989 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
9990 wxPyEndAllowThreads(__tstate);
9991 if (PyErr_Occurred()) SWIG_fail;
9992 }
9993 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_OWN | 0 );
9994 return resultobj;
9995 fail:
9996 return NULL;
9997 }
9998
9999
10000 SWIGINTERN PyObject *_wrap_delete_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10001 PyObject *resultobj = 0;
10002 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
10003 void *argp1 = 0 ;
10004 int res1 = 0 ;
10005 PyObject *swig_obj[1] ;
10006
10007 if (!args) SWIG_fail;
10008 swig_obj[0] = args;
10009 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_DISOWN | 0 );
10010 if (!SWIG_IsOK(res1)) {
10011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SingleInstanceChecker" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
10012 }
10013 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
10014 {
10015 PyThreadState* __tstate = wxPyBeginAllowThreads();
10016 delete arg1;
10017
10018 wxPyEndAllowThreads(__tstate);
10019 if (PyErr_Occurred()) SWIG_fail;
10020 }
10021 resultobj = SWIG_Py_Void();
10022 return resultobj;
10023 fail:
10024 return NULL;
10025 }
10026
10027
10028 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10029 PyObject *resultobj = 0;
10030 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
10031 wxString *arg2 = 0 ;
10032 wxString const &arg3_defvalue = wxPyEmptyString ;
10033 wxString *arg3 = (wxString *) &arg3_defvalue ;
10034 bool result;
10035 void *argp1 = 0 ;
10036 int res1 = 0 ;
10037 bool temp2 = false ;
10038 bool temp3 = false ;
10039 PyObject * obj0 = 0 ;
10040 PyObject * obj1 = 0 ;
10041 PyObject * obj2 = 0 ;
10042 char * kwnames[] = {
10043 (char *) "self",(char *) "name",(char *) "path", NULL
10044 };
10045
10046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
10048 if (!SWIG_IsOK(res1)) {
10049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_Create" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
10050 }
10051 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
10052 {
10053 arg2 = wxString_in_helper(obj1);
10054 if (arg2 == NULL) SWIG_fail;
10055 temp2 = true;
10056 }
10057 if (obj2) {
10058 {
10059 arg3 = wxString_in_helper(obj2);
10060 if (arg3 == NULL) SWIG_fail;
10061 temp3 = true;
10062 }
10063 }
10064 {
10065 PyThreadState* __tstate = wxPyBeginAllowThreads();
10066 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
10067 wxPyEndAllowThreads(__tstate);
10068 if (PyErr_Occurred()) SWIG_fail;
10069 }
10070 {
10071 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10072 }
10073 {
10074 if (temp2)
10075 delete arg2;
10076 }
10077 {
10078 if (temp3)
10079 delete arg3;
10080 }
10081 return resultobj;
10082 fail:
10083 {
10084 if (temp2)
10085 delete arg2;
10086 }
10087 {
10088 if (temp3)
10089 delete arg3;
10090 }
10091 return NULL;
10092 }
10093
10094
10095 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10096 PyObject *resultobj = 0;
10097 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
10098 bool result;
10099 void *argp1 = 0 ;
10100 int res1 = 0 ;
10101 PyObject *swig_obj[1] ;
10102
10103 if (!args) SWIG_fail;
10104 swig_obj[0] = args;
10105 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
10106 if (!SWIG_IsOK(res1)) {
10107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_IsAnotherRunning" "', expected argument " "1"" of type '" "wxSingleInstanceChecker const *""'");
10108 }
10109 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
10110 {
10111 PyThreadState* __tstate = wxPyBeginAllowThreads();
10112 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
10113 wxPyEndAllowThreads(__tstate);
10114 if (PyErr_Occurred()) SWIG_fail;
10115 }
10116 {
10117 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10118 }
10119 return resultobj;
10120 fail:
10121 return NULL;
10122 }
10123
10124
10125 SWIGINTERN PyObject *SingleInstanceChecker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10126 PyObject *obj;
10127 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10128 SWIG_TypeNewClientData(SWIGTYPE_p_wxSingleInstanceChecker, SWIG_NewClientData(obj));
10129 return SWIG_Py_Void();
10130 }
10131
10132 SWIGINTERN PyObject *SingleInstanceChecker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10133 return SWIG_Python_InitShadowInstance(args);
10134 }
10135
10136 SWIGINTERN PyObject *_wrap_new_PlatformInformation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10137 PyObject *resultobj = 0;
10138 wxPlatformInfo *result = 0 ;
10139
10140 if (!SWIG_Python_UnpackTuple(args,"new_PlatformInformation",0,0,0)) SWIG_fail;
10141 {
10142 PyThreadState* __tstate = wxPyBeginAllowThreads();
10143 result = (wxPlatformInfo *)new wxPlatformInfo();
10144 wxPyEndAllowThreads(__tstate);
10145 if (PyErr_Occurred()) SWIG_fail;
10146 }
10147 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPlatformInfo, SWIG_POINTER_NEW | 0 );
10148 return resultobj;
10149 fail:
10150 return NULL;
10151 }
10152
10153
10154 SWIGINTERN PyObject *_wrap_PlatformInformation___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10155 PyObject *resultobj = 0;
10156 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10157 wxPlatformInfo *arg2 = 0 ;
10158 bool result;
10159 void *argp1 = 0 ;
10160 int res1 = 0 ;
10161 void *argp2 = 0 ;
10162 int res2 = 0 ;
10163 PyObject * obj0 = 0 ;
10164 PyObject * obj1 = 0 ;
10165 char * kwnames[] = {
10166 (char *) "self",(char *) "t", NULL
10167 };
10168
10169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
10170 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10171 if (!SWIG_IsOK(res1)) {
10172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation___eq__" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10173 }
10174 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10175 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPlatformInfo, 0 | 0);
10176 if (!SWIG_IsOK(res2)) {
10177 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PlatformInformation___eq__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10178 }
10179 if (!argp2) {
10180 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PlatformInformation___eq__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10181 }
10182 arg2 = reinterpret_cast< wxPlatformInfo * >(argp2);
10183 {
10184 PyThreadState* __tstate = wxPyBeginAllowThreads();
10185 result = (bool)((wxPlatformInfo const *)arg1)->operator ==((wxPlatformInfo const &)*arg2);
10186 wxPyEndAllowThreads(__tstate);
10187 if (PyErr_Occurred()) SWIG_fail;
10188 }
10189 {
10190 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10191 }
10192 return resultobj;
10193 fail:
10194 return NULL;
10195 }
10196
10197
10198 SWIGINTERN PyObject *_wrap_PlatformInformation___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10199 PyObject *resultobj = 0;
10200 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10201 wxPlatformInfo *arg2 = 0 ;
10202 bool result;
10203 void *argp1 = 0 ;
10204 int res1 = 0 ;
10205 void *argp2 = 0 ;
10206 int res2 = 0 ;
10207 PyObject * obj0 = 0 ;
10208 PyObject * obj1 = 0 ;
10209 char * kwnames[] = {
10210 (char *) "self",(char *) "t", NULL
10211 };
10212
10213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
10214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10215 if (!SWIG_IsOK(res1)) {
10216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation___ne__" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10217 }
10218 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10219 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPlatformInfo, 0 | 0);
10220 if (!SWIG_IsOK(res2)) {
10221 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PlatformInformation___ne__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10222 }
10223 if (!argp2) {
10224 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PlatformInformation___ne__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10225 }
10226 arg2 = reinterpret_cast< wxPlatformInfo * >(argp2);
10227 {
10228 PyThreadState* __tstate = wxPyBeginAllowThreads();
10229 result = (bool)((wxPlatformInfo const *)arg1)->operator !=((wxPlatformInfo const &)*arg2);
10230 wxPyEndAllowThreads(__tstate);
10231 if (PyErr_Occurred()) SWIG_fail;
10232 }
10233 {
10234 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10235 }
10236 return resultobj;
10237 fail:
10238 return NULL;
10239 }
10240
10241
10242 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOSMajorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10243 PyObject *resultobj = 0;
10244 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10245 int result;
10246 void *argp1 = 0 ;
10247 int res1 = 0 ;
10248 PyObject *swig_obj[1] ;
10249
10250 if (!args) SWIG_fail;
10251 swig_obj[0] = args;
10252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10253 if (!SWIG_IsOK(res1)) {
10254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOSMajorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10255 }
10256 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10257 {
10258 PyThreadState* __tstate = wxPyBeginAllowThreads();
10259 result = (int)((wxPlatformInfo const *)arg1)->GetOSMajorVersion();
10260 wxPyEndAllowThreads(__tstate);
10261 if (PyErr_Occurred()) SWIG_fail;
10262 }
10263 resultobj = SWIG_From_int(static_cast< int >(result));
10264 return resultobj;
10265 fail:
10266 return NULL;
10267 }
10268
10269
10270 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOSMinorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10271 PyObject *resultobj = 0;
10272 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10273 int result;
10274 void *argp1 = 0 ;
10275 int res1 = 0 ;
10276 PyObject *swig_obj[1] ;
10277
10278 if (!args) SWIG_fail;
10279 swig_obj[0] = args;
10280 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10281 if (!SWIG_IsOK(res1)) {
10282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOSMinorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10283 }
10284 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10285 {
10286 PyThreadState* __tstate = wxPyBeginAllowThreads();
10287 result = (int)((wxPlatformInfo const *)arg1)->GetOSMinorVersion();
10288 wxPyEndAllowThreads(__tstate);
10289 if (PyErr_Occurred()) SWIG_fail;
10290 }
10291 resultobj = SWIG_From_int(static_cast< int >(result));
10292 return resultobj;
10293 fail:
10294 return NULL;
10295 }
10296
10297
10298 SWIGINTERN PyObject *_wrap_PlatformInformation_CheckOSVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10299 PyObject *resultobj = 0;
10300 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10301 int arg2 ;
10302 int arg3 ;
10303 bool result;
10304 void *argp1 = 0 ;
10305 int res1 = 0 ;
10306 int val2 ;
10307 int ecode2 = 0 ;
10308 int val3 ;
10309 int ecode3 = 0 ;
10310 PyObject * obj0 = 0 ;
10311 PyObject * obj1 = 0 ;
10312 PyObject * obj2 = 0 ;
10313 char * kwnames[] = {
10314 (char *) "self",(char *) "major",(char *) "minor", NULL
10315 };
10316
10317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_CheckOSVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10318 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10319 if (!SWIG_IsOK(res1)) {
10320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_CheckOSVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10321 }
10322 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10323 ecode2 = SWIG_AsVal_int(obj1, &val2);
10324 if (!SWIG_IsOK(ecode2)) {
10325 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_CheckOSVersion" "', expected argument " "2"" of type '" "int""'");
10326 }
10327 arg2 = static_cast< int >(val2);
10328 ecode3 = SWIG_AsVal_int(obj2, &val3);
10329 if (!SWIG_IsOK(ecode3)) {
10330 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_CheckOSVersion" "', expected argument " "3"" of type '" "int""'");
10331 }
10332 arg3 = static_cast< int >(val3);
10333 {
10334 PyThreadState* __tstate = wxPyBeginAllowThreads();
10335 result = (bool)((wxPlatformInfo const *)arg1)->CheckOSVersion(arg2,arg3);
10336 wxPyEndAllowThreads(__tstate);
10337 if (PyErr_Occurred()) SWIG_fail;
10338 }
10339 {
10340 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10341 }
10342 return resultobj;
10343 fail:
10344 return NULL;
10345 }
10346
10347
10348 SWIGINTERN PyObject *_wrap_PlatformInformation_GetToolkitMajorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10349 PyObject *resultobj = 0;
10350 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10351 int result;
10352 void *argp1 = 0 ;
10353 int res1 = 0 ;
10354 PyObject *swig_obj[1] ;
10355
10356 if (!args) SWIG_fail;
10357 swig_obj[0] = args;
10358 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10359 if (!SWIG_IsOK(res1)) {
10360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetToolkitMajorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10361 }
10362 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10363 {
10364 PyThreadState* __tstate = wxPyBeginAllowThreads();
10365 result = (int)((wxPlatformInfo const *)arg1)->GetToolkitMajorVersion();
10366 wxPyEndAllowThreads(__tstate);
10367 if (PyErr_Occurred()) SWIG_fail;
10368 }
10369 resultobj = SWIG_From_int(static_cast< int >(result));
10370 return resultobj;
10371 fail:
10372 return NULL;
10373 }
10374
10375
10376 SWIGINTERN PyObject *_wrap_PlatformInformation_GetToolkitMinorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10377 PyObject *resultobj = 0;
10378 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10379 int result;
10380 void *argp1 = 0 ;
10381 int res1 = 0 ;
10382 PyObject *swig_obj[1] ;
10383
10384 if (!args) SWIG_fail;
10385 swig_obj[0] = args;
10386 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10387 if (!SWIG_IsOK(res1)) {
10388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetToolkitMinorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10389 }
10390 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10391 {
10392 PyThreadState* __tstate = wxPyBeginAllowThreads();
10393 result = (int)((wxPlatformInfo const *)arg1)->GetToolkitMinorVersion();
10394 wxPyEndAllowThreads(__tstate);
10395 if (PyErr_Occurred()) SWIG_fail;
10396 }
10397 resultobj = SWIG_From_int(static_cast< int >(result));
10398 return resultobj;
10399 fail:
10400 return NULL;
10401 }
10402
10403
10404 SWIGINTERN PyObject *_wrap_PlatformInformation_CheckToolkitVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10405 PyObject *resultobj = 0;
10406 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10407 int arg2 ;
10408 int arg3 ;
10409 bool result;
10410 void *argp1 = 0 ;
10411 int res1 = 0 ;
10412 int val2 ;
10413 int ecode2 = 0 ;
10414 int val3 ;
10415 int ecode3 = 0 ;
10416 PyObject * obj0 = 0 ;
10417 PyObject * obj1 = 0 ;
10418 PyObject * obj2 = 0 ;
10419 char * kwnames[] = {
10420 (char *) "self",(char *) "major",(char *) "minor", NULL
10421 };
10422
10423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_CheckToolkitVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10424 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10425 if (!SWIG_IsOK(res1)) {
10426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_CheckToolkitVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10427 }
10428 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10429 ecode2 = SWIG_AsVal_int(obj1, &val2);
10430 if (!SWIG_IsOK(ecode2)) {
10431 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_CheckToolkitVersion" "', expected argument " "2"" of type '" "int""'");
10432 }
10433 arg2 = static_cast< int >(val2);
10434 ecode3 = SWIG_AsVal_int(obj2, &val3);
10435 if (!SWIG_IsOK(ecode3)) {
10436 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_CheckToolkitVersion" "', expected argument " "3"" of type '" "int""'");
10437 }
10438 arg3 = static_cast< int >(val3);
10439 {
10440 PyThreadState* __tstate = wxPyBeginAllowThreads();
10441 result = (bool)((wxPlatformInfo const *)arg1)->CheckToolkitVersion(arg2,arg3);
10442 wxPyEndAllowThreads(__tstate);
10443 if (PyErr_Occurred()) SWIG_fail;
10444 }
10445 {
10446 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10447 }
10448 return resultobj;
10449 fail:
10450 return NULL;
10451 }
10452
10453
10454 SWIGINTERN PyObject *_wrap_PlatformInformation_IsUsingUniversalWidgets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10455 PyObject *resultobj = 0;
10456 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10457 bool result;
10458 void *argp1 = 0 ;
10459 int res1 = 0 ;
10460 PyObject *swig_obj[1] ;
10461
10462 if (!args) SWIG_fail;
10463 swig_obj[0] = args;
10464 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10465 if (!SWIG_IsOK(res1)) {
10466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_IsUsingUniversalWidgets" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10467 }
10468 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10469 {
10470 PyThreadState* __tstate = wxPyBeginAllowThreads();
10471 result = (bool)((wxPlatformInfo const *)arg1)->IsUsingUniversalWidgets();
10472 wxPyEndAllowThreads(__tstate);
10473 if (PyErr_Occurred()) SWIG_fail;
10474 }
10475 {
10476 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10477 }
10478 return resultobj;
10479 fail:
10480 return NULL;
10481 }
10482
10483
10484 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10485 PyObject *resultobj = 0;
10486 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10487 wxOperatingSystemId result;
10488 void *argp1 = 0 ;
10489 int res1 = 0 ;
10490 PyObject *swig_obj[1] ;
10491
10492 if (!args) SWIG_fail;
10493 swig_obj[0] = args;
10494 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10495 if (!SWIG_IsOK(res1)) {
10496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOperatingSystemId" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10497 }
10498 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10499 {
10500 PyThreadState* __tstate = wxPyBeginAllowThreads();
10501 result = (wxOperatingSystemId)((wxPlatformInfo const *)arg1)->GetOperatingSystemId();
10502 wxPyEndAllowThreads(__tstate);
10503 if (PyErr_Occurred()) SWIG_fail;
10504 }
10505 resultobj = SWIG_From_int(static_cast< int >(result));
10506 return resultobj;
10507 fail:
10508 return NULL;
10509 }
10510
10511
10512 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10513 PyObject *resultobj = 0;
10514 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10515 wxPortId result;
10516 void *argp1 = 0 ;
10517 int res1 = 0 ;
10518 PyObject *swig_obj[1] ;
10519
10520 if (!args) SWIG_fail;
10521 swig_obj[0] = args;
10522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10523 if (!SWIG_IsOK(res1)) {
10524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortId" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10525 }
10526 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10527 {
10528 PyThreadState* __tstate = wxPyBeginAllowThreads();
10529 result = (wxPortId)((wxPlatformInfo const *)arg1)->GetPortId();
10530 wxPyEndAllowThreads(__tstate);
10531 if (PyErr_Occurred()) SWIG_fail;
10532 }
10533 resultobj = SWIG_From_int(static_cast< int >(result));
10534 return resultobj;
10535 fail:
10536 return NULL;
10537 }
10538
10539
10540 SWIGINTERN PyObject *_wrap_PlatformInformation_GetArchitecture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10541 PyObject *resultobj = 0;
10542 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10543 wxArchitecture result;
10544 void *argp1 = 0 ;
10545 int res1 = 0 ;
10546 PyObject *swig_obj[1] ;
10547
10548 if (!args) SWIG_fail;
10549 swig_obj[0] = args;
10550 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10551 if (!SWIG_IsOK(res1)) {
10552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetArchitecture" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10553 }
10554 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10555 {
10556 PyThreadState* __tstate = wxPyBeginAllowThreads();
10557 result = (wxArchitecture)((wxPlatformInfo const *)arg1)->GetArchitecture();
10558 wxPyEndAllowThreads(__tstate);
10559 if (PyErr_Occurred()) SWIG_fail;
10560 }
10561 resultobj = SWIG_From_int(static_cast< int >(result));
10562 return resultobj;
10563 fail:
10564 return NULL;
10565 }
10566
10567
10568 SWIGINTERN PyObject *_wrap_PlatformInformation_GetEndianness(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10569 PyObject *resultobj = 0;
10570 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10571 wxEndianness result;
10572 void *argp1 = 0 ;
10573 int res1 = 0 ;
10574 PyObject *swig_obj[1] ;
10575
10576 if (!args) SWIG_fail;
10577 swig_obj[0] = args;
10578 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10579 if (!SWIG_IsOK(res1)) {
10580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetEndianness" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10581 }
10582 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10583 {
10584 PyThreadState* __tstate = wxPyBeginAllowThreads();
10585 result = (wxEndianness)((wxPlatformInfo const *)arg1)->GetEndianness();
10586 wxPyEndAllowThreads(__tstate);
10587 if (PyErr_Occurred()) SWIG_fail;
10588 }
10589 resultobj = SWIG_From_int(static_cast< int >(result));
10590 return resultobj;
10591 fail:
10592 return NULL;
10593 }
10594
10595
10596 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemFamilyName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10597 PyObject *resultobj = 0;
10598 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10599 wxString result;
10600 void *argp1 = 0 ;
10601 int res1 = 0 ;
10602 PyObject *swig_obj[1] ;
10603
10604 if (!args) SWIG_fail;
10605 swig_obj[0] = args;
10606 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10607 if (!SWIG_IsOK(res1)) {
10608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOperatingSystemFamilyName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10609 }
10610 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10611 {
10612 PyThreadState* __tstate = wxPyBeginAllowThreads();
10613 result = ((wxPlatformInfo const *)arg1)->GetOperatingSystemFamilyName();
10614 wxPyEndAllowThreads(__tstate);
10615 if (PyErr_Occurred()) SWIG_fail;
10616 }
10617 {
10618 #if wxUSE_UNICODE
10619 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10620 #else
10621 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10622 #endif
10623 }
10624 return resultobj;
10625 fail:
10626 return NULL;
10627 }
10628
10629
10630 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemIdName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10631 PyObject *resultobj = 0;
10632 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10633 wxString result;
10634 void *argp1 = 0 ;
10635 int res1 = 0 ;
10636 PyObject *swig_obj[1] ;
10637
10638 if (!args) SWIG_fail;
10639 swig_obj[0] = args;
10640 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10641 if (!SWIG_IsOK(res1)) {
10642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOperatingSystemIdName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10643 }
10644 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10645 {
10646 PyThreadState* __tstate = wxPyBeginAllowThreads();
10647 result = ((wxPlatformInfo const *)arg1)->GetOperatingSystemIdName();
10648 wxPyEndAllowThreads(__tstate);
10649 if (PyErr_Occurred()) SWIG_fail;
10650 }
10651 {
10652 #if wxUSE_UNICODE
10653 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10654 #else
10655 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10656 #endif
10657 }
10658 return resultobj;
10659 fail:
10660 return NULL;
10661 }
10662
10663
10664 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortIdName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10665 PyObject *resultobj = 0;
10666 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10667 wxString result;
10668 void *argp1 = 0 ;
10669 int res1 = 0 ;
10670 PyObject *swig_obj[1] ;
10671
10672 if (!args) SWIG_fail;
10673 swig_obj[0] = args;
10674 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10675 if (!SWIG_IsOK(res1)) {
10676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortIdName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10677 }
10678 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10679 {
10680 PyThreadState* __tstate = wxPyBeginAllowThreads();
10681 result = ((wxPlatformInfo const *)arg1)->GetPortIdName();
10682 wxPyEndAllowThreads(__tstate);
10683 if (PyErr_Occurred()) SWIG_fail;
10684 }
10685 {
10686 #if wxUSE_UNICODE
10687 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10688 #else
10689 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10690 #endif
10691 }
10692 return resultobj;
10693 fail:
10694 return NULL;
10695 }
10696
10697
10698 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortIdShortName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10699 PyObject *resultobj = 0;
10700 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10701 wxString result;
10702 void *argp1 = 0 ;
10703 int res1 = 0 ;
10704 PyObject *swig_obj[1] ;
10705
10706 if (!args) SWIG_fail;
10707 swig_obj[0] = args;
10708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10709 if (!SWIG_IsOK(res1)) {
10710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortIdShortName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10711 }
10712 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10713 {
10714 PyThreadState* __tstate = wxPyBeginAllowThreads();
10715 result = ((wxPlatformInfo const *)arg1)->GetPortIdShortName();
10716 wxPyEndAllowThreads(__tstate);
10717 if (PyErr_Occurred()) SWIG_fail;
10718 }
10719 {
10720 #if wxUSE_UNICODE
10721 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10722 #else
10723 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10724 #endif
10725 }
10726 return resultobj;
10727 fail:
10728 return NULL;
10729 }
10730
10731
10732 SWIGINTERN PyObject *_wrap_PlatformInformation_GetArchName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10733 PyObject *resultobj = 0;
10734 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10735 wxString result;
10736 void *argp1 = 0 ;
10737 int res1 = 0 ;
10738 PyObject *swig_obj[1] ;
10739
10740 if (!args) SWIG_fail;
10741 swig_obj[0] = args;
10742 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10743 if (!SWIG_IsOK(res1)) {
10744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetArchName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10745 }
10746 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10747 {
10748 PyThreadState* __tstate = wxPyBeginAllowThreads();
10749 result = ((wxPlatformInfo const *)arg1)->GetArchName();
10750 wxPyEndAllowThreads(__tstate);
10751 if (PyErr_Occurred()) SWIG_fail;
10752 }
10753 {
10754 #if wxUSE_UNICODE
10755 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10756 #else
10757 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10758 #endif
10759 }
10760 return resultobj;
10761 fail:
10762 return NULL;
10763 }
10764
10765
10766 SWIGINTERN PyObject *_wrap_PlatformInformation_GetEndiannessName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10767 PyObject *resultobj = 0;
10768 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10769 wxString result;
10770 void *argp1 = 0 ;
10771 int res1 = 0 ;
10772 PyObject *swig_obj[1] ;
10773
10774 if (!args) SWIG_fail;
10775 swig_obj[0] = args;
10776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10777 if (!SWIG_IsOK(res1)) {
10778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetEndiannessName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10779 }
10780 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10781 {
10782 PyThreadState* __tstate = wxPyBeginAllowThreads();
10783 result = ((wxPlatformInfo const *)arg1)->GetEndiannessName();
10784 wxPyEndAllowThreads(__tstate);
10785 if (PyErr_Occurred()) SWIG_fail;
10786 }
10787 {
10788 #if wxUSE_UNICODE
10789 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10790 #else
10791 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10792 #endif
10793 }
10794 return resultobj;
10795 fail:
10796 return NULL;
10797 }
10798
10799
10800 SWIGINTERN PyObject *_wrap_PlatformInformation_SetOSVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10801 PyObject *resultobj = 0;
10802 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10803 int arg2 ;
10804 int arg3 ;
10805 void *argp1 = 0 ;
10806 int res1 = 0 ;
10807 int val2 ;
10808 int ecode2 = 0 ;
10809 int val3 ;
10810 int ecode3 = 0 ;
10811 PyObject * obj0 = 0 ;
10812 PyObject * obj1 = 0 ;
10813 PyObject * obj2 = 0 ;
10814 char * kwnames[] = {
10815 (char *) "self",(char *) "major",(char *) "minor", NULL
10816 };
10817
10818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_SetOSVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10819 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10820 if (!SWIG_IsOK(res1)) {
10821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10822 }
10823 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10824 ecode2 = SWIG_AsVal_int(obj1, &val2);
10825 if (!SWIG_IsOK(ecode2)) {
10826 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "2"" of type '" "int""'");
10827 }
10828 arg2 = static_cast< int >(val2);
10829 ecode3 = SWIG_AsVal_int(obj2, &val3);
10830 if (!SWIG_IsOK(ecode3)) {
10831 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "3"" of type '" "int""'");
10832 }
10833 arg3 = static_cast< int >(val3);
10834 {
10835 PyThreadState* __tstate = wxPyBeginAllowThreads();
10836 (arg1)->SetOSVersion(arg2,arg3);
10837 wxPyEndAllowThreads(__tstate);
10838 if (PyErr_Occurred()) SWIG_fail;
10839 }
10840 resultobj = SWIG_Py_Void();
10841 return resultobj;
10842 fail:
10843 return NULL;
10844 }
10845
10846
10847 SWIGINTERN PyObject *_wrap_PlatformInformation_SetToolkitVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10848 PyObject *resultobj = 0;
10849 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10850 int arg2 ;
10851 int arg3 ;
10852 void *argp1 = 0 ;
10853 int res1 = 0 ;
10854 int val2 ;
10855 int ecode2 = 0 ;
10856 int val3 ;
10857 int ecode3 = 0 ;
10858 PyObject * obj0 = 0 ;
10859 PyObject * obj1 = 0 ;
10860 PyObject * obj2 = 0 ;
10861 char * kwnames[] = {
10862 (char *) "self",(char *) "major",(char *) "minor", NULL
10863 };
10864
10865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_SetToolkitVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10866 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10867 if (!SWIG_IsOK(res1)) {
10868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetToolkitVersion" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10869 }
10870 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10871 ecode2 = SWIG_AsVal_int(obj1, &val2);
10872 if (!SWIG_IsOK(ecode2)) {
10873 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetToolkitVersion" "', expected argument " "2"" of type '" "int""'");
10874 }
10875 arg2 = static_cast< int >(val2);
10876 ecode3 = SWIG_AsVal_int(obj2, &val3);
10877 if (!SWIG_IsOK(ecode3)) {
10878 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_SetToolkitVersion" "', expected argument " "3"" of type '" "int""'");
10879 }
10880 arg3 = static_cast< int >(val3);
10881 {
10882 PyThreadState* __tstate = wxPyBeginAllowThreads();
10883 (arg1)->SetToolkitVersion(arg2,arg3);
10884 wxPyEndAllowThreads(__tstate);
10885 if (PyErr_Occurred()) SWIG_fail;
10886 }
10887 resultobj = SWIG_Py_Void();
10888 return resultobj;
10889 fail:
10890 return NULL;
10891 }
10892
10893
10894 SWIGINTERN PyObject *_wrap_PlatformInformation_SetOperatingSystemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10895 PyObject *resultobj = 0;
10896 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10897 wxOperatingSystemId arg2 ;
10898 void *argp1 = 0 ;
10899 int res1 = 0 ;
10900 int val2 ;
10901 int ecode2 = 0 ;
10902 PyObject * obj0 = 0 ;
10903 PyObject * obj1 = 0 ;
10904 char * kwnames[] = {
10905 (char *) "self",(char *) "n", NULL
10906 };
10907
10908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetOperatingSystemId",kwnames,&obj0,&obj1)) SWIG_fail;
10909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10910 if (!SWIG_IsOK(res1)) {
10911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetOperatingSystemId" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10912 }
10913 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10914 ecode2 = SWIG_AsVal_int(obj1, &val2);
10915 if (!SWIG_IsOK(ecode2)) {
10916 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetOperatingSystemId" "', expected argument " "2"" of type '" "wxOperatingSystemId""'");
10917 }
10918 arg2 = static_cast< wxOperatingSystemId >(val2);
10919 {
10920 PyThreadState* __tstate = wxPyBeginAllowThreads();
10921 (arg1)->SetOperatingSystemId(arg2);
10922 wxPyEndAllowThreads(__tstate);
10923 if (PyErr_Occurred()) SWIG_fail;
10924 }
10925 resultobj = SWIG_Py_Void();
10926 return resultobj;
10927 fail:
10928 return NULL;
10929 }
10930
10931
10932 SWIGINTERN PyObject *_wrap_PlatformInformation_SetPortId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10933 PyObject *resultobj = 0;
10934 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10935 wxPortId arg2 ;
10936 void *argp1 = 0 ;
10937 int res1 = 0 ;
10938 int val2 ;
10939 int ecode2 = 0 ;
10940 PyObject * obj0 = 0 ;
10941 PyObject * obj1 = 0 ;
10942 char * kwnames[] = {
10943 (char *) "self",(char *) "n", NULL
10944 };
10945
10946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetPortId",kwnames,&obj0,&obj1)) SWIG_fail;
10947 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10948 if (!SWIG_IsOK(res1)) {
10949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetPortId" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10950 }
10951 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10952 ecode2 = SWIG_AsVal_int(obj1, &val2);
10953 if (!SWIG_IsOK(ecode2)) {
10954 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetPortId" "', expected argument " "2"" of type '" "wxPortId""'");
10955 }
10956 arg2 = static_cast< wxPortId >(val2);
10957 {
10958 PyThreadState* __tstate = wxPyBeginAllowThreads();
10959 (arg1)->SetPortId(arg2);
10960 wxPyEndAllowThreads(__tstate);
10961 if (PyErr_Occurred()) SWIG_fail;
10962 }
10963 resultobj = SWIG_Py_Void();
10964 return resultobj;
10965 fail:
10966 return NULL;
10967 }
10968
10969
10970 SWIGINTERN PyObject *_wrap_PlatformInformation_SetArchitecture(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10971 PyObject *resultobj = 0;
10972 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10973 wxArchitecture arg2 ;
10974 void *argp1 = 0 ;
10975 int res1 = 0 ;
10976 int val2 ;
10977 int ecode2 = 0 ;
10978 PyObject * obj0 = 0 ;
10979 PyObject * obj1 = 0 ;
10980 char * kwnames[] = {
10981 (char *) "self",(char *) "n", NULL
10982 };
10983
10984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetArchitecture",kwnames,&obj0,&obj1)) SWIG_fail;
10985 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10986 if (!SWIG_IsOK(res1)) {
10987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetArchitecture" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10988 }
10989 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10990 ecode2 = SWIG_AsVal_int(obj1, &val2);
10991 if (!SWIG_IsOK(ecode2)) {
10992 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetArchitecture" "', expected argument " "2"" of type '" "wxArchitecture""'");
10993 }
10994 arg2 = static_cast< wxArchitecture >(val2);
10995 {
10996 PyThreadState* __tstate = wxPyBeginAllowThreads();
10997 (arg1)->SetArchitecture(arg2);
10998 wxPyEndAllowThreads(__tstate);
10999 if (PyErr_Occurred()) SWIG_fail;
11000 }
11001 resultobj = SWIG_Py_Void();
11002 return resultobj;
11003 fail:
11004 return NULL;
11005 }
11006
11007
11008 SWIGINTERN PyObject *_wrap_PlatformInformation_SetEndianness(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11009 PyObject *resultobj = 0;
11010 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
11011 wxEndianness arg2 ;
11012 void *argp1 = 0 ;
11013 int res1 = 0 ;
11014 int val2 ;
11015 int ecode2 = 0 ;
11016 PyObject * obj0 = 0 ;
11017 PyObject * obj1 = 0 ;
11018 char * kwnames[] = {
11019 (char *) "self",(char *) "n", NULL
11020 };
11021
11022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetEndianness",kwnames,&obj0,&obj1)) SWIG_fail;
11023 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
11024 if (!SWIG_IsOK(res1)) {
11025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetEndianness" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
11026 }
11027 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
11028 ecode2 = SWIG_AsVal_int(obj1, &val2);
11029 if (!SWIG_IsOK(ecode2)) {
11030 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetEndianness" "', expected argument " "2"" of type '" "wxEndianness""'");
11031 }
11032 arg2 = static_cast< wxEndianness >(val2);
11033 {
11034 PyThreadState* __tstate = wxPyBeginAllowThreads();
11035 (arg1)->SetEndianness(arg2);
11036 wxPyEndAllowThreads(__tstate);
11037 if (PyErr_Occurred()) SWIG_fail;
11038 }
11039 resultobj = SWIG_Py_Void();
11040 return resultobj;
11041 fail:
11042 return NULL;
11043 }
11044
11045
11046 SWIGINTERN PyObject *_wrap_PlatformInformation_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11047 PyObject *resultobj = 0;
11048 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
11049 bool result;
11050 void *argp1 = 0 ;
11051 int res1 = 0 ;
11052 PyObject *swig_obj[1] ;
11053
11054 if (!args) SWIG_fail;
11055 swig_obj[0] = args;
11056 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
11057 if (!SWIG_IsOK(res1)) {
11058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_IsOk" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
11059 }
11060 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
11061 {
11062 PyThreadState* __tstate = wxPyBeginAllowThreads();
11063 result = (bool)((wxPlatformInfo const *)arg1)->IsOk();
11064 wxPyEndAllowThreads(__tstate);
11065 if (PyErr_Occurred()) SWIG_fail;
11066 }
11067 {
11068 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11069 }
11070 return resultobj;
11071 fail:
11072 return NULL;
11073 }
11074
11075
11076 SWIGINTERN PyObject *PlatformInformation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11077 PyObject *obj;
11078 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11079 SWIG_TypeNewClientData(SWIGTYPE_p_wxPlatformInfo, SWIG_NewClientData(obj));
11080 return SWIG_Py_Void();
11081 }
11082
11083 SWIGINTERN PyObject *PlatformInformation_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11084 return SWIG_Python_InitShadowInstance(args);
11085 }
11086
11087 SWIGINTERN PyObject *_wrap_DrawWindowOnDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11088 PyObject *resultobj = 0;
11089 wxWindow *arg1 = (wxWindow *) 0 ;
11090 wxDC *arg2 = 0 ;
11091 bool result;
11092 void *argp1 = 0 ;
11093 int res1 = 0 ;
11094 void *argp2 = 0 ;
11095 int res2 = 0 ;
11096 PyObject * obj0 = 0 ;
11097 PyObject * obj1 = 0 ;
11098 char * kwnames[] = {
11099 (char *) "window",(char *) "dc", NULL
11100 };
11101
11102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DrawWindowOnDC",kwnames,&obj0,&obj1)) SWIG_fail;
11103 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
11104 if (!SWIG_IsOK(res1)) {
11105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DrawWindowOnDC" "', expected argument " "1"" of type '" "wxWindow *""'");
11106 }
11107 arg1 = reinterpret_cast< wxWindow * >(argp1);
11108 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
11109 if (!SWIG_IsOK(res2)) {
11110 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
11111 }
11112 if (!argp2) {
11113 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
11114 }
11115 arg2 = reinterpret_cast< wxDC * >(argp2);
11116 {
11117 PyThreadState* __tstate = wxPyBeginAllowThreads();
11118 result = (bool)wxDrawWindowOnDC(arg1,(wxDC const &)*arg2);
11119 wxPyEndAllowThreads(__tstate);
11120 if (PyErr_Occurred()) SWIG_fail;
11121 }
11122 {
11123 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11124 }
11125 return resultobj;
11126 fail:
11127 return NULL;
11128 }
11129
11130
11131 SWIGINTERN PyObject *_wrap_delete_TipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11132 PyObject *resultobj = 0;
11133 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11134 void *argp1 = 0 ;
11135 int res1 = 0 ;
11136 PyObject *swig_obj[1] ;
11137
11138 if (!args) SWIG_fail;
11139 swig_obj[0] = args;
11140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, SWIG_POINTER_DISOWN | 0 );
11141 if (!SWIG_IsOK(res1)) {
11142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TipProvider" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11143 }
11144 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11145 {
11146 PyThreadState* __tstate = wxPyBeginAllowThreads();
11147 delete arg1;
11148
11149 wxPyEndAllowThreads(__tstate);
11150 if (PyErr_Occurred()) SWIG_fail;
11151 }
11152 resultobj = SWIG_Py_Void();
11153 return resultobj;
11154 fail:
11155 return NULL;
11156 }
11157
11158
11159 SWIGINTERN PyObject *_wrap_TipProvider_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11160 PyObject *resultobj = 0;
11161 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11162 wxString result;
11163 void *argp1 = 0 ;
11164 int res1 = 0 ;
11165 PyObject *swig_obj[1] ;
11166
11167 if (!args) SWIG_fail;
11168 swig_obj[0] = args;
11169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11170 if (!SWIG_IsOK(res1)) {
11171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11172 }
11173 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11174 {
11175 PyThreadState* __tstate = wxPyBeginAllowThreads();
11176 result = (arg1)->GetTip();
11177 wxPyEndAllowThreads(__tstate);
11178 if (PyErr_Occurred()) SWIG_fail;
11179 }
11180 {
11181 #if wxUSE_UNICODE
11182 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11183 #else
11184 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11185 #endif
11186 }
11187 return resultobj;
11188 fail:
11189 return NULL;
11190 }
11191
11192
11193 SWIGINTERN PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11194 PyObject *resultobj = 0;
11195 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11196 size_t result;
11197 void *argp1 = 0 ;
11198 int res1 = 0 ;
11199 PyObject *swig_obj[1] ;
11200
11201 if (!args) SWIG_fail;
11202 swig_obj[0] = args;
11203 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11204 if (!SWIG_IsOK(res1)) {
11205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetCurrentTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11206 }
11207 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11208 {
11209 PyThreadState* __tstate = wxPyBeginAllowThreads();
11210 result = (size_t)(arg1)->GetCurrentTip();
11211 wxPyEndAllowThreads(__tstate);
11212 if (PyErr_Occurred()) SWIG_fail;
11213 }
11214 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
11215 return resultobj;
11216 fail:
11217 return NULL;
11218 }
11219
11220
11221 SWIGINTERN PyObject *_wrap_TipProvider_PreprocessTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11222 PyObject *resultobj = 0;
11223 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11224 wxString *arg2 = 0 ;
11225 wxString result;
11226 void *argp1 = 0 ;
11227 int res1 = 0 ;
11228 bool temp2 = false ;
11229 PyObject * obj0 = 0 ;
11230 PyObject * obj1 = 0 ;
11231 char * kwnames[] = {
11232 (char *) "self",(char *) "tip", NULL
11233 };
11234
11235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) SWIG_fail;
11236 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11237 if (!SWIG_IsOK(res1)) {
11238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_PreprocessTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11239 }
11240 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11241 {
11242 arg2 = wxString_in_helper(obj1);
11243 if (arg2 == NULL) SWIG_fail;
11244 temp2 = true;
11245 }
11246 {
11247 PyThreadState* __tstate = wxPyBeginAllowThreads();
11248 result = (arg1)->PreprocessTip((wxString const &)*arg2);
11249 wxPyEndAllowThreads(__tstate);
11250 if (PyErr_Occurred()) SWIG_fail;
11251 }
11252 {
11253 #if wxUSE_UNICODE
11254 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11255 #else
11256 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11257 #endif
11258 }
11259 {
11260 if (temp2)
11261 delete arg2;
11262 }
11263 return resultobj;
11264 fail:
11265 {
11266 if (temp2)
11267 delete arg2;
11268 }
11269 return NULL;
11270 }
11271
11272
11273 SWIGINTERN PyObject *TipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11274 PyObject *obj;
11275 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11276 SWIG_TypeNewClientData(SWIGTYPE_p_wxTipProvider, SWIG_NewClientData(obj));
11277 return SWIG_Py_Void();
11278 }
11279
11280 SWIGINTERN PyObject *_wrap_new_PyTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11281 PyObject *resultobj = 0;
11282 size_t arg1 ;
11283 wxPyTipProvider *result = 0 ;
11284 size_t val1 ;
11285 int ecode1 = 0 ;
11286 PyObject * obj0 = 0 ;
11287 char * kwnames[] = {
11288 (char *) "currentTip", NULL
11289 };
11290
11291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) SWIG_fail;
11292 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
11293 if (!SWIG_IsOK(ecode1)) {
11294 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyTipProvider" "', expected argument " "1"" of type '" "size_t""'");
11295 }
11296 arg1 = static_cast< size_t >(val1);
11297 {
11298 PyThreadState* __tstate = wxPyBeginAllowThreads();
11299 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
11300 wxPyEndAllowThreads(__tstate);
11301 if (PyErr_Occurred()) SWIG_fail;
11302 }
11303 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_NEW | 0 );
11304 return resultobj;
11305 fail:
11306 return NULL;
11307 }
11308
11309
11310 SWIGINTERN PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11311 PyObject *resultobj = 0;
11312 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
11313 PyObject *arg2 = (PyObject *) 0 ;
11314 PyObject *arg3 = (PyObject *) 0 ;
11315 void *argp1 = 0 ;
11316 int res1 = 0 ;
11317 PyObject * obj0 = 0 ;
11318 PyObject * obj1 = 0 ;
11319 PyObject * obj2 = 0 ;
11320 char * kwnames[] = {
11321 (char *) "self",(char *) "self",(char *) "_class", NULL
11322 };
11323
11324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11325 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTipProvider, 0 | 0 );
11326 if (!SWIG_IsOK(res1)) {
11327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTipProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTipProvider *""'");
11328 }
11329 arg1 = reinterpret_cast< wxPyTipProvider * >(argp1);
11330 arg2 = obj1;
11331 arg3 = obj2;
11332 {
11333 PyThreadState* __tstate = wxPyBeginAllowThreads();
11334 (arg1)->_setCallbackInfo(arg2,arg3);
11335 wxPyEndAllowThreads(__tstate);
11336 if (PyErr_Occurred()) SWIG_fail;
11337 }
11338 resultobj = SWIG_Py_Void();
11339 return resultobj;
11340 fail:
11341 return NULL;
11342 }
11343
11344
11345 SWIGINTERN PyObject *PyTipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11346 PyObject *obj;
11347 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11348 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTipProvider, SWIG_NewClientData(obj));
11349 return SWIG_Py_Void();
11350 }
11351
11352 SWIGINTERN PyObject *PyTipProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11353 return SWIG_Python_InitShadowInstance(args);
11354 }
11355
11356 SWIGINTERN PyObject *_wrap_ShowTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11357 PyObject *resultobj = 0;
11358 wxWindow *arg1 = (wxWindow *) 0 ;
11359 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
11360 bool arg3 = (bool) true ;
11361 bool result;
11362 void *argp1 = 0 ;
11363 int res1 = 0 ;
11364 void *argp2 = 0 ;
11365 int res2 = 0 ;
11366 bool val3 ;
11367 int ecode3 = 0 ;
11368 PyObject * obj0 = 0 ;
11369 PyObject * obj1 = 0 ;
11370 PyObject * obj2 = 0 ;
11371 char * kwnames[] = {
11372 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
11373 };
11374
11375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11376 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
11377 if (!SWIG_IsOK(res1)) {
11378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowTip" "', expected argument " "1"" of type '" "wxWindow *""'");
11379 }
11380 arg1 = reinterpret_cast< wxWindow * >(argp1);
11381 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11382 if (!SWIG_IsOK(res2)) {
11383 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShowTip" "', expected argument " "2"" of type '" "wxTipProvider *""'");
11384 }
11385 arg2 = reinterpret_cast< wxTipProvider * >(argp2);
11386 if (obj2) {
11387 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11388 if (!SWIG_IsOK(ecode3)) {
11389 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ShowTip" "', expected argument " "3"" of type '" "bool""'");
11390 }
11391 arg3 = static_cast< bool >(val3);
11392 }
11393 {
11394 if (!wxPyCheckForApp()) SWIG_fail;
11395 PyThreadState* __tstate = wxPyBeginAllowThreads();
11396 result = (bool)wxShowTip(arg1,arg2,arg3);
11397 wxPyEndAllowThreads(__tstate);
11398 if (PyErr_Occurred()) SWIG_fail;
11399 }
11400 {
11401 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11402 }
11403 return resultobj;
11404 fail:
11405 return NULL;
11406 }
11407
11408
11409 SWIGINTERN PyObject *_wrap_CreateFileTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11410 PyObject *resultobj = 0;
11411 wxString *arg1 = 0 ;
11412 size_t arg2 ;
11413 wxTipProvider *result = 0 ;
11414 bool temp1 = false ;
11415 size_t val2 ;
11416 int ecode2 = 0 ;
11417 PyObject * obj0 = 0 ;
11418 PyObject * obj1 = 0 ;
11419 char * kwnames[] = {
11420 (char *) "filename",(char *) "currentTip", NULL
11421 };
11422
11423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) SWIG_fail;
11424 {
11425 arg1 = wxString_in_helper(obj0);
11426 if (arg1 == NULL) SWIG_fail;
11427 temp1 = true;
11428 }
11429 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
11430 if (!SWIG_IsOK(ecode2)) {
11431 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CreateFileTipProvider" "', expected argument " "2"" of type '" "size_t""'");
11432 }
11433 arg2 = static_cast< size_t >(val2);
11434 {
11435 if (!wxPyCheckForApp()) SWIG_fail;
11436 PyThreadState* __tstate = wxPyBeginAllowThreads();
11437 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
11438 wxPyEndAllowThreads(__tstate);
11439 if (PyErr_Occurred()) SWIG_fail;
11440 }
11441 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTipProvider, SWIG_POINTER_OWN | 0 );
11442 {
11443 if (temp1)
11444 delete arg1;
11445 }
11446 return resultobj;
11447 fail:
11448 {
11449 if (temp1)
11450 delete arg1;
11451 }
11452 return NULL;
11453 }
11454
11455
11456 SWIGINTERN PyObject *_wrap_new_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11457 PyObject *resultobj = 0;
11458 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
11459 int arg2 = (int) wxID_ANY ;
11460 wxPyTimer *result = 0 ;
11461 void *argp1 = 0 ;
11462 int res1 = 0 ;
11463 int val2 ;
11464 int ecode2 = 0 ;
11465 PyObject * obj0 = 0 ;
11466 PyObject * obj1 = 0 ;
11467 char * kwnames[] = {
11468 (char *) "owner",(char *) "id", NULL
11469 };
11470
11471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) SWIG_fail;
11472 if (obj0) {
11473 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
11474 if (!SWIG_IsOK(res1)) {
11475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Timer" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
11476 }
11477 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
11478 }
11479 if (obj1) {
11480 ecode2 = SWIG_AsVal_int(obj1, &val2);
11481 if (!SWIG_IsOK(ecode2)) {
11482 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Timer" "', expected argument " "2"" of type '" "int""'");
11483 }
11484 arg2 = static_cast< int >(val2);
11485 }
11486 {
11487 if (!wxPyCheckForApp()) SWIG_fail;
11488 PyThreadState* __tstate = wxPyBeginAllowThreads();
11489 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
11490 wxPyEndAllowThreads(__tstate);
11491 if (PyErr_Occurred()) SWIG_fail;
11492 }
11493 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTimer, SWIG_POINTER_NEW | 0 );
11494 return resultobj;
11495 fail:
11496 return NULL;
11497 }
11498
11499
11500 SWIGINTERN PyObject *_wrap_delete_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11501 PyObject *resultobj = 0;
11502 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11503 void *argp1 = 0 ;
11504 int res1 = 0 ;
11505 PyObject *swig_obj[1] ;
11506
11507 if (!args) SWIG_fail;
11508 swig_obj[0] = args;
11509 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, SWIG_POINTER_DISOWN | 0 );
11510 if (!SWIG_IsOK(res1)) {
11511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Timer" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11512 }
11513 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11514 {
11515 PyThreadState* __tstate = wxPyBeginAllowThreads();
11516 delete arg1;
11517
11518 wxPyEndAllowThreads(__tstate);
11519 if (PyErr_Occurred()) SWIG_fail;
11520 }
11521 resultobj = SWIG_Py_Void();
11522 return resultobj;
11523 fail:
11524 return NULL;
11525 }
11526
11527
11528 SWIGINTERN PyObject *_wrap_Timer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11529 PyObject *resultobj = 0;
11530 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11531 PyObject *arg2 = (PyObject *) 0 ;
11532 PyObject *arg3 = (PyObject *) 0 ;
11533 int arg4 = (int) 1 ;
11534 void *argp1 = 0 ;
11535 int res1 = 0 ;
11536 int val4 ;
11537 int ecode4 = 0 ;
11538 PyObject * obj0 = 0 ;
11539 PyObject * obj1 = 0 ;
11540 PyObject * obj2 = 0 ;
11541 PyObject * obj3 = 0 ;
11542 char * kwnames[] = {
11543 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
11544 };
11545
11546 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11547 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11548 if (!SWIG_IsOK(res1)) {
11549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11550 }
11551 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11552 arg2 = obj1;
11553 arg3 = obj2;
11554 if (obj3) {
11555 ecode4 = SWIG_AsVal_int(obj3, &val4);
11556 if (!SWIG_IsOK(ecode4)) {
11557 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Timer__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
11558 }
11559 arg4 = static_cast< int >(val4);
11560 }
11561 {
11562 PyThreadState* __tstate = wxPyBeginAllowThreads();
11563 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
11564 wxPyEndAllowThreads(__tstate);
11565 if (PyErr_Occurred()) SWIG_fail;
11566 }
11567 resultobj = SWIG_Py_Void();
11568 return resultobj;
11569 fail:
11570 return NULL;
11571 }
11572
11573
11574 SWIGINTERN PyObject *_wrap_Timer_SetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11575 PyObject *resultobj = 0;
11576 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11577 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
11578 int arg3 = (int) wxID_ANY ;
11579 void *argp1 = 0 ;
11580 int res1 = 0 ;
11581 void *argp2 = 0 ;
11582 int res2 = 0 ;
11583 int val3 ;
11584 int ecode3 = 0 ;
11585 PyObject * obj0 = 0 ;
11586 PyObject * obj1 = 0 ;
11587 PyObject * obj2 = 0 ;
11588 char * kwnames[] = {
11589 (char *) "self",(char *) "owner",(char *) "id", NULL
11590 };
11591
11592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11594 if (!SWIG_IsOK(res1)) {
11595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_SetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11596 }
11597 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11598 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
11599 if (!SWIG_IsOK(res2)) {
11600 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Timer_SetOwner" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
11601 }
11602 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
11603 if (obj2) {
11604 ecode3 = SWIG_AsVal_int(obj2, &val3);
11605 if (!SWIG_IsOK(ecode3)) {
11606 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_SetOwner" "', expected argument " "3"" of type '" "int""'");
11607 }
11608 arg3 = static_cast< int >(val3);
11609 }
11610 {
11611 PyThreadState* __tstate = wxPyBeginAllowThreads();
11612 (arg1)->SetOwner(arg2,arg3);
11613 wxPyEndAllowThreads(__tstate);
11614 if (PyErr_Occurred()) SWIG_fail;
11615 }
11616 resultobj = SWIG_Py_Void();
11617 return resultobj;
11618 fail:
11619 return NULL;
11620 }
11621
11622
11623 SWIGINTERN PyObject *_wrap_Timer_GetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11624 PyObject *resultobj = 0;
11625 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11626 wxEvtHandler *result = 0 ;
11627 void *argp1 = 0 ;
11628 int res1 = 0 ;
11629 PyObject *swig_obj[1] ;
11630
11631 if (!args) SWIG_fail;
11632 swig_obj[0] = args;
11633 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11634 if (!SWIG_IsOK(res1)) {
11635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11636 }
11637 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11638 {
11639 PyThreadState* __tstate = wxPyBeginAllowThreads();
11640 result = (wxEvtHandler *)(arg1)->GetOwner();
11641 wxPyEndAllowThreads(__tstate);
11642 if (PyErr_Occurred()) SWIG_fail;
11643 }
11644 {
11645 resultobj = wxPyMake_wxObject(result, 0);
11646 }
11647 return resultobj;
11648 fail:
11649 return NULL;
11650 }
11651
11652
11653 SWIGINTERN PyObject *_wrap_Timer_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11654 PyObject *resultobj = 0;
11655 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11656 int arg2 = (int) -1 ;
11657 bool arg3 = (bool) false ;
11658 bool result;
11659 void *argp1 = 0 ;
11660 int res1 = 0 ;
11661 int val2 ;
11662 int ecode2 = 0 ;
11663 bool val3 ;
11664 int ecode3 = 0 ;
11665 PyObject * obj0 = 0 ;
11666 PyObject * obj1 = 0 ;
11667 PyObject * obj2 = 0 ;
11668 char * kwnames[] = {
11669 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
11670 };
11671
11672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11673 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11674 if (!SWIG_IsOK(res1)) {
11675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Start" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11676 }
11677 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11678 if (obj1) {
11679 ecode2 = SWIG_AsVal_int(obj1, &val2);
11680 if (!SWIG_IsOK(ecode2)) {
11681 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Timer_Start" "', expected argument " "2"" of type '" "int""'");
11682 }
11683 arg2 = static_cast< int >(val2);
11684 }
11685 if (obj2) {
11686 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11687 if (!SWIG_IsOK(ecode3)) {
11688 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_Start" "', expected argument " "3"" of type '" "bool""'");
11689 }
11690 arg3 = static_cast< bool >(val3);
11691 }
11692 {
11693 PyThreadState* __tstate = wxPyBeginAllowThreads();
11694 result = (bool)(arg1)->Start(arg2,arg3);
11695 wxPyEndAllowThreads(__tstate);
11696 if (PyErr_Occurred()) SWIG_fail;
11697 }
11698 {
11699 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11700 }
11701 return resultobj;
11702 fail:
11703 return NULL;
11704 }
11705
11706
11707 SWIGINTERN PyObject *_wrap_Timer_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11708 PyObject *resultobj = 0;
11709 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11710 void *argp1 = 0 ;
11711 int res1 = 0 ;
11712 PyObject *swig_obj[1] ;
11713
11714 if (!args) SWIG_fail;
11715 swig_obj[0] = args;
11716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11717 if (!SWIG_IsOK(res1)) {
11718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Stop" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11719 }
11720 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11721 {
11722 PyThreadState* __tstate = wxPyBeginAllowThreads();
11723 (arg1)->Stop();
11724 wxPyEndAllowThreads(__tstate);
11725 if (PyErr_Occurred()) SWIG_fail;
11726 }
11727 resultobj = SWIG_Py_Void();
11728 return resultobj;
11729 fail:
11730 return NULL;
11731 }
11732
11733
11734 SWIGINTERN PyObject *_wrap_Timer_Notify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11735 PyObject *resultobj = 0;
11736 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11737 void *argp1 = 0 ;
11738 int res1 = 0 ;
11739 PyObject *swig_obj[1] ;
11740
11741 if (!args) SWIG_fail;
11742 swig_obj[0] = args;
11743 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11744 if (!SWIG_IsOK(res1)) {
11745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Notify" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11746 }
11747 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11748 {
11749 PyThreadState* __tstate = wxPyBeginAllowThreads();
11750 (arg1)->Notify();
11751 wxPyEndAllowThreads(__tstate);
11752 if (PyErr_Occurred()) SWIG_fail;
11753 }
11754 resultobj = SWIG_Py_Void();
11755 return resultobj;
11756 fail:
11757 return NULL;
11758 }
11759
11760
11761 SWIGINTERN PyObject *_wrap_Timer_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11762 PyObject *resultobj = 0;
11763 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11764 bool result;
11765 void *argp1 = 0 ;
11766 int res1 = 0 ;
11767 PyObject *swig_obj[1] ;
11768
11769 if (!args) SWIG_fail;
11770 swig_obj[0] = args;
11771 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11772 if (!SWIG_IsOK(res1)) {
11773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsRunning" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11774 }
11775 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11776 {
11777 PyThreadState* __tstate = wxPyBeginAllowThreads();
11778 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
11779 wxPyEndAllowThreads(__tstate);
11780 if (PyErr_Occurred()) SWIG_fail;
11781 }
11782 {
11783 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11784 }
11785 return resultobj;
11786 fail:
11787 return NULL;
11788 }
11789
11790
11791 SWIGINTERN PyObject *_wrap_Timer_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11792 PyObject *resultobj = 0;
11793 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11794 int result;
11795 void *argp1 = 0 ;
11796 int res1 = 0 ;
11797 PyObject *swig_obj[1] ;
11798
11799 if (!args) SWIG_fail;
11800 swig_obj[0] = args;
11801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11802 if (!SWIG_IsOK(res1)) {
11803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetInterval" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11804 }
11805 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11806 {
11807 PyThreadState* __tstate = wxPyBeginAllowThreads();
11808 result = (int)((wxPyTimer const *)arg1)->GetInterval();
11809 wxPyEndAllowThreads(__tstate);
11810 if (PyErr_Occurred()) SWIG_fail;
11811 }
11812 resultobj = SWIG_From_int(static_cast< int >(result));
11813 return resultobj;
11814 fail:
11815 return NULL;
11816 }
11817
11818
11819 SWIGINTERN PyObject *_wrap_Timer_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11820 PyObject *resultobj = 0;
11821 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11822 int result;
11823 void *argp1 = 0 ;
11824 int res1 = 0 ;
11825 PyObject *swig_obj[1] ;
11826
11827 if (!args) SWIG_fail;
11828 swig_obj[0] = args;
11829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11830 if (!SWIG_IsOK(res1)) {
11831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetId" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11832 }
11833 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11834 {
11835 PyThreadState* __tstate = wxPyBeginAllowThreads();
11836 result = (int)((wxPyTimer const *)arg1)->GetId();
11837 wxPyEndAllowThreads(__tstate);
11838 if (PyErr_Occurred()) SWIG_fail;
11839 }
11840 resultobj = SWIG_From_int(static_cast< int >(result));
11841 return resultobj;
11842 fail:
11843 return NULL;
11844 }
11845
11846
11847 SWIGINTERN PyObject *_wrap_Timer_IsOneShot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11848 PyObject *resultobj = 0;
11849 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11850 bool result;
11851 void *argp1 = 0 ;
11852 int res1 = 0 ;
11853 PyObject *swig_obj[1] ;
11854
11855 if (!args) SWIG_fail;
11856 swig_obj[0] = args;
11857 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11858 if (!SWIG_IsOK(res1)) {
11859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsOneShot" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11860 }
11861 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11862 {
11863 PyThreadState* __tstate = wxPyBeginAllowThreads();
11864 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
11865 wxPyEndAllowThreads(__tstate);
11866 if (PyErr_Occurred()) SWIG_fail;
11867 }
11868 {
11869 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11870 }
11871 return resultobj;
11872 fail:
11873 return NULL;
11874 }
11875
11876
11877 SWIGINTERN PyObject *Timer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11878 PyObject *obj;
11879 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11880 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTimer, SWIG_NewClientData(obj));
11881 return SWIG_Py_Void();
11882 }
11883
11884 SWIGINTERN PyObject *Timer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11885 return SWIG_Python_InitShadowInstance(args);
11886 }
11887
11888 SWIGINTERN PyObject *_wrap_new_TimerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11889 PyObject *resultobj = 0;
11890 int arg1 = (int) 0 ;
11891 int arg2 = (int) 0 ;
11892 wxTimerEvent *result = 0 ;
11893 int val1 ;
11894 int ecode1 = 0 ;
11895 int val2 ;
11896 int ecode2 = 0 ;
11897 PyObject * obj0 = 0 ;
11898 PyObject * obj1 = 0 ;
11899 char * kwnames[] = {
11900 (char *) "timerid",(char *) "interval", NULL
11901 };
11902
11903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) SWIG_fail;
11904 if (obj0) {
11905 ecode1 = SWIG_AsVal_int(obj0, &val1);
11906 if (!SWIG_IsOK(ecode1)) {
11907 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimerEvent" "', expected argument " "1"" of type '" "int""'");
11908 }
11909 arg1 = static_cast< int >(val1);
11910 }
11911 if (obj1) {
11912 ecode2 = SWIG_AsVal_int(obj1, &val2);
11913 if (!SWIG_IsOK(ecode2)) {
11914 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerEvent" "', expected argument " "2"" of type '" "int""'");
11915 }
11916 arg2 = static_cast< int >(val2);
11917 }
11918 {
11919 PyThreadState* __tstate = wxPyBeginAllowThreads();
11920 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
11921 wxPyEndAllowThreads(__tstate);
11922 if (PyErr_Occurred()) SWIG_fail;
11923 }
11924 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_NEW | 0 );
11925 return resultobj;
11926 fail:
11927 return NULL;
11928 }
11929
11930
11931 SWIGINTERN PyObject *_wrap_TimerEvent_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11932 PyObject *resultobj = 0;
11933 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
11934 int result;
11935 void *argp1 = 0 ;
11936 int res1 = 0 ;
11937 PyObject *swig_obj[1] ;
11938
11939 if (!args) SWIG_fail;
11940 swig_obj[0] = args;
11941 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerEvent, 0 | 0 );
11942 if (!SWIG_IsOK(res1)) {
11943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerEvent_GetInterval" "', expected argument " "1"" of type '" "wxTimerEvent const *""'");
11944 }
11945 arg1 = reinterpret_cast< wxTimerEvent * >(argp1);
11946 {
11947 PyThreadState* __tstate = wxPyBeginAllowThreads();
11948 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
11949 wxPyEndAllowThreads(__tstate);
11950 if (PyErr_Occurred()) SWIG_fail;
11951 }
11952 resultobj = SWIG_From_int(static_cast< int >(result));
11953 return resultobj;
11954 fail:
11955 return NULL;
11956 }
11957
11958
11959 SWIGINTERN PyObject *TimerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11960 PyObject *obj;
11961 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11962 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerEvent, SWIG_NewClientData(obj));
11963 return SWIG_Py_Void();
11964 }
11965
11966 SWIGINTERN PyObject *TimerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11967 return SWIG_Python_InitShadowInstance(args);
11968 }
11969
11970 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
11971 PyObject *resultobj = 0;
11972 wxTimer *arg1 = 0 ;
11973 wxTimerRunner *result = 0 ;
11974 void *argp1 = 0 ;
11975 int res1 = 0 ;
11976
11977 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
11978 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
11979 if (!SWIG_IsOK(res1)) {
11980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
11981 }
11982 if (!argp1) {
11983 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
11984 }
11985 arg1 = reinterpret_cast< wxTimer * >(argp1);
11986 {
11987 if (!wxPyCheckForApp()) SWIG_fail;
11988 PyThreadState* __tstate = wxPyBeginAllowThreads();
11989 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
11990 wxPyEndAllowThreads(__tstate);
11991 if (PyErr_Occurred()) SWIG_fail;
11992 }
11993 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
11994 return resultobj;
11995 fail:
11996 return NULL;
11997 }
11998
11999
12000 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
12001 PyObject *resultobj = 0;
12002 wxTimer *arg1 = 0 ;
12003 int arg2 ;
12004 bool arg3 = (bool) false ;
12005 wxTimerRunner *result = 0 ;
12006 void *argp1 = 0 ;
12007 int res1 = 0 ;
12008 int val2 ;
12009 int ecode2 = 0 ;
12010 bool val3 ;
12011 int ecode3 = 0 ;
12012
12013 if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
12014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
12015 if (!SWIG_IsOK(res1)) {
12016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
12017 }
12018 if (!argp1) {
12019 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
12020 }
12021 arg1 = reinterpret_cast< wxTimer * >(argp1);
12022 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12023 if (!SWIG_IsOK(ecode2)) {
12024 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerRunner" "', expected argument " "2"" of type '" "int""'");
12025 }
12026 arg2 = static_cast< int >(val2);
12027 if (swig_obj[2]) {
12028 ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
12029 if (!SWIG_IsOK(ecode3)) {
12030 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimerRunner" "', expected argument " "3"" of type '" "bool""'");
12031 }
12032 arg3 = static_cast< bool >(val3);
12033 }
12034 {
12035 if (!wxPyCheckForApp()) SWIG_fail;
12036 PyThreadState* __tstate = wxPyBeginAllowThreads();
12037 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
12038 wxPyEndAllowThreads(__tstate);
12039 if (PyErr_Occurred()) SWIG_fail;
12040 }
12041 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
12042 return resultobj;
12043 fail:
12044 return NULL;
12045 }
12046
12047
12048 SWIGINTERN PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
12049 int argc;
12050 PyObject *argv[4];
12051
12052 if (!(argc = SWIG_Python_UnpackTuple(args,"new_TimerRunner",0,3,argv))) SWIG_fail;
12053 --argc;
12054 if (argc == 1) {
12055 return _wrap_new_TimerRunner__SWIG_0(self, argc, argv);
12056 }
12057 if ((argc >= 2) && (argc <= 3)) {
12058 return _wrap_new_TimerRunner__SWIG_1(self, argc, argv);
12059 }
12060
12061 fail:
12062 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
12063 return NULL;
12064 }
12065
12066
12067 SWIGINTERN PyObject *_wrap_delete_TimerRunner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12068 PyObject *resultobj = 0;
12069 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
12070 void *argp1 = 0 ;
12071 int res1 = 0 ;
12072 PyObject *swig_obj[1] ;
12073
12074 if (!args) SWIG_fail;
12075 swig_obj[0] = args;
12076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_DISOWN | 0 );
12077 if (!SWIG_IsOK(res1)) {
12078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimerRunner" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
12079 }
12080 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
12081 {
12082 PyThreadState* __tstate = wxPyBeginAllowThreads();
12083 delete arg1;
12084
12085 wxPyEndAllowThreads(__tstate);
12086 if (PyErr_Occurred()) SWIG_fail;
12087 }
12088 resultobj = SWIG_Py_Void();
12089 return resultobj;
12090 fail:
12091 return NULL;
12092 }
12093
12094
12095 SWIGINTERN PyObject *_wrap_TimerRunner_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12096 PyObject *resultobj = 0;
12097 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
12098 int arg2 ;
12099 bool arg3 = (bool) false ;
12100 void *argp1 = 0 ;
12101 int res1 = 0 ;
12102 int val2 ;
12103 int ecode2 = 0 ;
12104 bool val3 ;
12105 int ecode3 = 0 ;
12106 PyObject * obj0 = 0 ;
12107 PyObject * obj1 = 0 ;
12108 PyObject * obj2 = 0 ;
12109 char * kwnames[] = {
12110 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
12111 };
12112
12113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12114 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimerRunner, 0 | 0 );
12115 if (!SWIG_IsOK(res1)) {
12116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerRunner_Start" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
12117 }
12118 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
12119 ecode2 = SWIG_AsVal_int(obj1, &val2);
12120 if (!SWIG_IsOK(ecode2)) {
12121 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimerRunner_Start" "', expected argument " "2"" of type '" "int""'");
12122 }
12123 arg2 = static_cast< int >(val2);
12124 if (obj2) {
12125 ecode3 = SWIG_AsVal_bool(obj2, &val3);
12126 if (!SWIG_IsOK(ecode3)) {
12127 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TimerRunner_Start" "', expected argument " "3"" of type '" "bool""'");
12128 }
12129 arg3 = static_cast< bool >(val3);
12130 }
12131 {
12132 PyThreadState* __tstate = wxPyBeginAllowThreads();
12133 (arg1)->Start(arg2,arg3);
12134 wxPyEndAllowThreads(__tstate);
12135 if (PyErr_Occurred()) SWIG_fail;
12136 }
12137 resultobj = SWIG_Py_Void();
12138 return resultobj;
12139 fail:
12140 return NULL;
12141 }
12142
12143
12144 SWIGINTERN PyObject *TimerRunner_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12145 PyObject *obj;
12146 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12147 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerRunner, SWIG_NewClientData(obj));
12148 return SWIG_Py_Void();
12149 }
12150
12151 SWIGINTERN PyObject *TimerRunner_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12152 return SWIG_Python_InitShadowInstance(args);
12153 }
12154
12155 SWIGINTERN PyObject *_wrap_new_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12156 PyObject *resultobj = 0;
12157 wxLog *result = 0 ;
12158
12159 if (!SWIG_Python_UnpackTuple(args,"new_Log",0,0,0)) SWIG_fail;
12160 {
12161 PyThreadState* __tstate = wxPyBeginAllowThreads();
12162 result = (wxLog *)new wxLog();
12163 wxPyEndAllowThreads(__tstate);
12164 if (PyErr_Occurred()) SWIG_fail;
12165 }
12166 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_NEW | 0 );
12167 return resultobj;
12168 fail:
12169 return NULL;
12170 }
12171
12172
12173 SWIGINTERN PyObject *_wrap_delete_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12174 PyObject *resultobj = 0;
12175 wxLog *arg1 = (wxLog *) 0 ;
12176 void *argp1 = 0 ;
12177 int res1 = 0 ;
12178 PyObject *swig_obj[1] ;
12179
12180 if (!args) SWIG_fail;
12181 swig_obj[0] = args;
12182 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
12183 if (!SWIG_IsOK(res1)) {
12184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Log" "', expected argument " "1"" of type '" "wxLog *""'");
12185 }
12186 arg1 = reinterpret_cast< wxLog * >(argp1);
12187 {
12188 PyThreadState* __tstate = wxPyBeginAllowThreads();
12189 delete arg1;
12190
12191 wxPyEndAllowThreads(__tstate);
12192 if (PyErr_Occurred()) SWIG_fail;
12193 }
12194 resultobj = SWIG_Py_Void();
12195 return resultobj;
12196 fail:
12197 return NULL;
12198 }
12199
12200
12201 SWIGINTERN PyObject *_wrap_Log_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12202 PyObject *resultobj = 0;
12203 bool result;
12204
12205 if (!SWIG_Python_UnpackTuple(args,"Log_IsEnabled",0,0,0)) SWIG_fail;
12206 {
12207 PyThreadState* __tstate = wxPyBeginAllowThreads();
12208 result = (bool)wxLog::IsEnabled();
12209 wxPyEndAllowThreads(__tstate);
12210 if (PyErr_Occurred()) SWIG_fail;
12211 }
12212 {
12213 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12214 }
12215 return resultobj;
12216 fail:
12217 return NULL;
12218 }
12219
12220
12221 SWIGINTERN PyObject *_wrap_Log_EnableLogging(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12222 PyObject *resultobj = 0;
12223 bool arg1 = (bool) true ;
12224 bool result;
12225 bool val1 ;
12226 int ecode1 = 0 ;
12227 PyObject * obj0 = 0 ;
12228 char * kwnames[] = {
12229 (char *) "doIt", NULL
12230 };
12231
12232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) SWIG_fail;
12233 if (obj0) {
12234 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12235 if (!SWIG_IsOK(ecode1)) {
12236 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_EnableLogging" "', expected argument " "1"" of type '" "bool""'");
12237 }
12238 arg1 = static_cast< bool >(val1);
12239 }
12240 {
12241 PyThreadState* __tstate = wxPyBeginAllowThreads();
12242 result = (bool)wxLog::EnableLogging(arg1);
12243 wxPyEndAllowThreads(__tstate);
12244 if (PyErr_Occurred()) SWIG_fail;
12245 }
12246 {
12247 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12248 }
12249 return resultobj;
12250 fail:
12251 return NULL;
12252 }
12253
12254
12255 SWIGINTERN PyObject *_wrap_Log_OnLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12256 PyObject *resultobj = 0;
12257 wxLogLevel arg1 ;
12258 wxChar *arg2 = (wxChar *) 0 ;
12259 time_t arg3 ;
12260 unsigned long val1 ;
12261 int ecode1 = 0 ;
12262 void *argp2 = 0 ;
12263 int res2 = 0 ;
12264 unsigned int val3 ;
12265 int ecode3 = 0 ;
12266 PyObject * obj0 = 0 ;
12267 PyObject * obj1 = 0 ;
12268 PyObject * obj2 = 0 ;
12269 char * kwnames[] = {
12270 (char *) "level",(char *) "szString",(char *) "t", NULL
12271 };
12272
12273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12274 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12275 if (!SWIG_IsOK(ecode1)) {
12276 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_OnLog" "', expected argument " "1"" of type '" "wxLogLevel""'");
12277 }
12278 arg1 = static_cast< wxLogLevel >(val1);
12279 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxChar, 0 | 0 );
12280 if (!SWIG_IsOK(res2)) {
12281 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Log_OnLog" "', expected argument " "2"" of type '" "wxChar const *""'");
12282 }
12283 arg2 = reinterpret_cast< wxChar * >(argp2);
12284 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
12285 if (!SWIG_IsOK(ecode3)) {
12286 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Log_OnLog" "', expected argument " "3"" of type '" "time_t""'");
12287 }
12288 arg3 = static_cast< time_t >(val3);
12289 {
12290 PyThreadState* __tstate = wxPyBeginAllowThreads();
12291 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
12292 wxPyEndAllowThreads(__tstate);
12293 if (PyErr_Occurred()) SWIG_fail;
12294 }
12295 resultobj = SWIG_Py_Void();
12296 return resultobj;
12297 fail:
12298 return NULL;
12299 }
12300
12301
12302 SWIGINTERN PyObject *_wrap_Log_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12303 PyObject *resultobj = 0;
12304 wxLog *arg1 = (wxLog *) 0 ;
12305 void *argp1 = 0 ;
12306 int res1 = 0 ;
12307 PyObject *swig_obj[1] ;
12308
12309 if (!args) SWIG_fail;
12310 swig_obj[0] = args;
12311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
12312 if (!SWIG_IsOK(res1)) {
12313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Flush" "', expected argument " "1"" of type '" "wxLog *""'");
12314 }
12315 arg1 = reinterpret_cast< wxLog * >(argp1);
12316 {
12317 PyThreadState* __tstate = wxPyBeginAllowThreads();
12318 (arg1)->Flush();
12319 wxPyEndAllowThreads(__tstate);
12320 if (PyErr_Occurred()) SWIG_fail;
12321 }
12322 resultobj = SWIG_Py_Void();
12323 return resultobj;
12324 fail:
12325 return NULL;
12326 }
12327
12328
12329 SWIGINTERN PyObject *_wrap_Log_FlushActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12330 PyObject *resultobj = 0;
12331
12332 if (!SWIG_Python_UnpackTuple(args,"Log_FlushActive",0,0,0)) SWIG_fail;
12333 {
12334 PyThreadState* __tstate = wxPyBeginAllowThreads();
12335 wxLog::FlushActive();
12336 wxPyEndAllowThreads(__tstate);
12337 if (PyErr_Occurred()) SWIG_fail;
12338 }
12339 resultobj = SWIG_Py_Void();
12340 return resultobj;
12341 fail:
12342 return NULL;
12343 }
12344
12345
12346 SWIGINTERN PyObject *_wrap_Log_GetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12347 PyObject *resultobj = 0;
12348 wxLog *result = 0 ;
12349
12350 if (!SWIG_Python_UnpackTuple(args,"Log_GetActiveTarget",0,0,0)) SWIG_fail;
12351 {
12352 PyThreadState* __tstate = wxPyBeginAllowThreads();
12353 result = (wxLog *)wxLog::GetActiveTarget();
12354 wxPyEndAllowThreads(__tstate);
12355 if (PyErr_Occurred()) SWIG_fail;
12356 }
12357 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
12358 return resultobj;
12359 fail:
12360 return NULL;
12361 }
12362
12363
12364 SWIGINTERN PyObject *_wrap_Log_SetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12365 PyObject *resultobj = 0;
12366 wxLog *arg1 = (wxLog *) 0 ;
12367 wxLog *result = 0 ;
12368 int res1 = 0 ;
12369 PyObject * obj0 = 0 ;
12370 char * kwnames[] = {
12371 (char *) "pLogger", NULL
12372 };
12373
12374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) SWIG_fail;
12375 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
12376 if (!SWIG_IsOK(res1)) {
12377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetActiveTarget" "', expected argument " "1"" of type '" "wxLog *""'");
12378 }
12379 {
12380 PyThreadState* __tstate = wxPyBeginAllowThreads();
12381 result = (wxLog *)wxLog::SetActiveTarget(arg1);
12382 wxPyEndAllowThreads(__tstate);
12383 if (PyErr_Occurred()) SWIG_fail;
12384 }
12385 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_OWN | 0 );
12386 return resultobj;
12387 fail:
12388 return NULL;
12389 }
12390
12391
12392 SWIGINTERN PyObject *_wrap_Log_Suspend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12393 PyObject *resultobj = 0;
12394
12395 if (!SWIG_Python_UnpackTuple(args,"Log_Suspend",0,0,0)) SWIG_fail;
12396 {
12397 PyThreadState* __tstate = wxPyBeginAllowThreads();
12398 wxLog::Suspend();
12399 wxPyEndAllowThreads(__tstate);
12400 if (PyErr_Occurred()) SWIG_fail;
12401 }
12402 resultobj = SWIG_Py_Void();
12403 return resultobj;
12404 fail:
12405 return NULL;
12406 }
12407
12408
12409 SWIGINTERN PyObject *_wrap_Log_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12410 PyObject *resultobj = 0;
12411
12412 if (!SWIG_Python_UnpackTuple(args,"Log_Resume",0,0,0)) SWIG_fail;
12413 {
12414 PyThreadState* __tstate = wxPyBeginAllowThreads();
12415 wxLog::Resume();
12416 wxPyEndAllowThreads(__tstate);
12417 if (PyErr_Occurred()) SWIG_fail;
12418 }
12419 resultobj = SWIG_Py_Void();
12420 return resultobj;
12421 fail:
12422 return NULL;
12423 }
12424
12425
12426 SWIGINTERN PyObject *_wrap_Log_SetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12427 PyObject *resultobj = 0;
12428 bool arg1 = (bool) true ;
12429 bool val1 ;
12430 int ecode1 = 0 ;
12431 PyObject * obj0 = 0 ;
12432 char * kwnames[] = {
12433 (char *) "bVerbose", NULL
12434 };
12435
12436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) SWIG_fail;
12437 if (obj0) {
12438 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12439 if (!SWIG_IsOK(ecode1)) {
12440 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetVerbose" "', expected argument " "1"" of type '" "bool""'");
12441 }
12442 arg1 = static_cast< bool >(val1);
12443 }
12444 {
12445 PyThreadState* __tstate = wxPyBeginAllowThreads();
12446 wxLog::SetVerbose(arg1);
12447 wxPyEndAllowThreads(__tstate);
12448 if (PyErr_Occurred()) SWIG_fail;
12449 }
12450 resultobj = SWIG_Py_Void();
12451 return resultobj;
12452 fail:
12453 return NULL;
12454 }
12455
12456
12457 SWIGINTERN PyObject *_wrap_Log_SetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12458 PyObject *resultobj = 0;
12459 wxLogLevel arg1 ;
12460 unsigned long val1 ;
12461 int ecode1 = 0 ;
12462 PyObject * obj0 = 0 ;
12463 char * kwnames[] = {
12464 (char *) "logLevel", NULL
12465 };
12466
12467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) SWIG_fail;
12468 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12469 if (!SWIG_IsOK(ecode1)) {
12470 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetLogLevel" "', expected argument " "1"" of type '" "wxLogLevel""'");
12471 }
12472 arg1 = static_cast< wxLogLevel >(val1);
12473 {
12474 PyThreadState* __tstate = wxPyBeginAllowThreads();
12475 wxLog::SetLogLevel(arg1);
12476 wxPyEndAllowThreads(__tstate);
12477 if (PyErr_Occurred()) SWIG_fail;
12478 }
12479 resultobj = SWIG_Py_Void();
12480 return resultobj;
12481 fail:
12482 return NULL;
12483 }
12484
12485
12486 SWIGINTERN PyObject *_wrap_Log_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12487 PyObject *resultobj = 0;
12488
12489 if (!SWIG_Python_UnpackTuple(args,"Log_DontCreateOnDemand",0,0,0)) SWIG_fail;
12490 {
12491 PyThreadState* __tstate = wxPyBeginAllowThreads();
12492 wxLog::DontCreateOnDemand();
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_SetRepetitionCounting(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12504 PyObject *resultobj = 0;
12505 bool arg1 = (bool) true ;
12506 bool val1 ;
12507 int ecode1 = 0 ;
12508 PyObject * obj0 = 0 ;
12509 char * kwnames[] = {
12510 (char *) "bRepetCounting", NULL
12511 };
12512
12513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetRepetitionCounting",kwnames,&obj0)) SWIG_fail;
12514 if (obj0) {
12515 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12516 if (!SWIG_IsOK(ecode1)) {
12517 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetRepetitionCounting" "', expected argument " "1"" of type '" "bool""'");
12518 }
12519 arg1 = static_cast< bool >(val1);
12520 }
12521 {
12522 PyThreadState* __tstate = wxPyBeginAllowThreads();
12523 wxLog::SetRepetitionCounting(arg1);
12524 wxPyEndAllowThreads(__tstate);
12525 if (PyErr_Occurred()) SWIG_fail;
12526 }
12527 resultobj = SWIG_Py_Void();
12528 return resultobj;
12529 fail:
12530 return NULL;
12531 }
12532
12533
12534 SWIGINTERN PyObject *_wrap_Log_GetRepetitionCounting(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12535 PyObject *resultobj = 0;
12536 bool result;
12537
12538 if (!SWIG_Python_UnpackTuple(args,"Log_GetRepetitionCounting",0,0,0)) SWIG_fail;
12539 {
12540 PyThreadState* __tstate = wxPyBeginAllowThreads();
12541 result = (bool)wxLog::GetRepetitionCounting();
12542 wxPyEndAllowThreads(__tstate);
12543 if (PyErr_Occurred()) SWIG_fail;
12544 }
12545 {
12546 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12547 }
12548 return resultobj;
12549 fail:
12550 return NULL;
12551 }
12552
12553
12554 SWIGINTERN PyObject *_wrap_Log_SetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12555 PyObject *resultobj = 0;
12556 wxTraceMask arg1 ;
12557 unsigned long val1 ;
12558 int ecode1 = 0 ;
12559 PyObject * obj0 = 0 ;
12560 char * kwnames[] = {
12561 (char *) "ulMask", NULL
12562 };
12563
12564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) SWIG_fail;
12565 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12566 if (!SWIG_IsOK(ecode1)) {
12567 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetTraceMask" "', expected argument " "1"" of type '" "wxTraceMask""'");
12568 }
12569 arg1 = static_cast< wxTraceMask >(val1);
12570 {
12571 PyThreadState* __tstate = wxPyBeginAllowThreads();
12572 wxLog::SetTraceMask(arg1);
12573 wxPyEndAllowThreads(__tstate);
12574 if (PyErr_Occurred()) SWIG_fail;
12575 }
12576 resultobj = SWIG_Py_Void();
12577 return resultobj;
12578 fail:
12579 return NULL;
12580 }
12581
12582
12583 SWIGINTERN PyObject *_wrap_Log_AddTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12584 PyObject *resultobj = 0;
12585 wxString *arg1 = 0 ;
12586 bool temp1 = false ;
12587 PyObject * obj0 = 0 ;
12588 char * kwnames[] = {
12589 (char *) "str", NULL
12590 };
12591
12592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) SWIG_fail;
12593 {
12594 arg1 = wxString_in_helper(obj0);
12595 if (arg1 == NULL) SWIG_fail;
12596 temp1 = true;
12597 }
12598 {
12599 PyThreadState* __tstate = wxPyBeginAllowThreads();
12600 wxLog::AddTraceMask((wxString const &)*arg1);
12601 wxPyEndAllowThreads(__tstate);
12602 if (PyErr_Occurred()) SWIG_fail;
12603 }
12604 resultobj = SWIG_Py_Void();
12605 {
12606 if (temp1)
12607 delete arg1;
12608 }
12609 return resultobj;
12610 fail:
12611 {
12612 if (temp1)
12613 delete arg1;
12614 }
12615 return NULL;
12616 }
12617
12618
12619 SWIGINTERN PyObject *_wrap_Log_RemoveTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12620 PyObject *resultobj = 0;
12621 wxString *arg1 = 0 ;
12622 bool temp1 = false ;
12623 PyObject * obj0 = 0 ;
12624 char * kwnames[] = {
12625 (char *) "str", NULL
12626 };
12627
12628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) SWIG_fail;
12629 {
12630 arg1 = wxString_in_helper(obj0);
12631 if (arg1 == NULL) SWIG_fail;
12632 temp1 = true;
12633 }
12634 {
12635 PyThreadState* __tstate = wxPyBeginAllowThreads();
12636 wxLog::RemoveTraceMask((wxString const &)*arg1);
12637 wxPyEndAllowThreads(__tstate);
12638 if (PyErr_Occurred()) SWIG_fail;
12639 }
12640 resultobj = SWIG_Py_Void();
12641 {
12642 if (temp1)
12643 delete arg1;
12644 }
12645 return resultobj;
12646 fail:
12647 {
12648 if (temp1)
12649 delete arg1;
12650 }
12651 return NULL;
12652 }
12653
12654
12655 SWIGINTERN PyObject *_wrap_Log_ClearTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12656 PyObject *resultobj = 0;
12657
12658 if (!SWIG_Python_UnpackTuple(args,"Log_ClearTraceMasks",0,0,0)) SWIG_fail;
12659 {
12660 PyThreadState* __tstate = wxPyBeginAllowThreads();
12661 wxLog::ClearTraceMasks();
12662 wxPyEndAllowThreads(__tstate);
12663 if (PyErr_Occurred()) SWIG_fail;
12664 }
12665 resultobj = SWIG_Py_Void();
12666 return resultobj;
12667 fail:
12668 return NULL;
12669 }
12670
12671
12672 SWIGINTERN PyObject *_wrap_Log_GetTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12673 PyObject *resultobj = 0;
12674 wxArrayString *result = 0 ;
12675
12676 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMasks",0,0,0)) SWIG_fail;
12677 {
12678 PyThreadState* __tstate = wxPyBeginAllowThreads();
12679 {
12680 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
12681 result = (wxArrayString *) &_result_ref;
12682 }
12683 wxPyEndAllowThreads(__tstate);
12684 if (PyErr_Occurred()) SWIG_fail;
12685 }
12686 {
12687 resultobj = wxArrayString2PyList_helper(*result);
12688 }
12689 return resultobj;
12690 fail:
12691 return NULL;
12692 }
12693
12694
12695 SWIGINTERN PyObject *_wrap_Log_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12696 PyObject *resultobj = 0;
12697 wxChar *arg1 = (wxChar *) 0 ;
12698 void *argp1 = 0 ;
12699 int res1 = 0 ;
12700 PyObject * obj0 = 0 ;
12701 char * kwnames[] = {
12702 (char *) "ts", NULL
12703 };
12704
12705 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) SWIG_fail;
12706 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
12707 if (!SWIG_IsOK(res1)) {
12708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetTimestamp" "', expected argument " "1"" of type '" "wxChar const *""'");
12709 }
12710 arg1 = reinterpret_cast< wxChar * >(argp1);
12711 {
12712 PyThreadState* __tstate = wxPyBeginAllowThreads();
12713 wxLog::SetTimestamp((wxChar const *)arg1);
12714 wxPyEndAllowThreads(__tstate);
12715 if (PyErr_Occurred()) SWIG_fail;
12716 }
12717 resultobj = SWIG_Py_Void();
12718 return resultobj;
12719 fail:
12720 return NULL;
12721 }
12722
12723
12724 SWIGINTERN PyObject *_wrap_Log_GetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12725 PyObject *resultobj = 0;
12726 bool result;
12727
12728 if (!SWIG_Python_UnpackTuple(args,"Log_GetVerbose",0,0,0)) SWIG_fail;
12729 {
12730 PyThreadState* __tstate = wxPyBeginAllowThreads();
12731 result = (bool)wxLog::GetVerbose();
12732 wxPyEndAllowThreads(__tstate);
12733 if (PyErr_Occurred()) SWIG_fail;
12734 }
12735 {
12736 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12737 }
12738 return resultobj;
12739 fail:
12740 return NULL;
12741 }
12742
12743
12744 SWIGINTERN PyObject *_wrap_Log_GetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12745 PyObject *resultobj = 0;
12746 wxTraceMask result;
12747
12748 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMask",0,0,0)) SWIG_fail;
12749 {
12750 PyThreadState* __tstate = wxPyBeginAllowThreads();
12751 result = (wxTraceMask)wxLog::GetTraceMask();
12752 wxPyEndAllowThreads(__tstate);
12753 if (PyErr_Occurred()) SWIG_fail;
12754 }
12755 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12756 return resultobj;
12757 fail:
12758 return NULL;
12759 }
12760
12761
12762 SWIGINTERN PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12763 PyObject *resultobj = 0;
12764 wxChar *arg1 = (wxChar *) 0 ;
12765 bool result;
12766 void *argp1 = 0 ;
12767 int res1 = 0 ;
12768 PyObject * obj0 = 0 ;
12769 char * kwnames[] = {
12770 (char *) "mask", NULL
12771 };
12772
12773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) SWIG_fail;
12774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
12775 if (!SWIG_IsOK(res1)) {
12776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_IsAllowedTraceMask" "', expected argument " "1"" of type '" "wxChar const *""'");
12777 }
12778 arg1 = reinterpret_cast< wxChar * >(argp1);
12779 {
12780 PyThreadState* __tstate = wxPyBeginAllowThreads();
12781 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
12782 wxPyEndAllowThreads(__tstate);
12783 if (PyErr_Occurred()) SWIG_fail;
12784 }
12785 {
12786 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12787 }
12788 return resultobj;
12789 fail:
12790 return NULL;
12791 }
12792
12793
12794 SWIGINTERN PyObject *_wrap_Log_GetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12795 PyObject *resultobj = 0;
12796 wxLogLevel result;
12797
12798 if (!SWIG_Python_UnpackTuple(args,"Log_GetLogLevel",0,0,0)) SWIG_fail;
12799 {
12800 PyThreadState* __tstate = wxPyBeginAllowThreads();
12801 result = (wxLogLevel)wxLog::GetLogLevel();
12802 wxPyEndAllowThreads(__tstate);
12803 if (PyErr_Occurred()) SWIG_fail;
12804 }
12805 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12806 return resultobj;
12807 fail:
12808 return NULL;
12809 }
12810
12811
12812 SWIGINTERN PyObject *_wrap_Log_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12813 PyObject *resultobj = 0;
12814 wxChar *result = 0 ;
12815
12816 if (!SWIG_Python_UnpackTuple(args,"Log_GetTimestamp",0,0,0)) SWIG_fail;
12817 {
12818 PyThreadState* __tstate = wxPyBeginAllowThreads();
12819 result = (wxChar *)wxLog::GetTimestamp();
12820 wxPyEndAllowThreads(__tstate);
12821 if (PyErr_Occurred()) SWIG_fail;
12822 }
12823 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChar, 0 | 0 );
12824 return resultobj;
12825 fail:
12826 return NULL;
12827 }
12828
12829
12830 SWIGINTERN PyObject *_wrap_Log_TimeStamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12831 PyObject *resultobj = 0;
12832 wxString result;
12833
12834 if (!SWIG_Python_UnpackTuple(args,"Log_TimeStamp",0,0,0)) SWIG_fail;
12835 {
12836 PyThreadState* __tstate = wxPyBeginAllowThreads();
12837 result = wxLog_TimeStamp();
12838 wxPyEndAllowThreads(__tstate);
12839 if (PyErr_Occurred()) SWIG_fail;
12840 }
12841 {
12842 #if wxUSE_UNICODE
12843 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12844 #else
12845 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12846 #endif
12847 }
12848 return resultobj;
12849 fail:
12850 return NULL;
12851 }
12852
12853
12854 SWIGINTERN PyObject *_wrap_Log_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12855 PyObject *resultobj = 0;
12856 wxLog *arg1 = (wxLog *) 0 ;
12857 void *argp1 = 0 ;
12858 int res1 = 0 ;
12859 PyObject *swig_obj[1] ;
12860
12861 if (!args) SWIG_fail;
12862 swig_obj[0] = args;
12863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
12864 if (!SWIG_IsOK(res1)) {
12865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Destroy" "', expected argument " "1"" of type '" "wxLog *""'");
12866 }
12867 arg1 = reinterpret_cast< wxLog * >(argp1);
12868 {
12869 PyThreadState* __tstate = wxPyBeginAllowThreads();
12870 wxLog_Destroy(arg1);
12871 wxPyEndAllowThreads(__tstate);
12872 if (PyErr_Occurred()) SWIG_fail;
12873 }
12874 resultobj = SWIG_Py_Void();
12875 return resultobj;
12876 fail:
12877 return NULL;
12878 }
12879
12880
12881 SWIGINTERN PyObject *Log_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12882 PyObject *obj;
12883 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12884 SWIG_TypeNewClientData(SWIGTYPE_p_wxLog, SWIG_NewClientData(obj));
12885 return SWIG_Py_Void();
12886 }
12887
12888 SWIGINTERN PyObject *Log_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12889 return SWIG_Python_InitShadowInstance(args);
12890 }
12891
12892 SWIGINTERN PyObject *_wrap_new_LogStderr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12893 PyObject *resultobj = 0;
12894 wxLogStderr *result = 0 ;
12895
12896 if (!SWIG_Python_UnpackTuple(args,"new_LogStderr",0,0,0)) SWIG_fail;
12897 {
12898 PyThreadState* __tstate = wxPyBeginAllowThreads();
12899 result = (wxLogStderr *)new wxLogStderr();
12900 wxPyEndAllowThreads(__tstate);
12901 if (PyErr_Occurred()) SWIG_fail;
12902 }
12903 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogStderr, SWIG_POINTER_NEW | 0 );
12904 return resultobj;
12905 fail:
12906 return NULL;
12907 }
12908
12909
12910 SWIGINTERN PyObject *LogStderr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12911 PyObject *obj;
12912 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12913 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogStderr, SWIG_NewClientData(obj));
12914 return SWIG_Py_Void();
12915 }
12916
12917 SWIGINTERN PyObject *LogStderr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12918 return SWIG_Python_InitShadowInstance(args);
12919 }
12920
12921 SWIGINTERN PyObject *_wrap_new_LogTextCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12922 PyObject *resultobj = 0;
12923 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
12924 wxLogTextCtrl *result = 0 ;
12925 void *argp1 = 0 ;
12926 int res1 = 0 ;
12927 PyObject * obj0 = 0 ;
12928 char * kwnames[] = {
12929 (char *) "pTextCtrl", NULL
12930 };
12931
12932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) SWIG_fail;
12933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextCtrl, 0 | 0 );
12934 if (!SWIG_IsOK(res1)) {
12935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogTextCtrl" "', expected argument " "1"" of type '" "wxTextCtrl *""'");
12936 }
12937 arg1 = reinterpret_cast< wxTextCtrl * >(argp1);
12938 {
12939 PyThreadState* __tstate = wxPyBeginAllowThreads();
12940 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
12941 wxPyEndAllowThreads(__tstate);
12942 if (PyErr_Occurred()) SWIG_fail;
12943 }
12944 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogTextCtrl, SWIG_POINTER_NEW | 0 );
12945 return resultobj;
12946 fail:
12947 return NULL;
12948 }
12949
12950
12951 SWIGINTERN PyObject *LogTextCtrl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12952 PyObject *obj;
12953 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12954 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogTextCtrl, SWIG_NewClientData(obj));
12955 return SWIG_Py_Void();
12956 }
12957
12958 SWIGINTERN PyObject *LogTextCtrl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12959 return SWIG_Python_InitShadowInstance(args);
12960 }
12961
12962 SWIGINTERN PyObject *_wrap_new_LogGui(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12963 PyObject *resultobj = 0;
12964 wxLogGui *result = 0 ;
12965
12966 if (!SWIG_Python_UnpackTuple(args,"new_LogGui",0,0,0)) SWIG_fail;
12967 {
12968 PyThreadState* __tstate = wxPyBeginAllowThreads();
12969 result = (wxLogGui *)new wxLogGui();
12970 wxPyEndAllowThreads(__tstate);
12971 if (PyErr_Occurred()) SWIG_fail;
12972 }
12973 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogGui, SWIG_POINTER_NEW | 0 );
12974 return resultobj;
12975 fail:
12976 return NULL;
12977 }
12978
12979
12980 SWIGINTERN PyObject *LogGui_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12981 PyObject *obj;
12982 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12983 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogGui, SWIG_NewClientData(obj));
12984 return SWIG_Py_Void();
12985 }
12986
12987 SWIGINTERN PyObject *LogGui_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12988 return SWIG_Python_InitShadowInstance(args);
12989 }
12990
12991 SWIGINTERN PyObject *_wrap_new_LogWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12992 PyObject *resultobj = 0;
12993 wxFrame *arg1 = (wxFrame *) 0 ;
12994 wxString *arg2 = 0 ;
12995 bool arg3 = (bool) true ;
12996 bool arg4 = (bool) true ;
12997 wxLogWindow *result = 0 ;
12998 void *argp1 = 0 ;
12999 int res1 = 0 ;
13000 bool temp2 = false ;
13001 bool val3 ;
13002 int ecode3 = 0 ;
13003 bool val4 ;
13004 int ecode4 = 0 ;
13005 PyObject * obj0 = 0 ;
13006 PyObject * obj1 = 0 ;
13007 PyObject * obj2 = 0 ;
13008 PyObject * obj3 = 0 ;
13009 char * kwnames[] = {
13010 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
13011 };
13012
13013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13014 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
13015 if (!SWIG_IsOK(res1)) {
13016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogWindow" "', expected argument " "1"" of type '" "wxFrame *""'");
13017 }
13018 arg1 = reinterpret_cast< wxFrame * >(argp1);
13019 {
13020 arg2 = wxString_in_helper(obj1);
13021 if (arg2 == NULL) SWIG_fail;
13022 temp2 = true;
13023 }
13024 if (obj2) {
13025 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13026 if (!SWIG_IsOK(ecode3)) {
13027 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_LogWindow" "', expected argument " "3"" of type '" "bool""'");
13028 }
13029 arg3 = static_cast< bool >(val3);
13030 }
13031 if (obj3) {
13032 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13033 if (!SWIG_IsOK(ecode4)) {
13034 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LogWindow" "', expected argument " "4"" of type '" "bool""'");
13035 }
13036 arg4 = static_cast< bool >(val4);
13037 }
13038 {
13039 PyThreadState* __tstate = wxPyBeginAllowThreads();
13040 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
13041 wxPyEndAllowThreads(__tstate);
13042 if (PyErr_Occurred()) SWIG_fail;
13043 }
13044 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogWindow, SWIG_POINTER_NEW | 0 );
13045 {
13046 if (temp2)
13047 delete arg2;
13048 }
13049 return resultobj;
13050 fail:
13051 {
13052 if (temp2)
13053 delete arg2;
13054 }
13055 return NULL;
13056 }
13057
13058
13059 SWIGINTERN PyObject *_wrap_LogWindow_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13060 PyObject *resultobj = 0;
13061 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13062 bool arg2 = (bool) true ;
13063 void *argp1 = 0 ;
13064 int res1 = 0 ;
13065 bool val2 ;
13066 int ecode2 = 0 ;
13067 PyObject * obj0 = 0 ;
13068 PyObject * obj1 = 0 ;
13069 char * kwnames[] = {
13070 (char *) "self",(char *) "bShow", NULL
13071 };
13072
13073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) SWIG_fail;
13074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13075 if (!SWIG_IsOK(res1)) {
13076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_Show" "', expected argument " "1"" of type '" "wxLogWindow *""'");
13077 }
13078 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13079 if (obj1) {
13080 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13081 if (!SWIG_IsOK(ecode2)) {
13082 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_Show" "', expected argument " "2"" of type '" "bool""'");
13083 }
13084 arg2 = static_cast< bool >(val2);
13085 }
13086 {
13087 PyThreadState* __tstate = wxPyBeginAllowThreads();
13088 (arg1)->Show(arg2);
13089 wxPyEndAllowThreads(__tstate);
13090 if (PyErr_Occurred()) SWIG_fail;
13091 }
13092 resultobj = SWIG_Py_Void();
13093 return resultobj;
13094 fail:
13095 return NULL;
13096 }
13097
13098
13099 SWIGINTERN PyObject *_wrap_LogWindow_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13100 PyObject *resultobj = 0;
13101 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13102 wxFrame *result = 0 ;
13103 void *argp1 = 0 ;
13104 int res1 = 0 ;
13105 PyObject *swig_obj[1] ;
13106
13107 if (!args) SWIG_fail;
13108 swig_obj[0] = args;
13109 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13110 if (!SWIG_IsOK(res1)) {
13111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetFrame" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
13112 }
13113 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13114 {
13115 PyThreadState* __tstate = wxPyBeginAllowThreads();
13116 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
13117 wxPyEndAllowThreads(__tstate);
13118 if (PyErr_Occurred()) SWIG_fail;
13119 }
13120 {
13121 resultobj = wxPyMake_wxObject(result, (bool)0);
13122 }
13123 return resultobj;
13124 fail:
13125 return NULL;
13126 }
13127
13128
13129 SWIGINTERN PyObject *_wrap_LogWindow_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13130 PyObject *resultobj = 0;
13131 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13132 wxLog *result = 0 ;
13133 void *argp1 = 0 ;
13134 int res1 = 0 ;
13135 PyObject *swig_obj[1] ;
13136
13137 if (!args) SWIG_fail;
13138 swig_obj[0] = args;
13139 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13140 if (!SWIG_IsOK(res1)) {
13141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetOldLog" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
13142 }
13143 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13144 {
13145 PyThreadState* __tstate = wxPyBeginAllowThreads();
13146 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
13147 wxPyEndAllowThreads(__tstate);
13148 if (PyErr_Occurred()) SWIG_fail;
13149 }
13150 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
13151 return resultobj;
13152 fail:
13153 return NULL;
13154 }
13155
13156
13157 SWIGINTERN PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13158 PyObject *resultobj = 0;
13159 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13160 bool result;
13161 void *argp1 = 0 ;
13162 int res1 = 0 ;
13163 PyObject *swig_obj[1] ;
13164
13165 if (!args) SWIG_fail;
13166 swig_obj[0] = args;
13167 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13168 if (!SWIG_IsOK(res1)) {
13169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
13170 }
13171 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13172 {
13173 PyThreadState* __tstate = wxPyBeginAllowThreads();
13174 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
13175 wxPyEndAllowThreads(__tstate);
13176 if (PyErr_Occurred()) SWIG_fail;
13177 }
13178 {
13179 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13180 }
13181 return resultobj;
13182 fail:
13183 return NULL;
13184 }
13185
13186
13187 SWIGINTERN PyObject *_wrap_LogWindow_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13188 PyObject *resultobj = 0;
13189 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13190 bool arg2 ;
13191 void *argp1 = 0 ;
13192 int res1 = 0 ;
13193 bool val2 ;
13194 int ecode2 = 0 ;
13195 PyObject * obj0 = 0 ;
13196 PyObject * obj1 = 0 ;
13197 char * kwnames[] = {
13198 (char *) "self",(char *) "bDoPass", NULL
13199 };
13200
13201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
13202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13203 if (!SWIG_IsOK(res1)) {
13204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_PassMessages" "', expected argument " "1"" of type '" "wxLogWindow *""'");
13205 }
13206 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13207 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13208 if (!SWIG_IsOK(ecode2)) {
13209 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_PassMessages" "', expected argument " "2"" of type '" "bool""'");
13210 }
13211 arg2 = static_cast< bool >(val2);
13212 {
13213 PyThreadState* __tstate = wxPyBeginAllowThreads();
13214 (arg1)->PassMessages(arg2);
13215 wxPyEndAllowThreads(__tstate);
13216 if (PyErr_Occurred()) SWIG_fail;
13217 }
13218 resultobj = SWIG_Py_Void();
13219 return resultobj;
13220 fail:
13221 return NULL;
13222 }
13223
13224
13225 SWIGINTERN PyObject *LogWindow_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13226 PyObject *obj;
13227 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13228 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogWindow, SWIG_NewClientData(obj));
13229 return SWIG_Py_Void();
13230 }
13231
13232 SWIGINTERN PyObject *LogWindow_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13233 return SWIG_Python_InitShadowInstance(args);
13234 }
13235
13236 SWIGINTERN PyObject *_wrap_new_LogChain(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13237 PyObject *resultobj = 0;
13238 wxLog *arg1 = (wxLog *) 0 ;
13239 wxLogChain *result = 0 ;
13240 void *argp1 = 0 ;
13241 int res1 = 0 ;
13242 PyObject * obj0 = 0 ;
13243 char * kwnames[] = {
13244 (char *) "logger", NULL
13245 };
13246
13247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) SWIG_fail;
13248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
13249 if (!SWIG_IsOK(res1)) {
13250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogChain" "', expected argument " "1"" of type '" "wxLog *""'");
13251 }
13252 arg1 = reinterpret_cast< wxLog * >(argp1);
13253 {
13254 PyThreadState* __tstate = wxPyBeginAllowThreads();
13255 result = (wxLogChain *)new wxLogChain(arg1);
13256 wxPyEndAllowThreads(__tstate);
13257 if (PyErr_Occurred()) SWIG_fail;
13258 }
13259 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogChain, SWIG_POINTER_NEW | 0 );
13260 return resultobj;
13261 fail:
13262 return NULL;
13263 }
13264
13265
13266 SWIGINTERN PyObject *_wrap_LogChain_SetLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13267 PyObject *resultobj = 0;
13268 wxLogChain *arg1 = (wxLogChain *) 0 ;
13269 wxLog *arg2 = (wxLog *) 0 ;
13270 void *argp1 = 0 ;
13271 int res1 = 0 ;
13272 void *argp2 = 0 ;
13273 int res2 = 0 ;
13274 PyObject * obj0 = 0 ;
13275 PyObject * obj1 = 0 ;
13276 char * kwnames[] = {
13277 (char *) "self",(char *) "logger", NULL
13278 };
13279
13280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) SWIG_fail;
13281 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13282 if (!SWIG_IsOK(res1)) {
13283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_SetLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
13284 }
13285 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13286 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLog, 0 | 0 );
13287 if (!SWIG_IsOK(res2)) {
13288 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LogChain_SetLog" "', expected argument " "2"" of type '" "wxLog *""'");
13289 }
13290 arg2 = reinterpret_cast< wxLog * >(argp2);
13291 {
13292 PyThreadState* __tstate = wxPyBeginAllowThreads();
13293 (arg1)->SetLog(arg2);
13294 wxPyEndAllowThreads(__tstate);
13295 if (PyErr_Occurred()) SWIG_fail;
13296 }
13297 resultobj = SWIG_Py_Void();
13298 return resultobj;
13299 fail:
13300 return NULL;
13301 }
13302
13303
13304 SWIGINTERN PyObject *_wrap_LogChain_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13305 PyObject *resultobj = 0;
13306 wxLogChain *arg1 = (wxLogChain *) 0 ;
13307 bool arg2 ;
13308 void *argp1 = 0 ;
13309 int res1 = 0 ;
13310 bool val2 ;
13311 int ecode2 = 0 ;
13312 PyObject * obj0 = 0 ;
13313 PyObject * obj1 = 0 ;
13314 char * kwnames[] = {
13315 (char *) "self",(char *) "bDoPass", NULL
13316 };
13317
13318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
13319 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13320 if (!SWIG_IsOK(res1)) {
13321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_PassMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
13322 }
13323 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13324 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13325 if (!SWIG_IsOK(ecode2)) {
13326 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogChain_PassMessages" "', expected argument " "2"" of type '" "bool""'");
13327 }
13328 arg2 = static_cast< bool >(val2);
13329 {
13330 PyThreadState* __tstate = wxPyBeginAllowThreads();
13331 (arg1)->PassMessages(arg2);
13332 wxPyEndAllowThreads(__tstate);
13333 if (PyErr_Occurred()) SWIG_fail;
13334 }
13335 resultobj = SWIG_Py_Void();
13336 return resultobj;
13337 fail:
13338 return NULL;
13339 }
13340
13341
13342 SWIGINTERN PyObject *_wrap_LogChain_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13343 PyObject *resultobj = 0;
13344 wxLogChain *arg1 = (wxLogChain *) 0 ;
13345 bool result;
13346 void *argp1 = 0 ;
13347 int res1 = 0 ;
13348 PyObject *swig_obj[1] ;
13349
13350 if (!args) SWIG_fail;
13351 swig_obj[0] = args;
13352 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13353 if (!SWIG_IsOK(res1)) {
13354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
13355 }
13356 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13357 {
13358 PyThreadState* __tstate = wxPyBeginAllowThreads();
13359 result = (bool)(arg1)->IsPassingMessages();
13360 wxPyEndAllowThreads(__tstate);
13361 if (PyErr_Occurred()) SWIG_fail;
13362 }
13363 {
13364 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13365 }
13366 return resultobj;
13367 fail:
13368 return NULL;
13369 }
13370
13371
13372 SWIGINTERN PyObject *_wrap_LogChain_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13373 PyObject *resultobj = 0;
13374 wxLogChain *arg1 = (wxLogChain *) 0 ;
13375 wxLog *result = 0 ;
13376 void *argp1 = 0 ;
13377 int res1 = 0 ;
13378 PyObject *swig_obj[1] ;
13379
13380 if (!args) SWIG_fail;
13381 swig_obj[0] = args;
13382 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13383 if (!SWIG_IsOK(res1)) {
13384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_GetOldLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
13385 }
13386 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13387 {
13388 PyThreadState* __tstate = wxPyBeginAllowThreads();
13389 result = (wxLog *)(arg1)->GetOldLog();
13390 wxPyEndAllowThreads(__tstate);
13391 if (PyErr_Occurred()) SWIG_fail;
13392 }
13393 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
13394 return resultobj;
13395 fail:
13396 return NULL;
13397 }
13398
13399
13400 SWIGINTERN PyObject *LogChain_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13401 PyObject *obj;
13402 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13403 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogChain, SWIG_NewClientData(obj));
13404 return SWIG_Py_Void();
13405 }
13406
13407 SWIGINTERN PyObject *LogChain_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13408 return SWIG_Python_InitShadowInstance(args);
13409 }
13410
13411 SWIGINTERN PyObject *_wrap_new_LogBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13412 PyObject *resultobj = 0;
13413 wxLogBuffer *result = 0 ;
13414
13415 if (!SWIG_Python_UnpackTuple(args,"new_LogBuffer",0,0,0)) SWIG_fail;
13416 {
13417 PyThreadState* __tstate = wxPyBeginAllowThreads();
13418 result = (wxLogBuffer *)new wxLogBuffer();
13419 wxPyEndAllowThreads(__tstate);
13420 if (PyErr_Occurred()) SWIG_fail;
13421 }
13422 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogBuffer, SWIG_POINTER_NEW | 0 );
13423 return resultobj;
13424 fail:
13425 return NULL;
13426 }
13427
13428
13429 SWIGINTERN PyObject *_wrap_LogBuffer_GetBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13430 PyObject *resultobj = 0;
13431 wxLogBuffer *arg1 = (wxLogBuffer *) 0 ;
13432 wxString *result = 0 ;
13433 void *argp1 = 0 ;
13434 int res1 = 0 ;
13435 PyObject *swig_obj[1] ;
13436
13437 if (!args) SWIG_fail;
13438 swig_obj[0] = args;
13439 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogBuffer, 0 | 0 );
13440 if (!SWIG_IsOK(res1)) {
13441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogBuffer_GetBuffer" "', expected argument " "1"" of type '" "wxLogBuffer const *""'");
13442 }
13443 arg1 = reinterpret_cast< wxLogBuffer * >(argp1);
13444 {
13445 PyThreadState* __tstate = wxPyBeginAllowThreads();
13446 {
13447 wxString const &_result_ref = ((wxLogBuffer const *)arg1)->GetBuffer();
13448 result = (wxString *) &_result_ref;
13449 }
13450 wxPyEndAllowThreads(__tstate);
13451 if (PyErr_Occurred()) SWIG_fail;
13452 }
13453 {
13454 #if wxUSE_UNICODE
13455 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13456 #else
13457 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13458 #endif
13459 }
13460 return resultobj;
13461 fail:
13462 return NULL;
13463 }
13464
13465
13466 SWIGINTERN PyObject *LogBuffer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13467 PyObject *obj;
13468 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13469 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogBuffer, SWIG_NewClientData(obj));
13470 return SWIG_Py_Void();
13471 }
13472
13473 SWIGINTERN PyObject *LogBuffer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13474 return SWIG_Python_InitShadowInstance(args);
13475 }
13476
13477 SWIGINTERN PyObject *_wrap_SysErrorCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13478 PyObject *resultobj = 0;
13479 unsigned long result;
13480
13481 if (!SWIG_Python_UnpackTuple(args,"SysErrorCode",0,0,0)) SWIG_fail;
13482 {
13483 PyThreadState* __tstate = wxPyBeginAllowThreads();
13484 result = (unsigned long)wxSysErrorCode();
13485 wxPyEndAllowThreads(__tstate);
13486 if (PyErr_Occurred()) SWIG_fail;
13487 }
13488 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
13489 return resultobj;
13490 fail:
13491 return NULL;
13492 }
13493
13494
13495 SWIGINTERN PyObject *_wrap_SysErrorMsg(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13496 PyObject *resultobj = 0;
13497 unsigned long arg1 = (unsigned long) 0 ;
13498 wxString result;
13499 unsigned long val1 ;
13500 int ecode1 = 0 ;
13501 PyObject * obj0 = 0 ;
13502 char * kwnames[] = {
13503 (char *) "nErrCode", NULL
13504 };
13505
13506 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) SWIG_fail;
13507 if (obj0) {
13508 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
13509 if (!SWIG_IsOK(ecode1)) {
13510 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SysErrorMsg" "', expected argument " "1"" of type '" "unsigned long""'");
13511 }
13512 arg1 = static_cast< unsigned long >(val1);
13513 }
13514 {
13515 PyThreadState* __tstate = wxPyBeginAllowThreads();
13516 result = wxSysErrorMsg(arg1);
13517 wxPyEndAllowThreads(__tstate);
13518 if (PyErr_Occurred()) SWIG_fail;
13519 }
13520 {
13521 #if wxUSE_UNICODE
13522 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13523 #else
13524 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13525 #endif
13526 }
13527 return resultobj;
13528 fail:
13529 return NULL;
13530 }
13531
13532
13533 SWIGINTERN PyObject *_wrap_LogFatalError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13534 PyObject *resultobj = 0;
13535 wxString *arg1 = 0 ;
13536 bool temp1 = false ;
13537 PyObject * obj0 = 0 ;
13538 char * kwnames[] = {
13539 (char *) "msg", NULL
13540 };
13541
13542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) SWIG_fail;
13543 {
13544 arg1 = wxString_in_helper(obj0);
13545 if (arg1 == NULL) SWIG_fail;
13546 temp1 = true;
13547 }
13548 {
13549 PyThreadState* __tstate = wxPyBeginAllowThreads();
13550 wxPyLogFatalError((wxString const &)*arg1);
13551 wxPyEndAllowThreads(__tstate);
13552 if (PyErr_Occurred()) SWIG_fail;
13553 }
13554 resultobj = SWIG_Py_Void();
13555 {
13556 if (temp1)
13557 delete arg1;
13558 }
13559 return resultobj;
13560 fail:
13561 {
13562 if (temp1)
13563 delete arg1;
13564 }
13565 return NULL;
13566 }
13567
13568
13569 SWIGINTERN PyObject *_wrap_LogError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13570 PyObject *resultobj = 0;
13571 wxString *arg1 = 0 ;
13572 bool temp1 = false ;
13573 PyObject * obj0 = 0 ;
13574 char * kwnames[] = {
13575 (char *) "msg", NULL
13576 };
13577
13578 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) SWIG_fail;
13579 {
13580 arg1 = wxString_in_helper(obj0);
13581 if (arg1 == NULL) SWIG_fail;
13582 temp1 = true;
13583 }
13584 {
13585 PyThreadState* __tstate = wxPyBeginAllowThreads();
13586 wxPyLogError((wxString const &)*arg1);
13587 wxPyEndAllowThreads(__tstate);
13588 if (PyErr_Occurred()) SWIG_fail;
13589 }
13590 resultobj = SWIG_Py_Void();
13591 {
13592 if (temp1)
13593 delete arg1;
13594 }
13595 return resultobj;
13596 fail:
13597 {
13598 if (temp1)
13599 delete arg1;
13600 }
13601 return NULL;
13602 }
13603
13604
13605 SWIGINTERN PyObject *_wrap_LogWarning(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13606 PyObject *resultobj = 0;
13607 wxString *arg1 = 0 ;
13608 bool temp1 = false ;
13609 PyObject * obj0 = 0 ;
13610 char * kwnames[] = {
13611 (char *) "msg", NULL
13612 };
13613
13614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) SWIG_fail;
13615 {
13616 arg1 = wxString_in_helper(obj0);
13617 if (arg1 == NULL) SWIG_fail;
13618 temp1 = true;
13619 }
13620 {
13621 PyThreadState* __tstate = wxPyBeginAllowThreads();
13622 wxPyLogWarning((wxString const &)*arg1);
13623 wxPyEndAllowThreads(__tstate);
13624 if (PyErr_Occurred()) SWIG_fail;
13625 }
13626 resultobj = SWIG_Py_Void();
13627 {
13628 if (temp1)
13629 delete arg1;
13630 }
13631 return resultobj;
13632 fail:
13633 {
13634 if (temp1)
13635 delete arg1;
13636 }
13637 return NULL;
13638 }
13639
13640
13641 SWIGINTERN PyObject *_wrap_LogMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13642 PyObject *resultobj = 0;
13643 wxString *arg1 = 0 ;
13644 bool temp1 = false ;
13645 PyObject * obj0 = 0 ;
13646 char * kwnames[] = {
13647 (char *) "msg", NULL
13648 };
13649
13650 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) SWIG_fail;
13651 {
13652 arg1 = wxString_in_helper(obj0);
13653 if (arg1 == NULL) SWIG_fail;
13654 temp1 = true;
13655 }
13656 {
13657 PyThreadState* __tstate = wxPyBeginAllowThreads();
13658 wxPyLogMessage((wxString const &)*arg1);
13659 wxPyEndAllowThreads(__tstate);
13660 if (PyErr_Occurred()) SWIG_fail;
13661 }
13662 resultobj = SWIG_Py_Void();
13663 {
13664 if (temp1)
13665 delete arg1;
13666 }
13667 return resultobj;
13668 fail:
13669 {
13670 if (temp1)
13671 delete arg1;
13672 }
13673 return NULL;
13674 }
13675
13676
13677 SWIGINTERN PyObject *_wrap_LogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13678 PyObject *resultobj = 0;
13679 wxString *arg1 = 0 ;
13680 bool temp1 = false ;
13681 PyObject * obj0 = 0 ;
13682 char * kwnames[] = {
13683 (char *) "msg", NULL
13684 };
13685
13686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) SWIG_fail;
13687 {
13688 arg1 = wxString_in_helper(obj0);
13689 if (arg1 == NULL) SWIG_fail;
13690 temp1 = true;
13691 }
13692 {
13693 PyThreadState* __tstate = wxPyBeginAllowThreads();
13694 wxPyLogInfo((wxString const &)*arg1);
13695 wxPyEndAllowThreads(__tstate);
13696 if (PyErr_Occurred()) SWIG_fail;
13697 }
13698 resultobj = SWIG_Py_Void();
13699 {
13700 if (temp1)
13701 delete arg1;
13702 }
13703 return resultobj;
13704 fail:
13705 {
13706 if (temp1)
13707 delete arg1;
13708 }
13709 return NULL;
13710 }
13711
13712
13713 SWIGINTERN PyObject *_wrap_LogDebug(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13714 PyObject *resultobj = 0;
13715 wxString *arg1 = 0 ;
13716 bool temp1 = false ;
13717 PyObject * obj0 = 0 ;
13718 char * kwnames[] = {
13719 (char *) "msg", NULL
13720 };
13721
13722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) SWIG_fail;
13723 {
13724 arg1 = wxString_in_helper(obj0);
13725 if (arg1 == NULL) SWIG_fail;
13726 temp1 = true;
13727 }
13728 {
13729 PyThreadState* __tstate = wxPyBeginAllowThreads();
13730 wxPyLogDebug((wxString const &)*arg1);
13731 wxPyEndAllowThreads(__tstate);
13732 if (PyErr_Occurred()) SWIG_fail;
13733 }
13734 resultobj = SWIG_Py_Void();
13735 {
13736 if (temp1)
13737 delete arg1;
13738 }
13739 return resultobj;
13740 fail:
13741 {
13742 if (temp1)
13743 delete arg1;
13744 }
13745 return NULL;
13746 }
13747
13748
13749 SWIGINTERN PyObject *_wrap_LogVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13750 PyObject *resultobj = 0;
13751 wxString *arg1 = 0 ;
13752 bool temp1 = false ;
13753 PyObject * obj0 = 0 ;
13754 char * kwnames[] = {
13755 (char *) "msg", NULL
13756 };
13757
13758 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) SWIG_fail;
13759 {
13760 arg1 = wxString_in_helper(obj0);
13761 if (arg1 == NULL) SWIG_fail;
13762 temp1 = true;
13763 }
13764 {
13765 PyThreadState* __tstate = wxPyBeginAllowThreads();
13766 wxPyLogVerbose((wxString const &)*arg1);
13767 wxPyEndAllowThreads(__tstate);
13768 if (PyErr_Occurred()) SWIG_fail;
13769 }
13770 resultobj = SWIG_Py_Void();
13771 {
13772 if (temp1)
13773 delete arg1;
13774 }
13775 return resultobj;
13776 fail:
13777 {
13778 if (temp1)
13779 delete arg1;
13780 }
13781 return NULL;
13782 }
13783
13784
13785 SWIGINTERN PyObject *_wrap_LogStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13786 PyObject *resultobj = 0;
13787 wxString *arg1 = 0 ;
13788 bool temp1 = false ;
13789 PyObject * obj0 = 0 ;
13790 char * kwnames[] = {
13791 (char *) "msg", NULL
13792 };
13793
13794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) SWIG_fail;
13795 {
13796 arg1 = wxString_in_helper(obj0);
13797 if (arg1 == NULL) SWIG_fail;
13798 temp1 = true;
13799 }
13800 {
13801 PyThreadState* __tstate = wxPyBeginAllowThreads();
13802 wxPyLogStatus((wxString const &)*arg1);
13803 wxPyEndAllowThreads(__tstate);
13804 if (PyErr_Occurred()) SWIG_fail;
13805 }
13806 resultobj = SWIG_Py_Void();
13807 {
13808 if (temp1)
13809 delete arg1;
13810 }
13811 return resultobj;
13812 fail:
13813 {
13814 if (temp1)
13815 delete arg1;
13816 }
13817 return NULL;
13818 }
13819
13820
13821 SWIGINTERN PyObject *_wrap_LogStatusFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13822 PyObject *resultobj = 0;
13823 wxFrame *arg1 = (wxFrame *) 0 ;
13824 wxString *arg2 = 0 ;
13825 void *argp1 = 0 ;
13826 int res1 = 0 ;
13827 bool temp2 = false ;
13828 PyObject * obj0 = 0 ;
13829 PyObject * obj1 = 0 ;
13830 char * kwnames[] = {
13831 (char *) "pFrame",(char *) "msg", NULL
13832 };
13833
13834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) SWIG_fail;
13835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
13836 if (!SWIG_IsOK(res1)) {
13837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogStatusFrame" "', expected argument " "1"" of type '" "wxFrame *""'");
13838 }
13839 arg1 = reinterpret_cast< wxFrame * >(argp1);
13840 {
13841 arg2 = wxString_in_helper(obj1);
13842 if (arg2 == NULL) SWIG_fail;
13843 temp2 = true;
13844 }
13845 {
13846 PyThreadState* __tstate = wxPyBeginAllowThreads();
13847 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
13848 wxPyEndAllowThreads(__tstate);
13849 if (PyErr_Occurred()) SWIG_fail;
13850 }
13851 resultobj = SWIG_Py_Void();
13852 {
13853 if (temp2)
13854 delete arg2;
13855 }
13856 return resultobj;
13857 fail:
13858 {
13859 if (temp2)
13860 delete arg2;
13861 }
13862 return NULL;
13863 }
13864
13865
13866 SWIGINTERN PyObject *_wrap_LogSysError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13867 PyObject *resultobj = 0;
13868 wxString *arg1 = 0 ;
13869 bool temp1 = false ;
13870 PyObject * obj0 = 0 ;
13871 char * kwnames[] = {
13872 (char *) "msg", NULL
13873 };
13874
13875 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) SWIG_fail;
13876 {
13877 arg1 = wxString_in_helper(obj0);
13878 if (arg1 == NULL) SWIG_fail;
13879 temp1 = true;
13880 }
13881 {
13882 PyThreadState* __tstate = wxPyBeginAllowThreads();
13883 wxPyLogSysError((wxString const &)*arg1);
13884 wxPyEndAllowThreads(__tstate);
13885 if (PyErr_Occurred()) SWIG_fail;
13886 }
13887 resultobj = SWIG_Py_Void();
13888 {
13889 if (temp1)
13890 delete arg1;
13891 }
13892 return resultobj;
13893 fail:
13894 {
13895 if (temp1)
13896 delete arg1;
13897 }
13898 return NULL;
13899 }
13900
13901
13902 SWIGINTERN PyObject *_wrap_LogGeneric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13903 PyObject *resultobj = 0;
13904 unsigned long arg1 ;
13905 wxString *arg2 = 0 ;
13906 unsigned long val1 ;
13907 int ecode1 = 0 ;
13908 bool temp2 = false ;
13909 PyObject * obj0 = 0 ;
13910 PyObject * obj1 = 0 ;
13911 char * kwnames[] = {
13912 (char *) "level",(char *) "msg", NULL
13913 };
13914
13915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) SWIG_fail;
13916 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
13917 if (!SWIG_IsOK(ecode1)) {
13918 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogGeneric" "', expected argument " "1"" of type '" "unsigned long""'");
13919 }
13920 arg1 = static_cast< unsigned long >(val1);
13921 {
13922 arg2 = wxString_in_helper(obj1);
13923 if (arg2 == NULL) SWIG_fail;
13924 temp2 = true;
13925 }
13926 {
13927 PyThreadState* __tstate = wxPyBeginAllowThreads();
13928 wxPyLogGeneric(arg1,(wxString const &)*arg2);
13929 wxPyEndAllowThreads(__tstate);
13930 if (PyErr_Occurred()) SWIG_fail;
13931 }
13932 resultobj = SWIG_Py_Void();
13933 {
13934 if (temp2)
13935 delete arg2;
13936 }
13937 return resultobj;
13938 fail:
13939 {
13940 if (temp2)
13941 delete arg2;
13942 }
13943 return NULL;
13944 }
13945
13946
13947 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
13948 PyObject *resultobj = 0;
13949 unsigned long arg1 ;
13950 wxString *arg2 = 0 ;
13951 unsigned long val1 ;
13952 int ecode1 = 0 ;
13953 bool temp2 = false ;
13954
13955 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
13956 ecode1 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val1);
13957 if (!SWIG_IsOK(ecode1)) {
13958 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogTrace" "', expected argument " "1"" of type '" "unsigned long""'");
13959 }
13960 arg1 = static_cast< unsigned long >(val1);
13961 {
13962 arg2 = wxString_in_helper(swig_obj[1]);
13963 if (arg2 == NULL) SWIG_fail;
13964 temp2 = true;
13965 }
13966 {
13967 PyThreadState* __tstate = wxPyBeginAllowThreads();
13968 wxPyLogTrace(arg1,(wxString const &)*arg2);
13969 wxPyEndAllowThreads(__tstate);
13970 if (PyErr_Occurred()) SWIG_fail;
13971 }
13972 resultobj = SWIG_Py_Void();
13973 {
13974 if (temp2)
13975 delete arg2;
13976 }
13977 return resultobj;
13978 fail:
13979 {
13980 if (temp2)
13981 delete arg2;
13982 }
13983 return NULL;
13984 }
13985
13986
13987 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
13988 PyObject *resultobj = 0;
13989 wxString *arg1 = 0 ;
13990 wxString *arg2 = 0 ;
13991 bool temp1 = false ;
13992 bool temp2 = false ;
13993
13994 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
13995 {
13996 arg1 = wxString_in_helper(swig_obj[0]);
13997 if (arg1 == NULL) SWIG_fail;
13998 temp1 = true;
13999 }
14000 {
14001 arg2 = wxString_in_helper(swig_obj[1]);
14002 if (arg2 == NULL) SWIG_fail;
14003 temp2 = true;
14004 }
14005 {
14006 PyThreadState* __tstate = wxPyBeginAllowThreads();
14007 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
14008 wxPyEndAllowThreads(__tstate);
14009 if (PyErr_Occurred()) SWIG_fail;
14010 }
14011 resultobj = SWIG_Py_Void();
14012 {
14013 if (temp1)
14014 delete arg1;
14015 }
14016 {
14017 if (temp2)
14018 delete arg2;
14019 }
14020 return resultobj;
14021 fail:
14022 {
14023 if (temp1)
14024 delete arg1;
14025 }
14026 {
14027 if (temp2)
14028 delete arg2;
14029 }
14030 return NULL;
14031 }
14032
14033
14034 SWIGINTERN PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
14035 int argc;
14036 PyObject *argv[3];
14037
14038 if (!(argc = SWIG_Python_UnpackTuple(args,"LogTrace",0,2,argv))) SWIG_fail;
14039 --argc;
14040 if (argc == 2) {
14041 int _v = 0;
14042 {
14043 {
14044 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
14045 }
14046 }
14047 if (!_v) goto check_1;
14048 return _wrap_LogTrace__SWIG_1(self, argc, argv);
14049 }
14050 check_1:
14051
14052 if (argc == 2) {
14053 return _wrap_LogTrace__SWIG_0(self, argc, argv);
14054 }
14055
14056 fail:
14057 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
14058 return NULL;
14059 }
14060
14061
14062 SWIGINTERN PyObject *_wrap_SafeShowMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14063 PyObject *resultobj = 0;
14064 wxString *arg1 = 0 ;
14065 wxString *arg2 = 0 ;
14066 bool temp1 = false ;
14067 bool temp2 = false ;
14068 PyObject * obj0 = 0 ;
14069 PyObject * obj1 = 0 ;
14070 char * kwnames[] = {
14071 (char *) "title",(char *) "text", NULL
14072 };
14073
14074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) SWIG_fail;
14075 {
14076 arg1 = wxString_in_helper(obj0);
14077 if (arg1 == NULL) SWIG_fail;
14078 temp1 = true;
14079 }
14080 {
14081 arg2 = wxString_in_helper(obj1);
14082 if (arg2 == NULL) SWIG_fail;
14083 temp2 = true;
14084 }
14085 {
14086 PyThreadState* __tstate = wxPyBeginAllowThreads();
14087 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
14088 wxPyEndAllowThreads(__tstate);
14089 if (PyErr_Occurred()) SWIG_fail;
14090 }
14091 resultobj = SWIG_Py_Void();
14092 {
14093 if (temp1)
14094 delete arg1;
14095 }
14096 {
14097 if (temp2)
14098 delete arg2;
14099 }
14100 return resultobj;
14101 fail:
14102 {
14103 if (temp1)
14104 delete arg1;
14105 }
14106 {
14107 if (temp2)
14108 delete arg2;
14109 }
14110 return NULL;
14111 }
14112
14113
14114 SWIGINTERN PyObject *_wrap_new_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14115 PyObject *resultobj = 0;
14116 wxLogNull *result = 0 ;
14117
14118 if (!SWIG_Python_UnpackTuple(args,"new_LogNull",0,0,0)) SWIG_fail;
14119 {
14120 PyThreadState* __tstate = wxPyBeginAllowThreads();
14121 result = (wxLogNull *)new wxLogNull();
14122 wxPyEndAllowThreads(__tstate);
14123 if (PyErr_Occurred()) SWIG_fail;
14124 }
14125 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogNull, SWIG_POINTER_NEW | 0 );
14126 return resultobj;
14127 fail:
14128 return NULL;
14129 }
14130
14131
14132 SWIGINTERN PyObject *_wrap_delete_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14133 PyObject *resultobj = 0;
14134 wxLogNull *arg1 = (wxLogNull *) 0 ;
14135 void *argp1 = 0 ;
14136 int res1 = 0 ;
14137 PyObject *swig_obj[1] ;
14138
14139 if (!args) SWIG_fail;
14140 swig_obj[0] = args;
14141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogNull, SWIG_POINTER_DISOWN | 0 );
14142 if (!SWIG_IsOK(res1)) {
14143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LogNull" "', expected argument " "1"" of type '" "wxLogNull *""'");
14144 }
14145 arg1 = reinterpret_cast< wxLogNull * >(argp1);
14146 {
14147 PyThreadState* __tstate = wxPyBeginAllowThreads();
14148 delete arg1;
14149
14150 wxPyEndAllowThreads(__tstate);
14151 if (PyErr_Occurred()) SWIG_fail;
14152 }
14153 resultobj = SWIG_Py_Void();
14154 return resultobj;
14155 fail:
14156 return NULL;
14157 }
14158
14159
14160 SWIGINTERN PyObject *LogNull_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14161 PyObject *obj;
14162 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14163 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogNull, SWIG_NewClientData(obj));
14164 return SWIG_Py_Void();
14165 }
14166
14167 SWIGINTERN PyObject *LogNull_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14168 return SWIG_Python_InitShadowInstance(args);
14169 }
14170
14171 SWIGINTERN PyObject *_wrap_new_PyLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14172 PyObject *resultobj = 0;
14173 wxPyLog *result = 0 ;
14174
14175 if (!SWIG_Python_UnpackTuple(args,"new_PyLog",0,0,0)) SWIG_fail;
14176 {
14177 PyThreadState* __tstate = wxPyBeginAllowThreads();
14178 result = (wxPyLog *)new wxPyLog();
14179 wxPyEndAllowThreads(__tstate);
14180 if (PyErr_Occurred()) SWIG_fail;
14181 }
14182 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyLog, SWIG_POINTER_NEW | 0 );
14183 return resultobj;
14184 fail:
14185 return NULL;
14186 }
14187
14188
14189 SWIGINTERN PyObject *_wrap_PyLog__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14190 PyObject *resultobj = 0;
14191 wxPyLog *arg1 = (wxPyLog *) 0 ;
14192 PyObject *arg2 = (PyObject *) 0 ;
14193 PyObject *arg3 = (PyObject *) 0 ;
14194 void *argp1 = 0 ;
14195 int res1 = 0 ;
14196 PyObject * obj0 = 0 ;
14197 PyObject * obj1 = 0 ;
14198 PyObject * obj2 = 0 ;
14199 char * kwnames[] = {
14200 (char *) "self",(char *) "self",(char *) "_class", NULL
14201 };
14202
14203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14204 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyLog, 0 | 0 );
14205 if (!SWIG_IsOK(res1)) {
14206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyLog__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyLog *""'");
14207 }
14208 arg1 = reinterpret_cast< wxPyLog * >(argp1);
14209 arg2 = obj1;
14210 arg3 = obj2;
14211 {
14212 PyThreadState* __tstate = wxPyBeginAllowThreads();
14213 (arg1)->_setCallbackInfo(arg2,arg3);
14214 wxPyEndAllowThreads(__tstate);
14215 if (PyErr_Occurred()) SWIG_fail;
14216 }
14217 resultobj = SWIG_Py_Void();
14218 return resultobj;
14219 fail:
14220 return NULL;
14221 }
14222
14223
14224 SWIGINTERN PyObject *PyLog_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14225 PyObject *obj;
14226 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14227 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyLog, SWIG_NewClientData(obj));
14228 return SWIG_Py_Void();
14229 }
14230
14231 SWIGINTERN PyObject *PyLog_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14232 return SWIG_Python_InitShadowInstance(args);
14233 }
14234
14235 SWIGINTERN PyObject *_wrap_Process_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14236 PyObject *resultobj = 0;
14237 int arg1 ;
14238 wxSignal arg2 = (wxSignal) wxSIGTERM ;
14239 int arg3 = (int) wxKILL_NOCHILDREN ;
14240 wxKillError result;
14241 int val1 ;
14242 int ecode1 = 0 ;
14243 int val2 ;
14244 int ecode2 = 0 ;
14245 int val3 ;
14246 int ecode3 = 0 ;
14247 PyObject * obj0 = 0 ;
14248 PyObject * obj1 = 0 ;
14249 PyObject * obj2 = 0 ;
14250 char * kwnames[] = {
14251 (char *) "pid",(char *) "sig",(char *) "flags", NULL
14252 };
14253
14254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14255 ecode1 = SWIG_AsVal_int(obj0, &val1);
14256 if (!SWIG_IsOK(ecode1)) {
14257 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Kill" "', expected argument " "1"" of type '" "int""'");
14258 }
14259 arg1 = static_cast< int >(val1);
14260 if (obj1) {
14261 ecode2 = SWIG_AsVal_int(obj1, &val2);
14262 if (!SWIG_IsOK(ecode2)) {
14263 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Kill" "', expected argument " "2"" of type '" "wxSignal""'");
14264 }
14265 arg2 = static_cast< wxSignal >(val2);
14266 }
14267 if (obj2) {
14268 ecode3 = SWIG_AsVal_int(obj2, &val3);
14269 if (!SWIG_IsOK(ecode3)) {
14270 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_Kill" "', expected argument " "3"" of type '" "int""'");
14271 }
14272 arg3 = static_cast< int >(val3);
14273 }
14274 {
14275 PyThreadState* __tstate = wxPyBeginAllowThreads();
14276 result = (wxKillError)wxPyProcess::Kill(arg1,arg2,arg3);
14277 wxPyEndAllowThreads(__tstate);
14278 if (PyErr_Occurred()) SWIG_fail;
14279 }
14280 resultobj = SWIG_From_int(static_cast< int >(result));
14281 return resultobj;
14282 fail:
14283 return NULL;
14284 }
14285
14286
14287 SWIGINTERN PyObject *_wrap_Process_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14288 PyObject *resultobj = 0;
14289 int arg1 ;
14290 bool result;
14291 int val1 ;
14292 int ecode1 = 0 ;
14293 PyObject * obj0 = 0 ;
14294 char * kwnames[] = {
14295 (char *) "pid", NULL
14296 };
14297
14298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) SWIG_fail;
14299 ecode1 = SWIG_AsVal_int(obj0, &val1);
14300 if (!SWIG_IsOK(ecode1)) {
14301 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Exists" "', expected argument " "1"" of type '" "int""'");
14302 }
14303 arg1 = static_cast< int >(val1);
14304 {
14305 PyThreadState* __tstate = wxPyBeginAllowThreads();
14306 result = (bool)wxPyProcess::Exists(arg1);
14307 wxPyEndAllowThreads(__tstate);
14308 if (PyErr_Occurred()) SWIG_fail;
14309 }
14310 {
14311 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14312 }
14313 return resultobj;
14314 fail:
14315 return NULL;
14316 }
14317
14318
14319 SWIGINTERN PyObject *_wrap_Process_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14320 PyObject *resultobj = 0;
14321 wxString *arg1 = 0 ;
14322 int arg2 = (int) wxEXEC_ASYNC ;
14323 wxPyProcess *result = 0 ;
14324 bool temp1 = false ;
14325 int val2 ;
14326 int ecode2 = 0 ;
14327 PyObject * obj0 = 0 ;
14328 PyObject * obj1 = 0 ;
14329 char * kwnames[] = {
14330 (char *) "cmd",(char *) "flags", NULL
14331 };
14332
14333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) SWIG_fail;
14334 {
14335 arg1 = wxString_in_helper(obj0);
14336 if (arg1 == NULL) SWIG_fail;
14337 temp1 = true;
14338 }
14339 if (obj1) {
14340 ecode2 = SWIG_AsVal_int(obj1, &val2);
14341 if (!SWIG_IsOK(ecode2)) {
14342 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Open" "', expected argument " "2"" of type '" "int""'");
14343 }
14344 arg2 = static_cast< int >(val2);
14345 }
14346 {
14347 PyThreadState* __tstate = wxPyBeginAllowThreads();
14348 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
14349 wxPyEndAllowThreads(__tstate);
14350 if (PyErr_Occurred()) SWIG_fail;
14351 }
14352 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, 0 | 0 );
14353 {
14354 if (temp1)
14355 delete arg1;
14356 }
14357 return resultobj;
14358 fail:
14359 {
14360 if (temp1)
14361 delete arg1;
14362 }
14363 return NULL;
14364 }
14365
14366
14367 SWIGINTERN PyObject *_wrap_new_Process(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14368 PyObject *resultobj = 0;
14369 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
14370 int arg2 = (int) -1 ;
14371 wxPyProcess *result = 0 ;
14372 void *argp1 = 0 ;
14373 int res1 = 0 ;
14374 int val2 ;
14375 int ecode2 = 0 ;
14376 PyObject * obj0 = 0 ;
14377 PyObject * obj1 = 0 ;
14378 char * kwnames[] = {
14379 (char *) "parent",(char *) "id", NULL
14380 };
14381
14382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) SWIG_fail;
14383 if (obj0) {
14384 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
14385 if (!SWIG_IsOK(res1)) {
14386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Process" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
14387 }
14388 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
14389 }
14390 if (obj1) {
14391 ecode2 = SWIG_AsVal_int(obj1, &val2);
14392 if (!SWIG_IsOK(ecode2)) {
14393 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Process" "', expected argument " "2"" of type '" "int""'");
14394 }
14395 arg2 = static_cast< int >(val2);
14396 }
14397 {
14398 PyThreadState* __tstate = wxPyBeginAllowThreads();
14399 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
14400 wxPyEndAllowThreads(__tstate);
14401 if (PyErr_Occurred()) SWIG_fail;
14402 }
14403 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, SWIG_POINTER_NEW | 0 );
14404 return resultobj;
14405 fail:
14406 return NULL;
14407 }
14408
14409
14410 SWIGINTERN PyObject *_wrap_Process__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14411 PyObject *resultobj = 0;
14412 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14413 PyObject *arg2 = (PyObject *) 0 ;
14414 PyObject *arg3 = (PyObject *) 0 ;
14415 void *argp1 = 0 ;
14416 int res1 = 0 ;
14417 PyObject * obj0 = 0 ;
14418 PyObject * obj1 = 0 ;
14419 PyObject * obj2 = 0 ;
14420 char * kwnames[] = {
14421 (char *) "self",(char *) "self",(char *) "_class", NULL
14422 };
14423
14424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14426 if (!SWIG_IsOK(res1)) {
14427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14428 }
14429 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14430 arg2 = obj1;
14431 arg3 = obj2;
14432 {
14433 PyThreadState* __tstate = wxPyBeginAllowThreads();
14434 (arg1)->_setCallbackInfo(arg2,arg3);
14435 wxPyEndAllowThreads(__tstate);
14436 if (PyErr_Occurred()) SWIG_fail;
14437 }
14438 resultobj = SWIG_Py_Void();
14439 return resultobj;
14440 fail:
14441 return NULL;
14442 }
14443
14444
14445 SWIGINTERN PyObject *_wrap_Process_OnTerminate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14446 PyObject *resultobj = 0;
14447 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14448 int arg2 ;
14449 int arg3 ;
14450 void *argp1 = 0 ;
14451 int res1 = 0 ;
14452 int val2 ;
14453 int ecode2 = 0 ;
14454 int val3 ;
14455 int ecode3 = 0 ;
14456 PyObject * obj0 = 0 ;
14457 PyObject * obj1 = 0 ;
14458 PyObject * obj2 = 0 ;
14459 char * kwnames[] = {
14460 (char *) "self",(char *) "pid",(char *) "status", NULL
14461 };
14462
14463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_OnTerminate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14464 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14465 if (!SWIG_IsOK(res1)) {
14466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_OnTerminate" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14467 }
14468 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14469 ecode2 = SWIG_AsVal_int(obj1, &val2);
14470 if (!SWIG_IsOK(ecode2)) {
14471 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_OnTerminate" "', expected argument " "2"" of type '" "int""'");
14472 }
14473 arg2 = static_cast< int >(val2);
14474 ecode3 = SWIG_AsVal_int(obj2, &val3);
14475 if (!SWIG_IsOK(ecode3)) {
14476 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_OnTerminate" "', expected argument " "3"" of type '" "int""'");
14477 }
14478 arg3 = static_cast< int >(val3);
14479 {
14480 PyThreadState* __tstate = wxPyBeginAllowThreads();
14481 (arg1)->OnTerminate(arg2,arg3);
14482 wxPyEndAllowThreads(__tstate);
14483 if (PyErr_Occurred()) SWIG_fail;
14484 }
14485 resultobj = SWIG_Py_Void();
14486 return resultobj;
14487 fail:
14488 return NULL;
14489 }
14490
14491
14492 SWIGINTERN PyObject *_wrap_Process_Redirect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14493 PyObject *resultobj = 0;
14494 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14495 void *argp1 = 0 ;
14496 int res1 = 0 ;
14497 PyObject *swig_obj[1] ;
14498
14499 if (!args) SWIG_fail;
14500 swig_obj[0] = args;
14501 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14502 if (!SWIG_IsOK(res1)) {
14503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Redirect" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14504 }
14505 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14506 {
14507 PyThreadState* __tstate = wxPyBeginAllowThreads();
14508 (arg1)->Redirect();
14509 wxPyEndAllowThreads(__tstate);
14510 if (PyErr_Occurred()) SWIG_fail;
14511 }
14512 resultobj = SWIG_Py_Void();
14513 return resultobj;
14514 fail:
14515 return NULL;
14516 }
14517
14518
14519 SWIGINTERN PyObject *_wrap_Process_IsRedirected(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14520 PyObject *resultobj = 0;
14521 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14522 bool result;
14523 void *argp1 = 0 ;
14524 int res1 = 0 ;
14525 PyObject *swig_obj[1] ;
14526
14527 if (!args) SWIG_fail;
14528 swig_obj[0] = args;
14529 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14530 if (!SWIG_IsOK(res1)) {
14531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsRedirected" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14532 }
14533 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14534 {
14535 PyThreadState* __tstate = wxPyBeginAllowThreads();
14536 result = (bool)(arg1)->IsRedirected();
14537 wxPyEndAllowThreads(__tstate);
14538 if (PyErr_Occurred()) SWIG_fail;
14539 }
14540 {
14541 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14542 }
14543 return resultobj;
14544 fail:
14545 return NULL;
14546 }
14547
14548
14549 SWIGINTERN PyObject *_wrap_Process_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14550 PyObject *resultobj = 0;
14551 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14552 void *argp1 = 0 ;
14553 int res1 = 0 ;
14554 PyObject *swig_obj[1] ;
14555
14556 if (!args) SWIG_fail;
14557 swig_obj[0] = args;
14558 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14559 if (!SWIG_IsOK(res1)) {
14560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Detach" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14561 }
14562 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14563 {
14564 PyThreadState* __tstate = wxPyBeginAllowThreads();
14565 (arg1)->Detach();
14566 wxPyEndAllowThreads(__tstate);
14567 if (PyErr_Occurred()) SWIG_fail;
14568 }
14569 resultobj = SWIG_Py_Void();
14570 return resultobj;
14571 fail:
14572 return NULL;
14573 }
14574
14575
14576 SWIGINTERN PyObject *_wrap_Process_GetInputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14577 PyObject *resultobj = 0;
14578 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14579 wxInputStream *result = 0 ;
14580 void *argp1 = 0 ;
14581 int res1 = 0 ;
14582 PyObject *swig_obj[1] ;
14583
14584 if (!args) SWIG_fail;
14585 swig_obj[0] = args;
14586 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14587 if (!SWIG_IsOK(res1)) {
14588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetInputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14589 }
14590 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14591 {
14592 PyThreadState* __tstate = wxPyBeginAllowThreads();
14593 result = (wxInputStream *)(arg1)->GetInputStream();
14594 wxPyEndAllowThreads(__tstate);
14595 if (PyErr_Occurred()) SWIG_fail;
14596 }
14597 {
14598 wxPyInputStream * _ptr = NULL;
14599
14600 if (result) {
14601 _ptr = new wxPyInputStream(result);
14602 }
14603 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
14604 }
14605 return resultobj;
14606 fail:
14607 return NULL;
14608 }
14609
14610
14611 SWIGINTERN PyObject *_wrap_Process_GetErrorStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14612 PyObject *resultobj = 0;
14613 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14614 wxInputStream *result = 0 ;
14615 void *argp1 = 0 ;
14616 int res1 = 0 ;
14617 PyObject *swig_obj[1] ;
14618
14619 if (!args) SWIG_fail;
14620 swig_obj[0] = args;
14621 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14622 if (!SWIG_IsOK(res1)) {
14623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetErrorStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14624 }
14625 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14626 {
14627 PyThreadState* __tstate = wxPyBeginAllowThreads();
14628 result = (wxInputStream *)(arg1)->GetErrorStream();
14629 wxPyEndAllowThreads(__tstate);
14630 if (PyErr_Occurred()) SWIG_fail;
14631 }
14632 {
14633 wxPyInputStream * _ptr = NULL;
14634
14635 if (result) {
14636 _ptr = new wxPyInputStream(result);
14637 }
14638 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
14639 }
14640 return resultobj;
14641 fail:
14642 return NULL;
14643 }
14644
14645
14646 SWIGINTERN PyObject *_wrap_Process_GetOutputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14647 PyObject *resultobj = 0;
14648 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14649 wxOutputStream *result = 0 ;
14650 void *argp1 = 0 ;
14651 int res1 = 0 ;
14652 PyObject *swig_obj[1] ;
14653
14654 if (!args) SWIG_fail;
14655 swig_obj[0] = args;
14656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14657 if (!SWIG_IsOK(res1)) {
14658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetOutputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14659 }
14660 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14661 {
14662 PyThreadState* __tstate = wxPyBeginAllowThreads();
14663 result = (wxOutputStream *)(arg1)->GetOutputStream();
14664 wxPyEndAllowThreads(__tstate);
14665 if (PyErr_Occurred()) SWIG_fail;
14666 }
14667 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxOutputStream, 0 | 0 );
14668 return resultobj;
14669 fail:
14670 return NULL;
14671 }
14672
14673
14674 SWIGINTERN PyObject *_wrap_Process_CloseOutput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14675 PyObject *resultobj = 0;
14676 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14677 void *argp1 = 0 ;
14678 int res1 = 0 ;
14679 PyObject *swig_obj[1] ;
14680
14681 if (!args) SWIG_fail;
14682 swig_obj[0] = args;
14683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14684 if (!SWIG_IsOK(res1)) {
14685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_CloseOutput" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14686 }
14687 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14688 {
14689 PyThreadState* __tstate = wxPyBeginAllowThreads();
14690 (arg1)->CloseOutput();
14691 wxPyEndAllowThreads(__tstate);
14692 if (PyErr_Occurred()) SWIG_fail;
14693 }
14694 resultobj = SWIG_Py_Void();
14695 return resultobj;
14696 fail:
14697 return NULL;
14698 }
14699
14700
14701 SWIGINTERN PyObject *_wrap_Process_IsInputOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14702 PyObject *resultobj = 0;
14703 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14704 bool result;
14705 void *argp1 = 0 ;
14706 int res1 = 0 ;
14707 PyObject *swig_obj[1] ;
14708
14709 if (!args) SWIG_fail;
14710 swig_obj[0] = args;
14711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14712 if (!SWIG_IsOK(res1)) {
14713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputOpened" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14714 }
14715 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14716 {
14717 PyThreadState* __tstate = wxPyBeginAllowThreads();
14718 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
14719 wxPyEndAllowThreads(__tstate);
14720 if (PyErr_Occurred()) SWIG_fail;
14721 }
14722 {
14723 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14724 }
14725 return resultobj;
14726 fail:
14727 return NULL;
14728 }
14729
14730
14731 SWIGINTERN PyObject *_wrap_Process_IsInputAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14732 PyObject *resultobj = 0;
14733 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14734 bool result;
14735 void *argp1 = 0 ;
14736 int res1 = 0 ;
14737 PyObject *swig_obj[1] ;
14738
14739 if (!args) SWIG_fail;
14740 swig_obj[0] = args;
14741 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14742 if (!SWIG_IsOK(res1)) {
14743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14744 }
14745 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14746 {
14747 PyThreadState* __tstate = wxPyBeginAllowThreads();
14748 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
14749 wxPyEndAllowThreads(__tstate);
14750 if (PyErr_Occurred()) SWIG_fail;
14751 }
14752 {
14753 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14754 }
14755 return resultobj;
14756 fail:
14757 return NULL;
14758 }
14759
14760
14761 SWIGINTERN PyObject *_wrap_Process_IsErrorAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14762 PyObject *resultobj = 0;
14763 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14764 bool result;
14765 void *argp1 = 0 ;
14766 int res1 = 0 ;
14767 PyObject *swig_obj[1] ;
14768
14769 if (!args) SWIG_fail;
14770 swig_obj[0] = args;
14771 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14772 if (!SWIG_IsOK(res1)) {
14773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsErrorAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14774 }
14775 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14776 {
14777 PyThreadState* __tstate = wxPyBeginAllowThreads();
14778 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
14779 wxPyEndAllowThreads(__tstate);
14780 if (PyErr_Occurred()) SWIG_fail;
14781 }
14782 {
14783 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14784 }
14785 return resultobj;
14786 fail:
14787 return NULL;
14788 }
14789
14790
14791 SWIGINTERN PyObject *Process_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14792 PyObject *obj;
14793 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14794 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyProcess, SWIG_NewClientData(obj));
14795 return SWIG_Py_Void();
14796 }
14797
14798 SWIGINTERN PyObject *Process_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14799 return SWIG_Python_InitShadowInstance(args);
14800 }
14801
14802 SWIGINTERN PyObject *_wrap_new_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14803 PyObject *resultobj = 0;
14804 int arg1 = (int) 0 ;
14805 int arg2 = (int) 0 ;
14806 int arg3 = (int) 0 ;
14807 wxProcessEvent *result = 0 ;
14808 int val1 ;
14809 int ecode1 = 0 ;
14810 int val2 ;
14811 int ecode2 = 0 ;
14812 int val3 ;
14813 int ecode3 = 0 ;
14814 PyObject * obj0 = 0 ;
14815 PyObject * obj1 = 0 ;
14816 PyObject * obj2 = 0 ;
14817 char * kwnames[] = {
14818 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
14819 };
14820
14821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14822 if (obj0) {
14823 ecode1 = SWIG_AsVal_int(obj0, &val1);
14824 if (!SWIG_IsOK(ecode1)) {
14825 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ProcessEvent" "', expected argument " "1"" of type '" "int""'");
14826 }
14827 arg1 = static_cast< int >(val1);
14828 }
14829 if (obj1) {
14830 ecode2 = SWIG_AsVal_int(obj1, &val2);
14831 if (!SWIG_IsOK(ecode2)) {
14832 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ProcessEvent" "', expected argument " "2"" of type '" "int""'");
14833 }
14834 arg2 = static_cast< int >(val2);
14835 }
14836 if (obj2) {
14837 ecode3 = SWIG_AsVal_int(obj2, &val3);
14838 if (!SWIG_IsOK(ecode3)) {
14839 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ProcessEvent" "', expected argument " "3"" of type '" "int""'");
14840 }
14841 arg3 = static_cast< int >(val3);
14842 }
14843 {
14844 PyThreadState* __tstate = wxPyBeginAllowThreads();
14845 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
14846 wxPyEndAllowThreads(__tstate);
14847 if (PyErr_Occurred()) SWIG_fail;
14848 }
14849 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_NEW | 0 );
14850 return resultobj;
14851 fail:
14852 return NULL;
14853 }
14854
14855
14856 SWIGINTERN PyObject *_wrap_ProcessEvent_GetPid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14857 PyObject *resultobj = 0;
14858 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14859 int result;
14860 void *argp1 = 0 ;
14861 int res1 = 0 ;
14862 PyObject *swig_obj[1] ;
14863
14864 if (!args) SWIG_fail;
14865 swig_obj[0] = args;
14866 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14867 if (!SWIG_IsOK(res1)) {
14868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetPid" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14869 }
14870 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14871 {
14872 PyThreadState* __tstate = wxPyBeginAllowThreads();
14873 result = (int)(arg1)->GetPid();
14874 wxPyEndAllowThreads(__tstate);
14875 if (PyErr_Occurred()) SWIG_fail;
14876 }
14877 resultobj = SWIG_From_int(static_cast< int >(result));
14878 return resultobj;
14879 fail:
14880 return NULL;
14881 }
14882
14883
14884 SWIGINTERN PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14885 PyObject *resultobj = 0;
14886 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14887 int result;
14888 void *argp1 = 0 ;
14889 int res1 = 0 ;
14890 PyObject *swig_obj[1] ;
14891
14892 if (!args) SWIG_fail;
14893 swig_obj[0] = args;
14894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14895 if (!SWIG_IsOK(res1)) {
14896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetExitCode" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14897 }
14898 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14899 {
14900 PyThreadState* __tstate = wxPyBeginAllowThreads();
14901 result = (int)(arg1)->GetExitCode();
14902 wxPyEndAllowThreads(__tstate);
14903 if (PyErr_Occurred()) SWIG_fail;
14904 }
14905 resultobj = SWIG_From_int(static_cast< int >(result));
14906 return resultobj;
14907 fail:
14908 return NULL;
14909 }
14910
14911
14912 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14913 PyObject *resultobj = 0;
14914 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14915 int arg2 ;
14916 void *argp1 = 0 ;
14917 int res1 = 0 ;
14918 int val2 ;
14919 int ecode2 = 0 ;
14920 PyObject *swig_obj[2] ;
14921
14922 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_pid_set",2,2,swig_obj)) SWIG_fail;
14923 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14924 if (!SWIG_IsOK(res1)) {
14925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14926 }
14927 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14928 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
14929 if (!SWIG_IsOK(ecode2)) {
14930 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "2"" of type '" "int""'");
14931 }
14932 arg2 = static_cast< int >(val2);
14933 if (arg1) (arg1)->m_pid = arg2;
14934
14935 resultobj = SWIG_Py_Void();
14936 return resultobj;
14937 fail:
14938 return NULL;
14939 }
14940
14941
14942 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14943 PyObject *resultobj = 0;
14944 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14945 int result;
14946 void *argp1 = 0 ;
14947 int res1 = 0 ;
14948 PyObject *swig_obj[1] ;
14949
14950 if (!args) SWIG_fail;
14951 swig_obj[0] = args;
14952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14953 if (!SWIG_IsOK(res1)) {
14954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14955 }
14956 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14957 result = (int) ((arg1)->m_pid);
14958 resultobj = SWIG_From_int(static_cast< int >(result));
14959 return resultobj;
14960 fail:
14961 return NULL;
14962 }
14963
14964
14965 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14966 PyObject *resultobj = 0;
14967 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14968 int arg2 ;
14969 void *argp1 = 0 ;
14970 int res1 = 0 ;
14971 int val2 ;
14972 int ecode2 = 0 ;
14973 PyObject *swig_obj[2] ;
14974
14975 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_exitcode_set",2,2,swig_obj)) SWIG_fail;
14976 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14977 if (!SWIG_IsOK(res1)) {
14978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14979 }
14980 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14981 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
14982 if (!SWIG_IsOK(ecode2)) {
14983 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "2"" of type '" "int""'");
14984 }
14985 arg2 = static_cast< int >(val2);
14986 if (arg1) (arg1)->m_exitcode = arg2;
14987
14988 resultobj = SWIG_Py_Void();
14989 return resultobj;
14990 fail:
14991 return NULL;
14992 }
14993
14994
14995 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14996 PyObject *resultobj = 0;
14997 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14998 int result;
14999 void *argp1 = 0 ;
15000 int res1 = 0 ;
15001 PyObject *swig_obj[1] ;
15002
15003 if (!args) SWIG_fail;
15004 swig_obj[0] = args;
15005 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
15006 if (!SWIG_IsOK(res1)) {
15007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
15008 }
15009 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
15010 result = (int) ((arg1)->m_exitcode);
15011 resultobj = SWIG_From_int(static_cast< int >(result));
15012 return resultobj;
15013 fail:
15014 return NULL;
15015 }
15016
15017
15018 SWIGINTERN PyObject *ProcessEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15019 PyObject *obj;
15020 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15021 SWIG_TypeNewClientData(SWIGTYPE_p_wxProcessEvent, SWIG_NewClientData(obj));
15022 return SWIG_Py_Void();
15023 }
15024
15025 SWIGINTERN PyObject *ProcessEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15026 return SWIG_Python_InitShadowInstance(args);
15027 }
15028
15029 SWIGINTERN PyObject *_wrap_Execute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15030 PyObject *resultobj = 0;
15031 wxString *arg1 = 0 ;
15032 int arg2 = (int) wxEXEC_ASYNC ;
15033 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
15034 long result;
15035 bool temp1 = false ;
15036 int val2 ;
15037 int ecode2 = 0 ;
15038 void *argp3 = 0 ;
15039 int res3 = 0 ;
15040 PyObject * obj0 = 0 ;
15041 PyObject * obj1 = 0 ;
15042 PyObject * obj2 = 0 ;
15043 char * kwnames[] = {
15044 (char *) "command",(char *) "flags",(char *) "process", NULL
15045 };
15046
15047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15048 {
15049 arg1 = wxString_in_helper(obj0);
15050 if (arg1 == NULL) SWIG_fail;
15051 temp1 = true;
15052 }
15053 if (obj1) {
15054 ecode2 = SWIG_AsVal_int(obj1, &val2);
15055 if (!SWIG_IsOK(ecode2)) {
15056 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Execute" "', expected argument " "2"" of type '" "int""'");
15057 }
15058 arg2 = static_cast< int >(val2);
15059 }
15060 if (obj2) {
15061 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxPyProcess, 0 | 0 );
15062 if (!SWIG_IsOK(res3)) {
15063 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Execute" "', expected argument " "3"" of type '" "wxPyProcess *""'");
15064 }
15065 arg3 = reinterpret_cast< wxPyProcess * >(argp3);
15066 }
15067 {
15068 if (!wxPyCheckForApp()) SWIG_fail;
15069 PyThreadState* __tstate = wxPyBeginAllowThreads();
15070 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
15071 wxPyEndAllowThreads(__tstate);
15072 if (PyErr_Occurred()) SWIG_fail;
15073 }
15074 resultobj = SWIG_From_long(static_cast< long >(result));
15075 {
15076 if (temp1)
15077 delete arg1;
15078 }
15079 return resultobj;
15080 fail:
15081 {
15082 if (temp1)
15083 delete arg1;
15084 }
15085 return NULL;
15086 }
15087
15088
15089 SWIGINTERN PyObject *_wrap_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15090 PyObject *resultobj = 0;
15091 long arg1 ;
15092 wxSignal arg2 = (wxSignal) wxSIGTERM ;
15093 wxKillError *arg3 = (wxKillError *) 0 ;
15094 int arg4 = (int) wxKILL_NOCHILDREN ;
15095 int result;
15096 long val1 ;
15097 int ecode1 = 0 ;
15098 int val2 ;
15099 int ecode2 = 0 ;
15100 wxKillError temp3 ;
15101 int val4 ;
15102 int ecode4 = 0 ;
15103 PyObject * obj0 = 0 ;
15104 PyObject * obj1 = 0 ;
15105 PyObject * obj2 = 0 ;
15106 char * kwnames[] = {
15107 (char *) "pid",(char *) "sig",(char *) "flags", NULL
15108 };
15109
15110 {
15111 arg3 = &temp3;
15112 }
15113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15114 ecode1 = SWIG_AsVal_long(obj0, &val1);
15115 if (!SWIG_IsOK(ecode1)) {
15116 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Kill" "', expected argument " "1"" of type '" "long""'");
15117 }
15118 arg1 = static_cast< long >(val1);
15119 if (obj1) {
15120 ecode2 = SWIG_AsVal_int(obj1, &val2);
15121 if (!SWIG_IsOK(ecode2)) {
15122 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Kill" "', expected argument " "2"" of type '" "wxSignal""'");
15123 }
15124 arg2 = static_cast< wxSignal >(val2);
15125 }
15126 if (obj2) {
15127 ecode4 = SWIG_AsVal_int(obj2, &val4);
15128 if (!SWIG_IsOK(ecode4)) {
15129 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Kill" "', expected argument " "4"" of type '" "int""'");
15130 }
15131 arg4 = static_cast< int >(val4);
15132 }
15133 {
15134 PyThreadState* __tstate = wxPyBeginAllowThreads();
15135 result = (int)wxKill(arg1,arg2,arg3,arg4);
15136 wxPyEndAllowThreads(__tstate);
15137 if (PyErr_Occurred()) SWIG_fail;
15138 }
15139 resultobj = SWIG_From_int(static_cast< int >(result));
15140 {
15141 PyObject* o;
15142 o = PyInt_FromLong((long) (*arg3));
15143
15144
15145
15146 resultobj = SWIG_Python_AppendOutput(resultobj, o);
15147
15148 }
15149 return resultobj;
15150 fail:
15151 return NULL;
15152 }
15153
15154
15155 SWIGINTERN PyObject *_wrap_new_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15156 PyObject *resultobj = 0;
15157 int arg1 = (int) wxJOYSTICK1 ;
15158 wxJoystick *result = 0 ;
15159 int val1 ;
15160 int ecode1 = 0 ;
15161 PyObject * obj0 = 0 ;
15162 char * kwnames[] = {
15163 (char *) "joystick", NULL
15164 };
15165
15166 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) SWIG_fail;
15167 if (obj0) {
15168 ecode1 = SWIG_AsVal_int(obj0, &val1);
15169 if (!SWIG_IsOK(ecode1)) {
15170 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Joystick" "', expected argument " "1"" of type '" "int""'");
15171 }
15172 arg1 = static_cast< int >(val1);
15173 }
15174 {
15175 if (!wxPyCheckForApp()) SWIG_fail;
15176 PyThreadState* __tstate = wxPyBeginAllowThreads();
15177 result = (wxJoystick *)new wxJoystick(arg1);
15178 wxPyEndAllowThreads(__tstate);
15179 if (PyErr_Occurred()) SWIG_fail;
15180 }
15181 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystick, SWIG_POINTER_NEW | 0 );
15182 return resultobj;
15183 fail:
15184 return NULL;
15185 }
15186
15187
15188 SWIGINTERN PyObject *_wrap_delete_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15189 PyObject *resultobj = 0;
15190 wxJoystick *arg1 = (wxJoystick *) 0 ;
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, SWIG_POINTER_DISOWN | 0 );
15198 if (!SWIG_IsOK(res1)) {
15199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Joystick" "', expected argument " "1"" of type '" "wxJoystick *""'");
15200 }
15201 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15202 {
15203 PyThreadState* __tstate = wxPyBeginAllowThreads();
15204 delete arg1;
15205
15206 wxPyEndAllowThreads(__tstate);
15207 if (PyErr_Occurred()) SWIG_fail;
15208 }
15209 resultobj = SWIG_Py_Void();
15210 return resultobj;
15211 fail:
15212 return NULL;
15213 }
15214
15215
15216 SWIGINTERN PyObject *_wrap_Joystick_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15217 PyObject *resultobj = 0;
15218 wxJoystick *arg1 = (wxJoystick *) 0 ;
15219 wxPoint result;
15220 void *argp1 = 0 ;
15221 int res1 = 0 ;
15222 PyObject *swig_obj[1] ;
15223
15224 if (!args) SWIG_fail;
15225 swig_obj[0] = args;
15226 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15227 if (!SWIG_IsOK(res1)) {
15228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15229 }
15230 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15231 {
15232 PyThreadState* __tstate = wxPyBeginAllowThreads();
15233 result = (arg1)->GetPosition();
15234 wxPyEndAllowThreads(__tstate);
15235 if (PyErr_Occurred()) SWIG_fail;
15236 }
15237 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
15238 return resultobj;
15239 fail:
15240 return NULL;
15241 }
15242
15243
15244 SWIGINTERN PyObject *_wrap_Joystick_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15245 PyObject *resultobj = 0;
15246 wxJoystick *arg1 = (wxJoystick *) 0 ;
15247 int result;
15248 void *argp1 = 0 ;
15249 int res1 = 0 ;
15250 PyObject *swig_obj[1] ;
15251
15252 if (!args) SWIG_fail;
15253 swig_obj[0] = args;
15254 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15255 if (!SWIG_IsOK(res1)) {
15256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15257 }
15258 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15259 {
15260 PyThreadState* __tstate = wxPyBeginAllowThreads();
15261 result = (int)(arg1)->GetZPosition();
15262 wxPyEndAllowThreads(__tstate);
15263 if (PyErr_Occurred()) SWIG_fail;
15264 }
15265 resultobj = SWIG_From_int(static_cast< int >(result));
15266 return resultobj;
15267 fail:
15268 return NULL;
15269 }
15270
15271
15272 SWIGINTERN PyObject *_wrap_Joystick_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15273 PyObject *resultobj = 0;
15274 wxJoystick *arg1 = (wxJoystick *) 0 ;
15275 int result;
15276 void *argp1 = 0 ;
15277 int res1 = 0 ;
15278 PyObject *swig_obj[1] ;
15279
15280 if (!args) SWIG_fail;
15281 swig_obj[0] = args;
15282 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15283 if (!SWIG_IsOK(res1)) {
15284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetButtonState" "', expected argument " "1"" of type '" "wxJoystick *""'");
15285 }
15286 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15287 {
15288 PyThreadState* __tstate = wxPyBeginAllowThreads();
15289 result = (int)(arg1)->GetButtonState();
15290 wxPyEndAllowThreads(__tstate);
15291 if (PyErr_Occurred()) SWIG_fail;
15292 }
15293 resultobj = SWIG_From_int(static_cast< int >(result));
15294 return resultobj;
15295 fail:
15296 return NULL;
15297 }
15298
15299
15300 SWIGINTERN PyObject *_wrap_Joystick_GetPOVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15301 PyObject *resultobj = 0;
15302 wxJoystick *arg1 = (wxJoystick *) 0 ;
15303 int result;
15304 void *argp1 = 0 ;
15305 int res1 = 0 ;
15306 PyObject *swig_obj[1] ;
15307
15308 if (!args) SWIG_fail;
15309 swig_obj[0] = args;
15310 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15311 if (!SWIG_IsOK(res1)) {
15312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15313 }
15314 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15315 {
15316 PyThreadState* __tstate = wxPyBeginAllowThreads();
15317 result = (int)(arg1)->GetPOVPosition();
15318 wxPyEndAllowThreads(__tstate);
15319 if (PyErr_Occurred()) SWIG_fail;
15320 }
15321 resultobj = SWIG_From_int(static_cast< int >(result));
15322 return resultobj;
15323 fail:
15324 return NULL;
15325 }
15326
15327
15328 SWIGINTERN PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15329 PyObject *resultobj = 0;
15330 wxJoystick *arg1 = (wxJoystick *) 0 ;
15331 int result;
15332 void *argp1 = 0 ;
15333 int res1 = 0 ;
15334 PyObject *swig_obj[1] ;
15335
15336 if (!args) SWIG_fail;
15337 swig_obj[0] = args;
15338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15339 if (!SWIG_IsOK(res1)) {
15340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVCTSPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15341 }
15342 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15343 {
15344 PyThreadState* __tstate = wxPyBeginAllowThreads();
15345 result = (int)(arg1)->GetPOVCTSPosition();
15346 wxPyEndAllowThreads(__tstate);
15347 if (PyErr_Occurred()) SWIG_fail;
15348 }
15349 resultobj = SWIG_From_int(static_cast< int >(result));
15350 return resultobj;
15351 fail:
15352 return NULL;
15353 }
15354
15355
15356 SWIGINTERN PyObject *_wrap_Joystick_GetRudderPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15357 PyObject *resultobj = 0;
15358 wxJoystick *arg1 = (wxJoystick *) 0 ;
15359 int result;
15360 void *argp1 = 0 ;
15361 int res1 = 0 ;
15362 PyObject *swig_obj[1] ;
15363
15364 if (!args) SWIG_fail;
15365 swig_obj[0] = args;
15366 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15367 if (!SWIG_IsOK(res1)) {
15368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15369 }
15370 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15371 {
15372 PyThreadState* __tstate = wxPyBeginAllowThreads();
15373 result = (int)(arg1)->GetRudderPosition();
15374 wxPyEndAllowThreads(__tstate);
15375 if (PyErr_Occurred()) SWIG_fail;
15376 }
15377 resultobj = SWIG_From_int(static_cast< int >(result));
15378 return resultobj;
15379 fail:
15380 return NULL;
15381 }
15382
15383
15384 SWIGINTERN PyObject *_wrap_Joystick_GetUPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15385 PyObject *resultobj = 0;
15386 wxJoystick *arg1 = (wxJoystick *) 0 ;
15387 int result;
15388 void *argp1 = 0 ;
15389 int res1 = 0 ;
15390 PyObject *swig_obj[1] ;
15391
15392 if (!args) SWIG_fail;
15393 swig_obj[0] = args;
15394 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15395 if (!SWIG_IsOK(res1)) {
15396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15397 }
15398 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15399 {
15400 PyThreadState* __tstate = wxPyBeginAllowThreads();
15401 result = (int)(arg1)->GetUPosition();
15402 wxPyEndAllowThreads(__tstate);
15403 if (PyErr_Occurred()) SWIG_fail;
15404 }
15405 resultobj = SWIG_From_int(static_cast< int >(result));
15406 return resultobj;
15407 fail:
15408 return NULL;
15409 }
15410
15411
15412 SWIGINTERN PyObject *_wrap_Joystick_GetVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15413 PyObject *resultobj = 0;
15414 wxJoystick *arg1 = (wxJoystick *) 0 ;
15415 int result;
15416 void *argp1 = 0 ;
15417 int res1 = 0 ;
15418 PyObject *swig_obj[1] ;
15419
15420 if (!args) SWIG_fail;
15421 swig_obj[0] = args;
15422 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15423 if (!SWIG_IsOK(res1)) {
15424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15425 }
15426 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15427 {
15428 PyThreadState* __tstate = wxPyBeginAllowThreads();
15429 result = (int)(arg1)->GetVPosition();
15430 wxPyEndAllowThreads(__tstate);
15431 if (PyErr_Occurred()) SWIG_fail;
15432 }
15433 resultobj = SWIG_From_int(static_cast< int >(result));
15434 return resultobj;
15435 fail:
15436 return NULL;
15437 }
15438
15439
15440 SWIGINTERN PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15441 PyObject *resultobj = 0;
15442 wxJoystick *arg1 = (wxJoystick *) 0 ;
15443 int result;
15444 void *argp1 = 0 ;
15445 int res1 = 0 ;
15446 PyObject *swig_obj[1] ;
15447
15448 if (!args) SWIG_fail;
15449 swig_obj[0] = args;
15450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15451 if (!SWIG_IsOK(res1)) {
15452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
15453 }
15454 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15455 {
15456 PyThreadState* __tstate = wxPyBeginAllowThreads();
15457 result = (int)(arg1)->GetMovementThreshold();
15458 wxPyEndAllowThreads(__tstate);
15459 if (PyErr_Occurred()) SWIG_fail;
15460 }
15461 resultobj = SWIG_From_int(static_cast< int >(result));
15462 return resultobj;
15463 fail:
15464 return NULL;
15465 }
15466
15467
15468 SWIGINTERN PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15469 PyObject *resultobj = 0;
15470 wxJoystick *arg1 = (wxJoystick *) 0 ;
15471 int arg2 ;
15472 void *argp1 = 0 ;
15473 int res1 = 0 ;
15474 int val2 ;
15475 int ecode2 = 0 ;
15476 PyObject * obj0 = 0 ;
15477 PyObject * obj1 = 0 ;
15478 char * kwnames[] = {
15479 (char *) "self",(char *) "threshold", NULL
15480 };
15481
15482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) SWIG_fail;
15483 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15484 if (!SWIG_IsOK(res1)) {
15485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
15486 }
15487 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15488 ecode2 = SWIG_AsVal_int(obj1, &val2);
15489 if (!SWIG_IsOK(ecode2)) {
15490 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "2"" of type '" "int""'");
15491 }
15492 arg2 = static_cast< int >(val2);
15493 {
15494 PyThreadState* __tstate = wxPyBeginAllowThreads();
15495 (arg1)->SetMovementThreshold(arg2);
15496 wxPyEndAllowThreads(__tstate);
15497 if (PyErr_Occurred()) SWIG_fail;
15498 }
15499 resultobj = SWIG_Py_Void();
15500 return resultobj;
15501 fail:
15502 return NULL;
15503 }
15504
15505
15506 SWIGINTERN PyObject *_wrap_Joystick_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15507 PyObject *resultobj = 0;
15508 wxJoystick *arg1 = (wxJoystick *) 0 ;
15509 bool result;
15510 void *argp1 = 0 ;
15511 int res1 = 0 ;
15512 PyObject *swig_obj[1] ;
15513
15514 if (!args) SWIG_fail;
15515 swig_obj[0] = args;
15516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15517 if (!SWIG_IsOK(res1)) {
15518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_IsOk" "', expected argument " "1"" of type '" "wxJoystick *""'");
15519 }
15520 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15521 {
15522 PyThreadState* __tstate = wxPyBeginAllowThreads();
15523 result = (bool)(arg1)->IsOk();
15524 wxPyEndAllowThreads(__tstate);
15525 if (PyErr_Occurred()) SWIG_fail;
15526 }
15527 {
15528 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15529 }
15530 return resultobj;
15531 fail:
15532 return NULL;
15533 }
15534
15535
15536 SWIGINTERN PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15537 PyObject *resultobj = 0;
15538 wxJoystick *arg1 = (wxJoystick *) 0 ;
15539 int result;
15540 void *argp1 = 0 ;
15541 int res1 = 0 ;
15542 PyObject *swig_obj[1] ;
15543
15544 if (!args) SWIG_fail;
15545 swig_obj[0] = args;
15546 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15547 if (!SWIG_IsOK(res1)) {
15548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberJoysticks" "', expected argument " "1"" of type '" "wxJoystick *""'");
15549 }
15550 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15551 {
15552 PyThreadState* __tstate = wxPyBeginAllowThreads();
15553 result = (int)(arg1)->GetNumberJoysticks();
15554 wxPyEndAllowThreads(__tstate);
15555 if (PyErr_Occurred()) SWIG_fail;
15556 }
15557 resultobj = SWIG_From_int(static_cast< int >(result));
15558 return resultobj;
15559 fail:
15560 return NULL;
15561 }
15562
15563
15564 SWIGINTERN PyObject *_wrap_Joystick_GetManufacturerId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15565 PyObject *resultobj = 0;
15566 wxJoystick *arg1 = (wxJoystick *) 0 ;
15567 int result;
15568 void *argp1 = 0 ;
15569 int res1 = 0 ;
15570 PyObject *swig_obj[1] ;
15571
15572 if (!args) SWIG_fail;
15573 swig_obj[0] = args;
15574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15575 if (!SWIG_IsOK(res1)) {
15576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetManufacturerId" "', expected argument " "1"" of type '" "wxJoystick *""'");
15577 }
15578 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15579 {
15580 PyThreadState* __tstate = wxPyBeginAllowThreads();
15581 result = (int)(arg1)->GetManufacturerId();
15582 wxPyEndAllowThreads(__tstate);
15583 if (PyErr_Occurred()) SWIG_fail;
15584 }
15585 resultobj = SWIG_From_int(static_cast< int >(result));
15586 return resultobj;
15587 fail:
15588 return NULL;
15589 }
15590
15591
15592 SWIGINTERN PyObject *_wrap_Joystick_GetProductId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15593 PyObject *resultobj = 0;
15594 wxJoystick *arg1 = (wxJoystick *) 0 ;
15595 int result;
15596 void *argp1 = 0 ;
15597 int res1 = 0 ;
15598 PyObject *swig_obj[1] ;
15599
15600 if (!args) SWIG_fail;
15601 swig_obj[0] = args;
15602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15603 if (!SWIG_IsOK(res1)) {
15604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductId" "', expected argument " "1"" of type '" "wxJoystick *""'");
15605 }
15606 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15607 {
15608 PyThreadState* __tstate = wxPyBeginAllowThreads();
15609 result = (int)(arg1)->GetProductId();
15610 wxPyEndAllowThreads(__tstate);
15611 if (PyErr_Occurred()) SWIG_fail;
15612 }
15613 resultobj = SWIG_From_int(static_cast< int >(result));
15614 return resultobj;
15615 fail:
15616 return NULL;
15617 }
15618
15619
15620 SWIGINTERN PyObject *_wrap_Joystick_GetProductName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15621 PyObject *resultobj = 0;
15622 wxJoystick *arg1 = (wxJoystick *) 0 ;
15623 wxString result;
15624 void *argp1 = 0 ;
15625 int res1 = 0 ;
15626 PyObject *swig_obj[1] ;
15627
15628 if (!args) SWIG_fail;
15629 swig_obj[0] = args;
15630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15631 if (!SWIG_IsOK(res1)) {
15632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductName" "', expected argument " "1"" of type '" "wxJoystick *""'");
15633 }
15634 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15635 {
15636 PyThreadState* __tstate = wxPyBeginAllowThreads();
15637 result = (arg1)->GetProductName();
15638 wxPyEndAllowThreads(__tstate);
15639 if (PyErr_Occurred()) SWIG_fail;
15640 }
15641 {
15642 #if wxUSE_UNICODE
15643 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15644 #else
15645 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15646 #endif
15647 }
15648 return resultobj;
15649 fail:
15650 return NULL;
15651 }
15652
15653
15654 SWIGINTERN PyObject *_wrap_Joystick_GetXMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15655 PyObject *resultobj = 0;
15656 wxJoystick *arg1 = (wxJoystick *) 0 ;
15657 int result;
15658 void *argp1 = 0 ;
15659 int res1 = 0 ;
15660 PyObject *swig_obj[1] ;
15661
15662 if (!args) SWIG_fail;
15663 swig_obj[0] = args;
15664 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15665 if (!SWIG_IsOK(res1)) {
15666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15667 }
15668 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15669 {
15670 PyThreadState* __tstate = wxPyBeginAllowThreads();
15671 result = (int)(arg1)->GetXMin();
15672 wxPyEndAllowThreads(__tstate);
15673 if (PyErr_Occurred()) SWIG_fail;
15674 }
15675 resultobj = SWIG_From_int(static_cast< int >(result));
15676 return resultobj;
15677 fail:
15678 return NULL;
15679 }
15680
15681
15682 SWIGINTERN PyObject *_wrap_Joystick_GetYMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15683 PyObject *resultobj = 0;
15684 wxJoystick *arg1 = (wxJoystick *) 0 ;
15685 int result;
15686 void *argp1 = 0 ;
15687 int res1 = 0 ;
15688 PyObject *swig_obj[1] ;
15689
15690 if (!args) SWIG_fail;
15691 swig_obj[0] = args;
15692 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15693 if (!SWIG_IsOK(res1)) {
15694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15695 }
15696 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15697 {
15698 PyThreadState* __tstate = wxPyBeginAllowThreads();
15699 result = (int)(arg1)->GetYMin();
15700 wxPyEndAllowThreads(__tstate);
15701 if (PyErr_Occurred()) SWIG_fail;
15702 }
15703 resultobj = SWIG_From_int(static_cast< int >(result));
15704 return resultobj;
15705 fail:
15706 return NULL;
15707 }
15708
15709
15710 SWIGINTERN PyObject *_wrap_Joystick_GetZMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15711 PyObject *resultobj = 0;
15712 wxJoystick *arg1 = (wxJoystick *) 0 ;
15713 int result;
15714 void *argp1 = 0 ;
15715 int res1 = 0 ;
15716 PyObject *swig_obj[1] ;
15717
15718 if (!args) SWIG_fail;
15719 swig_obj[0] = args;
15720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15721 if (!SWIG_IsOK(res1)) {
15722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15723 }
15724 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15725 {
15726 PyThreadState* __tstate = wxPyBeginAllowThreads();
15727 result = (int)(arg1)->GetZMin();
15728 wxPyEndAllowThreads(__tstate);
15729 if (PyErr_Occurred()) SWIG_fail;
15730 }
15731 resultobj = SWIG_From_int(static_cast< int >(result));
15732 return resultobj;
15733 fail:
15734 return NULL;
15735 }
15736
15737
15738 SWIGINTERN PyObject *_wrap_Joystick_GetXMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15739 PyObject *resultobj = 0;
15740 wxJoystick *arg1 = (wxJoystick *) 0 ;
15741 int result;
15742 void *argp1 = 0 ;
15743 int res1 = 0 ;
15744 PyObject *swig_obj[1] ;
15745
15746 if (!args) SWIG_fail;
15747 swig_obj[0] = args;
15748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15749 if (!SWIG_IsOK(res1)) {
15750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15751 }
15752 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15753 {
15754 PyThreadState* __tstate = wxPyBeginAllowThreads();
15755 result = (int)(arg1)->GetXMax();
15756 wxPyEndAllowThreads(__tstate);
15757 if (PyErr_Occurred()) SWIG_fail;
15758 }
15759 resultobj = SWIG_From_int(static_cast< int >(result));
15760 return resultobj;
15761 fail:
15762 return NULL;
15763 }
15764
15765
15766 SWIGINTERN PyObject *_wrap_Joystick_GetYMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15767 PyObject *resultobj = 0;
15768 wxJoystick *arg1 = (wxJoystick *) 0 ;
15769 int result;
15770 void *argp1 = 0 ;
15771 int res1 = 0 ;
15772 PyObject *swig_obj[1] ;
15773
15774 if (!args) SWIG_fail;
15775 swig_obj[0] = args;
15776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15777 if (!SWIG_IsOK(res1)) {
15778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15779 }
15780 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15781 {
15782 PyThreadState* __tstate = wxPyBeginAllowThreads();
15783 result = (int)(arg1)->GetYMax();
15784 wxPyEndAllowThreads(__tstate);
15785 if (PyErr_Occurred()) SWIG_fail;
15786 }
15787 resultobj = SWIG_From_int(static_cast< int >(result));
15788 return resultobj;
15789 fail:
15790 return NULL;
15791 }
15792
15793
15794 SWIGINTERN PyObject *_wrap_Joystick_GetZMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15795 PyObject *resultobj = 0;
15796 wxJoystick *arg1 = (wxJoystick *) 0 ;
15797 int result;
15798 void *argp1 = 0 ;
15799 int res1 = 0 ;
15800 PyObject *swig_obj[1] ;
15801
15802 if (!args) SWIG_fail;
15803 swig_obj[0] = args;
15804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15805 if (!SWIG_IsOK(res1)) {
15806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15807 }
15808 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15809 {
15810 PyThreadState* __tstate = wxPyBeginAllowThreads();
15811 result = (int)(arg1)->GetZMax();
15812 wxPyEndAllowThreads(__tstate);
15813 if (PyErr_Occurred()) SWIG_fail;
15814 }
15815 resultobj = SWIG_From_int(static_cast< int >(result));
15816 return resultobj;
15817 fail:
15818 return NULL;
15819 }
15820
15821
15822 SWIGINTERN PyObject *_wrap_Joystick_GetNumberButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15823 PyObject *resultobj = 0;
15824 wxJoystick *arg1 = (wxJoystick *) 0 ;
15825 int result;
15826 void *argp1 = 0 ;
15827 int res1 = 0 ;
15828 PyObject *swig_obj[1] ;
15829
15830 if (!args) SWIG_fail;
15831 swig_obj[0] = args;
15832 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15833 if (!SWIG_IsOK(res1)) {
15834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
15835 }
15836 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15837 {
15838 PyThreadState* __tstate = wxPyBeginAllowThreads();
15839 result = (int)(arg1)->GetNumberButtons();
15840 wxPyEndAllowThreads(__tstate);
15841 if (PyErr_Occurred()) SWIG_fail;
15842 }
15843 resultobj = SWIG_From_int(static_cast< int >(result));
15844 return resultobj;
15845 fail:
15846 return NULL;
15847 }
15848
15849
15850 SWIGINTERN PyObject *_wrap_Joystick_GetNumberAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15851 PyObject *resultobj = 0;
15852 wxJoystick *arg1 = (wxJoystick *) 0 ;
15853 int result;
15854 void *argp1 = 0 ;
15855 int res1 = 0 ;
15856 PyObject *swig_obj[1] ;
15857
15858 if (!args) SWIG_fail;
15859 swig_obj[0] = args;
15860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15861 if (!SWIG_IsOK(res1)) {
15862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
15863 }
15864 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15865 {
15866 PyThreadState* __tstate = wxPyBeginAllowThreads();
15867 result = (int)(arg1)->GetNumberAxes();
15868 wxPyEndAllowThreads(__tstate);
15869 if (PyErr_Occurred()) SWIG_fail;
15870 }
15871 resultobj = SWIG_From_int(static_cast< int >(result));
15872 return resultobj;
15873 fail:
15874 return NULL;
15875 }
15876
15877
15878 SWIGINTERN PyObject *_wrap_Joystick_GetMaxButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15879 PyObject *resultobj = 0;
15880 wxJoystick *arg1 = (wxJoystick *) 0 ;
15881 int result;
15882 void *argp1 = 0 ;
15883 int res1 = 0 ;
15884 PyObject *swig_obj[1] ;
15885
15886 if (!args) SWIG_fail;
15887 swig_obj[0] = args;
15888 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15889 if (!SWIG_IsOK(res1)) {
15890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
15891 }
15892 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15893 {
15894 PyThreadState* __tstate = wxPyBeginAllowThreads();
15895 result = (int)(arg1)->GetMaxButtons();
15896 wxPyEndAllowThreads(__tstate);
15897 if (PyErr_Occurred()) SWIG_fail;
15898 }
15899 resultobj = SWIG_From_int(static_cast< int >(result));
15900 return resultobj;
15901 fail:
15902 return NULL;
15903 }
15904
15905
15906 SWIGINTERN PyObject *_wrap_Joystick_GetMaxAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15907 PyObject *resultobj = 0;
15908 wxJoystick *arg1 = (wxJoystick *) 0 ;
15909 int result;
15910 void *argp1 = 0 ;
15911 int res1 = 0 ;
15912 PyObject *swig_obj[1] ;
15913
15914 if (!args) SWIG_fail;
15915 swig_obj[0] = args;
15916 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15917 if (!SWIG_IsOK(res1)) {
15918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
15919 }
15920 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15921 {
15922 PyThreadState* __tstate = wxPyBeginAllowThreads();
15923 result = (int)(arg1)->GetMaxAxes();
15924 wxPyEndAllowThreads(__tstate);
15925 if (PyErr_Occurred()) SWIG_fail;
15926 }
15927 resultobj = SWIG_From_int(static_cast< int >(result));
15928 return resultobj;
15929 fail:
15930 return NULL;
15931 }
15932
15933
15934 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15935 PyObject *resultobj = 0;
15936 wxJoystick *arg1 = (wxJoystick *) 0 ;
15937 int result;
15938 void *argp1 = 0 ;
15939 int res1 = 0 ;
15940 PyObject *swig_obj[1] ;
15941
15942 if (!args) SWIG_fail;
15943 swig_obj[0] = args;
15944 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15945 if (!SWIG_IsOK(res1)) {
15946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15947 }
15948 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15949 {
15950 PyThreadState* __tstate = wxPyBeginAllowThreads();
15951 result = (int)(arg1)->GetPollingMin();
15952 wxPyEndAllowThreads(__tstate);
15953 if (PyErr_Occurred()) SWIG_fail;
15954 }
15955 resultobj = SWIG_From_int(static_cast< int >(result));
15956 return resultobj;
15957 fail:
15958 return NULL;
15959 }
15960
15961
15962 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15963 PyObject *resultobj = 0;
15964 wxJoystick *arg1 = (wxJoystick *) 0 ;
15965 int result;
15966 void *argp1 = 0 ;
15967 int res1 = 0 ;
15968 PyObject *swig_obj[1] ;
15969
15970 if (!args) SWIG_fail;
15971 swig_obj[0] = args;
15972 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15973 if (!SWIG_IsOK(res1)) {
15974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15975 }
15976 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15977 {
15978 PyThreadState* __tstate = wxPyBeginAllowThreads();
15979 result = (int)(arg1)->GetPollingMax();
15980 wxPyEndAllowThreads(__tstate);
15981 if (PyErr_Occurred()) SWIG_fail;
15982 }
15983 resultobj = SWIG_From_int(static_cast< int >(result));
15984 return resultobj;
15985 fail:
15986 return NULL;
15987 }
15988
15989
15990 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15991 PyObject *resultobj = 0;
15992 wxJoystick *arg1 = (wxJoystick *) 0 ;
15993 int result;
15994 void *argp1 = 0 ;
15995 int res1 = 0 ;
15996 PyObject *swig_obj[1] ;
15997
15998 if (!args) SWIG_fail;
15999 swig_obj[0] = args;
16000 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16001 if (!SWIG_IsOK(res1)) {
16002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
16003 }
16004 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16005 {
16006 PyThreadState* __tstate = wxPyBeginAllowThreads();
16007 result = (int)(arg1)->GetRudderMin();
16008 wxPyEndAllowThreads(__tstate);
16009 if (PyErr_Occurred()) SWIG_fail;
16010 }
16011 resultobj = SWIG_From_int(static_cast< int >(result));
16012 return resultobj;
16013 fail:
16014 return NULL;
16015 }
16016
16017
16018 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16019 PyObject *resultobj = 0;
16020 wxJoystick *arg1 = (wxJoystick *) 0 ;
16021 int result;
16022 void *argp1 = 0 ;
16023 int res1 = 0 ;
16024 PyObject *swig_obj[1] ;
16025
16026 if (!args) SWIG_fail;
16027 swig_obj[0] = args;
16028 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16029 if (!SWIG_IsOK(res1)) {
16030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16031 }
16032 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16033 {
16034 PyThreadState* __tstate = wxPyBeginAllowThreads();
16035 result = (int)(arg1)->GetRudderMax();
16036 wxPyEndAllowThreads(__tstate);
16037 if (PyErr_Occurred()) SWIG_fail;
16038 }
16039 resultobj = SWIG_From_int(static_cast< int >(result));
16040 return resultobj;
16041 fail:
16042 return NULL;
16043 }
16044
16045
16046 SWIGINTERN PyObject *_wrap_Joystick_GetUMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16047 PyObject *resultobj = 0;
16048 wxJoystick *arg1 = (wxJoystick *) 0 ;
16049 int result;
16050 void *argp1 = 0 ;
16051 int res1 = 0 ;
16052 PyObject *swig_obj[1] ;
16053
16054 if (!args) SWIG_fail;
16055 swig_obj[0] = args;
16056 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16057 if (!SWIG_IsOK(res1)) {
16058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
16059 }
16060 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16061 {
16062 PyThreadState* __tstate = wxPyBeginAllowThreads();
16063 result = (int)(arg1)->GetUMin();
16064 wxPyEndAllowThreads(__tstate);
16065 if (PyErr_Occurred()) SWIG_fail;
16066 }
16067 resultobj = SWIG_From_int(static_cast< int >(result));
16068 return resultobj;
16069 fail:
16070 return NULL;
16071 }
16072
16073
16074 SWIGINTERN PyObject *_wrap_Joystick_GetUMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16075 PyObject *resultobj = 0;
16076 wxJoystick *arg1 = (wxJoystick *) 0 ;
16077 int result;
16078 void *argp1 = 0 ;
16079 int res1 = 0 ;
16080 PyObject *swig_obj[1] ;
16081
16082 if (!args) SWIG_fail;
16083 swig_obj[0] = args;
16084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16085 if (!SWIG_IsOK(res1)) {
16086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16087 }
16088 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16089 {
16090 PyThreadState* __tstate = wxPyBeginAllowThreads();
16091 result = (int)(arg1)->GetUMax();
16092 wxPyEndAllowThreads(__tstate);
16093 if (PyErr_Occurred()) SWIG_fail;
16094 }
16095 resultobj = SWIG_From_int(static_cast< int >(result));
16096 return resultobj;
16097 fail:
16098 return NULL;
16099 }
16100
16101
16102 SWIGINTERN PyObject *_wrap_Joystick_GetVMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16103 PyObject *resultobj = 0;
16104 wxJoystick *arg1 = (wxJoystick *) 0 ;
16105 int result;
16106 void *argp1 = 0 ;
16107 int res1 = 0 ;
16108 PyObject *swig_obj[1] ;
16109
16110 if (!args) SWIG_fail;
16111 swig_obj[0] = args;
16112 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16113 if (!SWIG_IsOK(res1)) {
16114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
16115 }
16116 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16117 {
16118 PyThreadState* __tstate = wxPyBeginAllowThreads();
16119 result = (int)(arg1)->GetVMin();
16120 wxPyEndAllowThreads(__tstate);
16121 if (PyErr_Occurred()) SWIG_fail;
16122 }
16123 resultobj = SWIG_From_int(static_cast< int >(result));
16124 return resultobj;
16125 fail:
16126 return NULL;
16127 }
16128
16129
16130 SWIGINTERN PyObject *_wrap_Joystick_GetVMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16131 PyObject *resultobj = 0;
16132 wxJoystick *arg1 = (wxJoystick *) 0 ;
16133 int result;
16134 void *argp1 = 0 ;
16135 int res1 = 0 ;
16136 PyObject *swig_obj[1] ;
16137
16138 if (!args) SWIG_fail;
16139 swig_obj[0] = args;
16140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16141 if (!SWIG_IsOK(res1)) {
16142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16143 }
16144 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16145 {
16146 PyThreadState* __tstate = wxPyBeginAllowThreads();
16147 result = (int)(arg1)->GetVMax();
16148 wxPyEndAllowThreads(__tstate);
16149 if (PyErr_Occurred()) SWIG_fail;
16150 }
16151 resultobj = SWIG_From_int(static_cast< int >(result));
16152 return resultobj;
16153 fail:
16154 return NULL;
16155 }
16156
16157
16158 SWIGINTERN PyObject *_wrap_Joystick_HasRudder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16159 PyObject *resultobj = 0;
16160 wxJoystick *arg1 = (wxJoystick *) 0 ;
16161 bool result;
16162 void *argp1 = 0 ;
16163 int res1 = 0 ;
16164 PyObject *swig_obj[1] ;
16165
16166 if (!args) SWIG_fail;
16167 swig_obj[0] = args;
16168 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16169 if (!SWIG_IsOK(res1)) {
16170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasRudder" "', expected argument " "1"" of type '" "wxJoystick *""'");
16171 }
16172 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16173 {
16174 PyThreadState* __tstate = wxPyBeginAllowThreads();
16175 result = (bool)(arg1)->HasRudder();
16176 wxPyEndAllowThreads(__tstate);
16177 if (PyErr_Occurred()) SWIG_fail;
16178 }
16179 {
16180 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16181 }
16182 return resultobj;
16183 fail:
16184 return NULL;
16185 }
16186
16187
16188 SWIGINTERN PyObject *_wrap_Joystick_HasZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16189 PyObject *resultobj = 0;
16190 wxJoystick *arg1 = (wxJoystick *) 0 ;
16191 bool result;
16192 void *argp1 = 0 ;
16193 int res1 = 0 ;
16194 PyObject *swig_obj[1] ;
16195
16196 if (!args) SWIG_fail;
16197 swig_obj[0] = args;
16198 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16199 if (!SWIG_IsOK(res1)) {
16200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasZ" "', expected argument " "1"" of type '" "wxJoystick *""'");
16201 }
16202 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16203 {
16204 PyThreadState* __tstate = wxPyBeginAllowThreads();
16205 result = (bool)(arg1)->HasZ();
16206 wxPyEndAllowThreads(__tstate);
16207 if (PyErr_Occurred()) SWIG_fail;
16208 }
16209 {
16210 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16211 }
16212 return resultobj;
16213 fail:
16214 return NULL;
16215 }
16216
16217
16218 SWIGINTERN PyObject *_wrap_Joystick_HasU(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16219 PyObject *resultobj = 0;
16220 wxJoystick *arg1 = (wxJoystick *) 0 ;
16221 bool result;
16222 void *argp1 = 0 ;
16223 int res1 = 0 ;
16224 PyObject *swig_obj[1] ;
16225
16226 if (!args) SWIG_fail;
16227 swig_obj[0] = args;
16228 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16229 if (!SWIG_IsOK(res1)) {
16230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasU" "', expected argument " "1"" of type '" "wxJoystick *""'");
16231 }
16232 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16233 {
16234 PyThreadState* __tstate = wxPyBeginAllowThreads();
16235 result = (bool)(arg1)->HasU();
16236 wxPyEndAllowThreads(__tstate);
16237 if (PyErr_Occurred()) SWIG_fail;
16238 }
16239 {
16240 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16241 }
16242 return resultobj;
16243 fail:
16244 return NULL;
16245 }
16246
16247
16248 SWIGINTERN PyObject *_wrap_Joystick_HasV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16249 PyObject *resultobj = 0;
16250 wxJoystick *arg1 = (wxJoystick *) 0 ;
16251 bool result;
16252 void *argp1 = 0 ;
16253 int res1 = 0 ;
16254 PyObject *swig_obj[1] ;
16255
16256 if (!args) SWIG_fail;
16257 swig_obj[0] = args;
16258 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16259 if (!SWIG_IsOK(res1)) {
16260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasV" "', expected argument " "1"" of type '" "wxJoystick *""'");
16261 }
16262 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16263 {
16264 PyThreadState* __tstate = wxPyBeginAllowThreads();
16265 result = (bool)(arg1)->HasV();
16266 wxPyEndAllowThreads(__tstate);
16267 if (PyErr_Occurred()) SWIG_fail;
16268 }
16269 {
16270 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16271 }
16272 return resultobj;
16273 fail:
16274 return NULL;
16275 }
16276
16277
16278 SWIGINTERN PyObject *_wrap_Joystick_HasPOV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16279 PyObject *resultobj = 0;
16280 wxJoystick *arg1 = (wxJoystick *) 0 ;
16281 bool result;
16282 void *argp1 = 0 ;
16283 int res1 = 0 ;
16284 PyObject *swig_obj[1] ;
16285
16286 if (!args) SWIG_fail;
16287 swig_obj[0] = args;
16288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16289 if (!SWIG_IsOK(res1)) {
16290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV" "', expected argument " "1"" of type '" "wxJoystick *""'");
16291 }
16292 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16293 {
16294 PyThreadState* __tstate = wxPyBeginAllowThreads();
16295 result = (bool)(arg1)->HasPOV();
16296 wxPyEndAllowThreads(__tstate);
16297 if (PyErr_Occurred()) SWIG_fail;
16298 }
16299 {
16300 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16301 }
16302 return resultobj;
16303 fail:
16304 return NULL;
16305 }
16306
16307
16308 SWIGINTERN PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16309 PyObject *resultobj = 0;
16310 wxJoystick *arg1 = (wxJoystick *) 0 ;
16311 bool result;
16312 void *argp1 = 0 ;
16313 int res1 = 0 ;
16314 PyObject *swig_obj[1] ;
16315
16316 if (!args) SWIG_fail;
16317 swig_obj[0] = args;
16318 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16319 if (!SWIG_IsOK(res1)) {
16320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV4Dir" "', expected argument " "1"" of type '" "wxJoystick *""'");
16321 }
16322 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16323 {
16324 PyThreadState* __tstate = wxPyBeginAllowThreads();
16325 result = (bool)(arg1)->HasPOV4Dir();
16326 wxPyEndAllowThreads(__tstate);
16327 if (PyErr_Occurred()) SWIG_fail;
16328 }
16329 {
16330 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16331 }
16332 return resultobj;
16333 fail:
16334 return NULL;
16335 }
16336
16337
16338 SWIGINTERN PyObject *_wrap_Joystick_HasPOVCTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16339 PyObject *resultobj = 0;
16340 wxJoystick *arg1 = (wxJoystick *) 0 ;
16341 bool result;
16342 void *argp1 = 0 ;
16343 int res1 = 0 ;
16344 PyObject *swig_obj[1] ;
16345
16346 if (!args) SWIG_fail;
16347 swig_obj[0] = args;
16348 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16349 if (!SWIG_IsOK(res1)) {
16350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOVCTS" "', expected argument " "1"" of type '" "wxJoystick *""'");
16351 }
16352 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16353 {
16354 PyThreadState* __tstate = wxPyBeginAllowThreads();
16355 result = (bool)(arg1)->HasPOVCTS();
16356 wxPyEndAllowThreads(__tstate);
16357 if (PyErr_Occurred()) SWIG_fail;
16358 }
16359 {
16360 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16361 }
16362 return resultobj;
16363 fail:
16364 return NULL;
16365 }
16366
16367
16368 SWIGINTERN PyObject *_wrap_Joystick_SetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16369 PyObject *resultobj = 0;
16370 wxJoystick *arg1 = (wxJoystick *) 0 ;
16371 wxWindow *arg2 = (wxWindow *) 0 ;
16372 int arg3 = (int) 0 ;
16373 bool result;
16374 void *argp1 = 0 ;
16375 int res1 = 0 ;
16376 void *argp2 = 0 ;
16377 int res2 = 0 ;
16378 int val3 ;
16379 int ecode3 = 0 ;
16380 PyObject * obj0 = 0 ;
16381 PyObject * obj1 = 0 ;
16382 PyObject * obj2 = 0 ;
16383 char * kwnames[] = {
16384 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
16385 };
16386
16387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16389 if (!SWIG_IsOK(res1)) {
16390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
16391 }
16392 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16393 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
16394 if (!SWIG_IsOK(res2)) {
16395 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Joystick_SetCapture" "', expected argument " "2"" of type '" "wxWindow *""'");
16396 }
16397 arg2 = reinterpret_cast< wxWindow * >(argp2);
16398 if (obj2) {
16399 ecode3 = SWIG_AsVal_int(obj2, &val3);
16400 if (!SWIG_IsOK(ecode3)) {
16401 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Joystick_SetCapture" "', expected argument " "3"" of type '" "int""'");
16402 }
16403 arg3 = static_cast< int >(val3);
16404 }
16405 {
16406 PyThreadState* __tstate = wxPyBeginAllowThreads();
16407 result = (bool)(arg1)->SetCapture(arg2,arg3);
16408 wxPyEndAllowThreads(__tstate);
16409 if (PyErr_Occurred()) SWIG_fail;
16410 }
16411 {
16412 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16413 }
16414 return resultobj;
16415 fail:
16416 return NULL;
16417 }
16418
16419
16420 SWIGINTERN PyObject *_wrap_Joystick_ReleaseCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16421 PyObject *resultobj = 0;
16422 wxJoystick *arg1 = (wxJoystick *) 0 ;
16423 bool result;
16424 void *argp1 = 0 ;
16425 int res1 = 0 ;
16426 PyObject *swig_obj[1] ;
16427
16428 if (!args) SWIG_fail;
16429 swig_obj[0] = args;
16430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16431 if (!SWIG_IsOK(res1)) {
16432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_ReleaseCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
16433 }
16434 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16435 {
16436 PyThreadState* __tstate = wxPyBeginAllowThreads();
16437 result = (bool)(arg1)->ReleaseCapture();
16438 wxPyEndAllowThreads(__tstate);
16439 if (PyErr_Occurred()) SWIG_fail;
16440 }
16441 {
16442 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16443 }
16444 return resultobj;
16445 fail:
16446 return NULL;
16447 }
16448
16449
16450 SWIGINTERN PyObject *Joystick_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16451 PyObject *obj;
16452 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16453 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystick, SWIG_NewClientData(obj));
16454 return SWIG_Py_Void();
16455 }
16456
16457 SWIGINTERN PyObject *Joystick_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16458 return SWIG_Python_InitShadowInstance(args);
16459 }
16460
16461 SWIGINTERN PyObject *_wrap_new_JoystickEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16462 PyObject *resultobj = 0;
16463 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16464 int arg2 = (int) 0 ;
16465 int arg3 = (int) wxJOYSTICK1 ;
16466 int arg4 = (int) 0 ;
16467 wxJoystickEvent *result = 0 ;
16468 int val1 ;
16469 int ecode1 = 0 ;
16470 int val2 ;
16471 int ecode2 = 0 ;
16472 int val3 ;
16473 int ecode3 = 0 ;
16474 int val4 ;
16475 int ecode4 = 0 ;
16476 PyObject * obj0 = 0 ;
16477 PyObject * obj1 = 0 ;
16478 PyObject * obj2 = 0 ;
16479 PyObject * obj3 = 0 ;
16480 char * kwnames[] = {
16481 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
16482 };
16483
16484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16485 if (obj0) {
16486 ecode1 = SWIG_AsVal_int(obj0, &val1);
16487 if (!SWIG_IsOK(ecode1)) {
16488 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_JoystickEvent" "', expected argument " "1"" of type '" "wxEventType""'");
16489 }
16490 arg1 = static_cast< wxEventType >(val1);
16491 }
16492 if (obj1) {
16493 ecode2 = SWIG_AsVal_int(obj1, &val2);
16494 if (!SWIG_IsOK(ecode2)) {
16495 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_JoystickEvent" "', expected argument " "2"" of type '" "int""'");
16496 }
16497 arg2 = static_cast< int >(val2);
16498 }
16499 if (obj2) {
16500 ecode3 = SWIG_AsVal_int(obj2, &val3);
16501 if (!SWIG_IsOK(ecode3)) {
16502 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_JoystickEvent" "', expected argument " "3"" of type '" "int""'");
16503 }
16504 arg3 = static_cast< int >(val3);
16505 }
16506 if (obj3) {
16507 ecode4 = SWIG_AsVal_int(obj3, &val4);
16508 if (!SWIG_IsOK(ecode4)) {
16509 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_JoystickEvent" "', expected argument " "4"" of type '" "int""'");
16510 }
16511 arg4 = static_cast< int >(val4);
16512 }
16513 {
16514 PyThreadState* __tstate = wxPyBeginAllowThreads();
16515 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
16516 wxPyEndAllowThreads(__tstate);
16517 if (PyErr_Occurred()) SWIG_fail;
16518 }
16519 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_NEW | 0 );
16520 return resultobj;
16521 fail:
16522 return NULL;
16523 }
16524
16525
16526 SWIGINTERN PyObject *_wrap_JoystickEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16527 PyObject *resultobj = 0;
16528 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16529 wxPoint result;
16530 void *argp1 = 0 ;
16531 int res1 = 0 ;
16532 PyObject *swig_obj[1] ;
16533
16534 if (!args) SWIG_fail;
16535 swig_obj[0] = args;
16536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16537 if (!SWIG_IsOK(res1)) {
16538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16539 }
16540 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16541 {
16542 PyThreadState* __tstate = wxPyBeginAllowThreads();
16543 result = ((wxJoystickEvent const *)arg1)->GetPosition();
16544 wxPyEndAllowThreads(__tstate);
16545 if (PyErr_Occurred()) SWIG_fail;
16546 }
16547 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
16548 return resultobj;
16549 fail:
16550 return NULL;
16551 }
16552
16553
16554 SWIGINTERN PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16555 PyObject *resultobj = 0;
16556 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16557 int result;
16558 void *argp1 = 0 ;
16559 int res1 = 0 ;
16560 PyObject *swig_obj[1] ;
16561
16562 if (!args) SWIG_fail;
16563 swig_obj[0] = args;
16564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16565 if (!SWIG_IsOK(res1)) {
16566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16567 }
16568 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16569 {
16570 PyThreadState* __tstate = wxPyBeginAllowThreads();
16571 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
16572 wxPyEndAllowThreads(__tstate);
16573 if (PyErr_Occurred()) SWIG_fail;
16574 }
16575 resultobj = SWIG_From_int(static_cast< int >(result));
16576 return resultobj;
16577 fail:
16578 return NULL;
16579 }
16580
16581
16582 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16583 PyObject *resultobj = 0;
16584 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16585 int result;
16586 void *argp1 = 0 ;
16587 int res1 = 0 ;
16588 PyObject *swig_obj[1] ;
16589
16590 if (!args) SWIG_fail;
16591 swig_obj[0] = args;
16592 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16593 if (!SWIG_IsOK(res1)) {
16594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16595 }
16596 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16597 {
16598 PyThreadState* __tstate = wxPyBeginAllowThreads();
16599 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
16600 wxPyEndAllowThreads(__tstate);
16601 if (PyErr_Occurred()) SWIG_fail;
16602 }
16603 resultobj = SWIG_From_int(static_cast< int >(result));
16604 return resultobj;
16605 fail:
16606 return NULL;
16607 }
16608
16609
16610 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16611 PyObject *resultobj = 0;
16612 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16613 int result;
16614 void *argp1 = 0 ;
16615 int res1 = 0 ;
16616 PyObject *swig_obj[1] ;
16617
16618 if (!args) SWIG_fail;
16619 swig_obj[0] = args;
16620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16621 if (!SWIG_IsOK(res1)) {
16622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16623 }
16624 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16625 {
16626 PyThreadState* __tstate = wxPyBeginAllowThreads();
16627 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
16628 wxPyEndAllowThreads(__tstate);
16629 if (PyErr_Occurred()) SWIG_fail;
16630 }
16631 resultobj = SWIG_From_int(static_cast< int >(result));
16632 return resultobj;
16633 fail:
16634 return NULL;
16635 }
16636
16637
16638 SWIGINTERN PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16639 PyObject *resultobj = 0;
16640 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16641 int result;
16642 void *argp1 = 0 ;
16643 int res1 = 0 ;
16644 PyObject *swig_obj[1] ;
16645
16646 if (!args) SWIG_fail;
16647 swig_obj[0] = args;
16648 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16649 if (!SWIG_IsOK(res1)) {
16650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16651 }
16652 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16653 {
16654 PyThreadState* __tstate = wxPyBeginAllowThreads();
16655 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
16656 wxPyEndAllowThreads(__tstate);
16657 if (PyErr_Occurred()) SWIG_fail;
16658 }
16659 resultobj = SWIG_From_int(static_cast< int >(result));
16660 return resultobj;
16661 fail:
16662 return NULL;
16663 }
16664
16665
16666 SWIGINTERN PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16667 PyObject *resultobj = 0;
16668 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16669 int arg2 ;
16670 void *argp1 = 0 ;
16671 int res1 = 0 ;
16672 int val2 ;
16673 int ecode2 = 0 ;
16674 PyObject * obj0 = 0 ;
16675 PyObject * obj1 = 0 ;
16676 char * kwnames[] = {
16677 (char *) "self",(char *) "stick", NULL
16678 };
16679
16680 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) SWIG_fail;
16681 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16682 if (!SWIG_IsOK(res1)) {
16683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16684 }
16685 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16686 ecode2 = SWIG_AsVal_int(obj1, &val2);
16687 if (!SWIG_IsOK(ecode2)) {
16688 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "2"" of type '" "int""'");
16689 }
16690 arg2 = static_cast< int >(val2);
16691 {
16692 PyThreadState* __tstate = wxPyBeginAllowThreads();
16693 (arg1)->SetJoystick(arg2);
16694 wxPyEndAllowThreads(__tstate);
16695 if (PyErr_Occurred()) SWIG_fail;
16696 }
16697 resultobj = SWIG_Py_Void();
16698 return resultobj;
16699 fail:
16700 return NULL;
16701 }
16702
16703
16704 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16705 PyObject *resultobj = 0;
16706 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16707 int arg2 ;
16708 void *argp1 = 0 ;
16709 int res1 = 0 ;
16710 int val2 ;
16711 int ecode2 = 0 ;
16712 PyObject * obj0 = 0 ;
16713 PyObject * obj1 = 0 ;
16714 char * kwnames[] = {
16715 (char *) "self",(char *) "state", NULL
16716 };
16717
16718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) SWIG_fail;
16719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16720 if (!SWIG_IsOK(res1)) {
16721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16722 }
16723 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16724 ecode2 = SWIG_AsVal_int(obj1, &val2);
16725 if (!SWIG_IsOK(ecode2)) {
16726 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "2"" of type '" "int""'");
16727 }
16728 arg2 = static_cast< int >(val2);
16729 {
16730 PyThreadState* __tstate = wxPyBeginAllowThreads();
16731 (arg1)->SetButtonState(arg2);
16732 wxPyEndAllowThreads(__tstate);
16733 if (PyErr_Occurred()) SWIG_fail;
16734 }
16735 resultobj = SWIG_Py_Void();
16736 return resultobj;
16737 fail:
16738 return NULL;
16739 }
16740
16741
16742 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16743 PyObject *resultobj = 0;
16744 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16745 int arg2 ;
16746 void *argp1 = 0 ;
16747 int res1 = 0 ;
16748 int val2 ;
16749 int ecode2 = 0 ;
16750 PyObject * obj0 = 0 ;
16751 PyObject * obj1 = 0 ;
16752 char * kwnames[] = {
16753 (char *) "self",(char *) "change", NULL
16754 };
16755
16756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) SWIG_fail;
16757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16758 if (!SWIG_IsOK(res1)) {
16759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16760 }
16761 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16762 ecode2 = SWIG_AsVal_int(obj1, &val2);
16763 if (!SWIG_IsOK(ecode2)) {
16764 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "2"" of type '" "int""'");
16765 }
16766 arg2 = static_cast< int >(val2);
16767 {
16768 PyThreadState* __tstate = wxPyBeginAllowThreads();
16769 (arg1)->SetButtonChange(arg2);
16770 wxPyEndAllowThreads(__tstate);
16771 if (PyErr_Occurred()) SWIG_fail;
16772 }
16773 resultobj = SWIG_Py_Void();
16774 return resultobj;
16775 fail:
16776 return NULL;
16777 }
16778
16779
16780 SWIGINTERN PyObject *_wrap_JoystickEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16781 PyObject *resultobj = 0;
16782 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16783 wxPoint *arg2 = 0 ;
16784 void *argp1 = 0 ;
16785 int res1 = 0 ;
16786 wxPoint temp2 ;
16787 PyObject * obj0 = 0 ;
16788 PyObject * obj1 = 0 ;
16789 char * kwnames[] = {
16790 (char *) "self",(char *) "pos", NULL
16791 };
16792
16793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
16794 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16795 if (!SWIG_IsOK(res1)) {
16796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16797 }
16798 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16799 {
16800 arg2 = &temp2;
16801 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
16802 }
16803 {
16804 PyThreadState* __tstate = wxPyBeginAllowThreads();
16805 (arg1)->SetPosition((wxPoint const &)*arg2);
16806 wxPyEndAllowThreads(__tstate);
16807 if (PyErr_Occurred()) SWIG_fail;
16808 }
16809 resultobj = SWIG_Py_Void();
16810 return resultobj;
16811 fail:
16812 return NULL;
16813 }
16814
16815
16816 SWIGINTERN PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16817 PyObject *resultobj = 0;
16818 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16819 int arg2 ;
16820 void *argp1 = 0 ;
16821 int res1 = 0 ;
16822 int val2 ;
16823 int ecode2 = 0 ;
16824 PyObject * obj0 = 0 ;
16825 PyObject * obj1 = 0 ;
16826 char * kwnames[] = {
16827 (char *) "self",(char *) "zPos", NULL
16828 };
16829
16830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) SWIG_fail;
16831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16832 if (!SWIG_IsOK(res1)) {
16833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16834 }
16835 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16836 ecode2 = SWIG_AsVal_int(obj1, &val2);
16837 if (!SWIG_IsOK(ecode2)) {
16838 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "2"" of type '" "int""'");
16839 }
16840 arg2 = static_cast< int >(val2);
16841 {
16842 PyThreadState* __tstate = wxPyBeginAllowThreads();
16843 (arg1)->SetZPosition(arg2);
16844 wxPyEndAllowThreads(__tstate);
16845 if (PyErr_Occurred()) SWIG_fail;
16846 }
16847 resultobj = SWIG_Py_Void();
16848 return resultobj;
16849 fail:
16850 return NULL;
16851 }
16852
16853
16854 SWIGINTERN PyObject *_wrap_JoystickEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16855 PyObject *resultobj = 0;
16856 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16857 bool result;
16858 void *argp1 = 0 ;
16859 int res1 = 0 ;
16860 PyObject *swig_obj[1] ;
16861
16862 if (!args) SWIG_fail;
16863 swig_obj[0] = args;
16864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16865 if (!SWIG_IsOK(res1)) {
16866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsButton" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16867 }
16868 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16869 {
16870 PyThreadState* __tstate = wxPyBeginAllowThreads();
16871 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
16872 wxPyEndAllowThreads(__tstate);
16873 if (PyErr_Occurred()) SWIG_fail;
16874 }
16875 {
16876 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16877 }
16878 return resultobj;
16879 fail:
16880 return NULL;
16881 }
16882
16883
16884 SWIGINTERN PyObject *_wrap_JoystickEvent_IsMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16885 PyObject *resultobj = 0;
16886 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16887 bool result;
16888 void *argp1 = 0 ;
16889 int res1 = 0 ;
16890 PyObject *swig_obj[1] ;
16891
16892 if (!args) SWIG_fail;
16893 swig_obj[0] = args;
16894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16895 if (!SWIG_IsOK(res1)) {
16896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16897 }
16898 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16899 {
16900 PyThreadState* __tstate = wxPyBeginAllowThreads();
16901 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
16902 wxPyEndAllowThreads(__tstate);
16903 if (PyErr_Occurred()) SWIG_fail;
16904 }
16905 {
16906 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16907 }
16908 return resultobj;
16909 fail:
16910 return NULL;
16911 }
16912
16913
16914 SWIGINTERN PyObject *_wrap_JoystickEvent_IsZMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16915 PyObject *resultobj = 0;
16916 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16917 bool result;
16918 void *argp1 = 0 ;
16919 int res1 = 0 ;
16920 PyObject *swig_obj[1] ;
16921
16922 if (!args) SWIG_fail;
16923 swig_obj[0] = args;
16924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16925 if (!SWIG_IsOK(res1)) {
16926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsZMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16927 }
16928 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16929 {
16930 PyThreadState* __tstate = wxPyBeginAllowThreads();
16931 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
16932 wxPyEndAllowThreads(__tstate);
16933 if (PyErr_Occurred()) SWIG_fail;
16934 }
16935 {
16936 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16937 }
16938 return resultobj;
16939 fail:
16940 return NULL;
16941 }
16942
16943
16944 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16945 PyObject *resultobj = 0;
16946 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16947 int arg2 = (int) wxJOY_BUTTON_ANY ;
16948 bool result;
16949 void *argp1 = 0 ;
16950 int res1 = 0 ;
16951 int val2 ;
16952 int ecode2 = 0 ;
16953 PyObject * obj0 = 0 ;
16954 PyObject * obj1 = 0 ;
16955 char * kwnames[] = {
16956 (char *) "self",(char *) "but", NULL
16957 };
16958
16959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
16960 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16961 if (!SWIG_IsOK(res1)) {
16962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16963 }
16964 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16965 if (obj1) {
16966 ecode2 = SWIG_AsVal_int(obj1, &val2);
16967 if (!SWIG_IsOK(ecode2)) {
16968 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
16969 }
16970 arg2 = static_cast< int >(val2);
16971 }
16972 {
16973 PyThreadState* __tstate = wxPyBeginAllowThreads();
16974 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
16975 wxPyEndAllowThreads(__tstate);
16976 if (PyErr_Occurred()) SWIG_fail;
16977 }
16978 {
16979 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16980 }
16981 return resultobj;
16982 fail:
16983 return NULL;
16984 }
16985
16986
16987 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16988 PyObject *resultobj = 0;
16989 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16990 int arg2 = (int) wxJOY_BUTTON_ANY ;
16991 bool result;
16992 void *argp1 = 0 ;
16993 int res1 = 0 ;
16994 int val2 ;
16995 int ecode2 = 0 ;
16996 PyObject * obj0 = 0 ;
16997 PyObject * obj1 = 0 ;
16998 char * kwnames[] = {
16999 (char *) "self",(char *) "but", NULL
17000 };
17001
17002 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
17003 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
17004 if (!SWIG_IsOK(res1)) {
17005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
17006 }
17007 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
17008 if (obj1) {
17009 ecode2 = SWIG_AsVal_int(obj1, &val2);
17010 if (!SWIG_IsOK(ecode2)) {
17011 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
17012 }
17013 arg2 = static_cast< int >(val2);
17014 }
17015 {
17016 PyThreadState* __tstate = wxPyBeginAllowThreads();
17017 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
17018 wxPyEndAllowThreads(__tstate);
17019 if (PyErr_Occurred()) SWIG_fail;
17020 }
17021 {
17022 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17023 }
17024 return resultobj;
17025 fail:
17026 return NULL;
17027 }
17028
17029
17030 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17031 PyObject *resultobj = 0;
17032 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
17033 int arg2 = (int) wxJOY_BUTTON_ANY ;
17034 bool result;
17035 void *argp1 = 0 ;
17036 int res1 = 0 ;
17037 int val2 ;
17038 int ecode2 = 0 ;
17039 PyObject * obj0 = 0 ;
17040 PyObject * obj1 = 0 ;
17041 char * kwnames[] = {
17042 (char *) "self",(char *) "but", NULL
17043 };
17044
17045 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
17046 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
17047 if (!SWIG_IsOK(res1)) {
17048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
17049 }
17050 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
17051 if (obj1) {
17052 ecode2 = SWIG_AsVal_int(obj1, &val2);
17053 if (!SWIG_IsOK(ecode2)) {
17054 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
17055 }
17056 arg2 = static_cast< int >(val2);
17057 }
17058 {
17059 PyThreadState* __tstate = wxPyBeginAllowThreads();
17060 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
17061 wxPyEndAllowThreads(__tstate);
17062 if (PyErr_Occurred()) SWIG_fail;
17063 }
17064 {
17065 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17066 }
17067 return resultobj;
17068 fail:
17069 return NULL;
17070 }
17071
17072
17073 SWIGINTERN PyObject *JoystickEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17074 PyObject *obj;
17075 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17076 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystickEvent, SWIG_NewClientData(obj));
17077 return SWIG_Py_Void();
17078 }
17079
17080 SWIGINTERN PyObject *JoystickEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17081 return SWIG_Python_InitShadowInstance(args);
17082 }
17083
17084 SWIGINTERN PyObject *_wrap_new_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17085 PyObject *resultobj = 0;
17086 wxString const &arg1_defvalue = wxPyEmptyString ;
17087 wxString *arg1 = (wxString *) &arg1_defvalue ;
17088 wxSound *result = 0 ;
17089 bool temp1 = false ;
17090 PyObject * obj0 = 0 ;
17091 char * kwnames[] = {
17092 (char *) "fileName", NULL
17093 };
17094
17095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) SWIG_fail;
17096 if (obj0) {
17097 {
17098 arg1 = wxString_in_helper(obj0);
17099 if (arg1 == NULL) SWIG_fail;
17100 temp1 = true;
17101 }
17102 }
17103 {
17104 if (!wxPyCheckForApp()) SWIG_fail;
17105 PyThreadState* __tstate = wxPyBeginAllowThreads();
17106 result = (wxSound *)new_wxSound((wxString const &)*arg1);
17107 wxPyEndAllowThreads(__tstate);
17108 if (PyErr_Occurred()) SWIG_fail;
17109 }
17110 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_NEW | 0 );
17111 {
17112 if (temp1)
17113 delete arg1;
17114 }
17115 return resultobj;
17116 fail:
17117 {
17118 if (temp1)
17119 delete arg1;
17120 }
17121 return NULL;
17122 }
17123
17124
17125 SWIGINTERN PyObject *_wrap_new_SoundFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17126 PyObject *resultobj = 0;
17127 PyObject *arg1 = (PyObject *) 0 ;
17128 wxSound *result = 0 ;
17129 PyObject * obj0 = 0 ;
17130 char * kwnames[] = {
17131 (char *) "data", NULL
17132 };
17133
17134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) SWIG_fail;
17135 arg1 = obj0;
17136 {
17137 if (!wxPyCheckForApp()) SWIG_fail;
17138 PyThreadState* __tstate = wxPyBeginAllowThreads();
17139 result = (wxSound *)new_wxSound(arg1);
17140 wxPyEndAllowThreads(__tstate);
17141 if (PyErr_Occurred()) SWIG_fail;
17142 }
17143 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_OWN | 0 );
17144 return resultobj;
17145 fail:
17146 return NULL;
17147 }
17148
17149
17150 SWIGINTERN PyObject *_wrap_delete_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17151 PyObject *resultobj = 0;
17152 wxSound *arg1 = (wxSound *) 0 ;
17153 void *argp1 = 0 ;
17154 int res1 = 0 ;
17155 PyObject *swig_obj[1] ;
17156
17157 if (!args) SWIG_fail;
17158 swig_obj[0] = args;
17159 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, SWIG_POINTER_DISOWN | 0 );
17160 if (!SWIG_IsOK(res1)) {
17161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sound" "', expected argument " "1"" of type '" "wxSound *""'");
17162 }
17163 arg1 = reinterpret_cast< wxSound * >(argp1);
17164 {
17165 PyThreadState* __tstate = wxPyBeginAllowThreads();
17166 delete arg1;
17167
17168 wxPyEndAllowThreads(__tstate);
17169 if (PyErr_Occurred()) SWIG_fail;
17170 }
17171 resultobj = SWIG_Py_Void();
17172 return resultobj;
17173 fail:
17174 return NULL;
17175 }
17176
17177
17178 SWIGINTERN PyObject *_wrap_Sound_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17179 PyObject *resultobj = 0;
17180 wxSound *arg1 = (wxSound *) 0 ;
17181 wxString *arg2 = 0 ;
17182 bool result;
17183 void *argp1 = 0 ;
17184 int res1 = 0 ;
17185 bool temp2 = false ;
17186 PyObject * obj0 = 0 ;
17187 PyObject * obj1 = 0 ;
17188 char * kwnames[] = {
17189 (char *) "self",(char *) "fileName", NULL
17190 };
17191
17192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) SWIG_fail;
17193 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17194 if (!SWIG_IsOK(res1)) {
17195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Create" "', expected argument " "1"" of type '" "wxSound *""'");
17196 }
17197 arg1 = reinterpret_cast< wxSound * >(argp1);
17198 {
17199 arg2 = wxString_in_helper(obj1);
17200 if (arg2 == NULL) SWIG_fail;
17201 temp2 = true;
17202 }
17203 {
17204 PyThreadState* __tstate = wxPyBeginAllowThreads();
17205 result = (bool)(arg1)->Create((wxString const &)*arg2);
17206 wxPyEndAllowThreads(__tstate);
17207 if (PyErr_Occurred()) SWIG_fail;
17208 }
17209 {
17210 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17211 }
17212 {
17213 if (temp2)
17214 delete arg2;
17215 }
17216 return resultobj;
17217 fail:
17218 {
17219 if (temp2)
17220 delete arg2;
17221 }
17222 return NULL;
17223 }
17224
17225
17226 SWIGINTERN PyObject *_wrap_Sound_CreateFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17227 PyObject *resultobj = 0;
17228 wxSound *arg1 = (wxSound *) 0 ;
17229 PyObject *arg2 = (PyObject *) 0 ;
17230 bool result;
17231 void *argp1 = 0 ;
17232 int res1 = 0 ;
17233 PyObject * obj0 = 0 ;
17234 PyObject * obj1 = 0 ;
17235 char * kwnames[] = {
17236 (char *) "self",(char *) "data", NULL
17237 };
17238
17239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) SWIG_fail;
17240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17241 if (!SWIG_IsOK(res1)) {
17242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_CreateFromData" "', expected argument " "1"" of type '" "wxSound *""'");
17243 }
17244 arg1 = reinterpret_cast< wxSound * >(argp1);
17245 arg2 = obj1;
17246 {
17247 PyThreadState* __tstate = wxPyBeginAllowThreads();
17248 result = (bool)wxSound_CreateFromData(arg1,arg2);
17249 wxPyEndAllowThreads(__tstate);
17250 if (PyErr_Occurred()) SWIG_fail;
17251 }
17252 {
17253 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17254 }
17255 return resultobj;
17256 fail:
17257 return NULL;
17258 }
17259
17260
17261 SWIGINTERN PyObject *_wrap_Sound_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17262 PyObject *resultobj = 0;
17263 wxSound *arg1 = (wxSound *) 0 ;
17264 bool result;
17265 void *argp1 = 0 ;
17266 int res1 = 0 ;
17267 PyObject *swig_obj[1] ;
17268
17269 if (!args) SWIG_fail;
17270 swig_obj[0] = args;
17271 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17272 if (!SWIG_IsOK(res1)) {
17273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_IsOk" "', expected argument " "1"" of type '" "wxSound *""'");
17274 }
17275 arg1 = reinterpret_cast< wxSound * >(argp1);
17276 {
17277 PyThreadState* __tstate = wxPyBeginAllowThreads();
17278 result = (bool)(arg1)->IsOk();
17279 wxPyEndAllowThreads(__tstate);
17280 if (PyErr_Occurred()) SWIG_fail;
17281 }
17282 {
17283 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17284 }
17285 return resultobj;
17286 fail:
17287 return NULL;
17288 }
17289
17290
17291 SWIGINTERN PyObject *_wrap_Sound_Play(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17292 PyObject *resultobj = 0;
17293 wxSound *arg1 = (wxSound *) 0 ;
17294 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
17295 bool result;
17296 void *argp1 = 0 ;
17297 int res1 = 0 ;
17298 unsigned int val2 ;
17299 int ecode2 = 0 ;
17300 PyObject * obj0 = 0 ;
17301 PyObject * obj1 = 0 ;
17302 char * kwnames[] = {
17303 (char *) "self",(char *) "flags", NULL
17304 };
17305
17306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) SWIG_fail;
17307 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17308 if (!SWIG_IsOK(res1)) {
17309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Play" "', expected argument " "1"" of type '" "wxSound const *""'");
17310 }
17311 arg1 = reinterpret_cast< wxSound * >(argp1);
17312 if (obj1) {
17313 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
17314 if (!SWIG_IsOK(ecode2)) {
17315 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_Play" "', expected argument " "2"" of type '" "unsigned int""'");
17316 }
17317 arg2 = static_cast< unsigned int >(val2);
17318 }
17319 {
17320 if (!wxPyCheckForApp()) SWIG_fail;
17321 PyThreadState* __tstate = wxPyBeginAllowThreads();
17322 result = (bool)((wxSound const *)arg1)->Play(arg2);
17323 wxPyEndAllowThreads(__tstate);
17324 if (PyErr_Occurred()) SWIG_fail;
17325 }
17326 {
17327 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17328 }
17329 return resultobj;
17330 fail:
17331 return NULL;
17332 }
17333
17334
17335 SWIGINTERN PyObject *_wrap_Sound_PlaySound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17336 PyObject *resultobj = 0;
17337 wxString *arg1 = 0 ;
17338 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
17339 bool result;
17340 bool temp1 = false ;
17341 unsigned int val2 ;
17342 int ecode2 = 0 ;
17343 PyObject * obj0 = 0 ;
17344 PyObject * obj1 = 0 ;
17345 char * kwnames[] = {
17346 (char *) "filename",(char *) "flags", NULL
17347 };
17348
17349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) SWIG_fail;
17350 {
17351 arg1 = wxString_in_helper(obj0);
17352 if (arg1 == NULL) SWIG_fail;
17353 temp1 = true;
17354 }
17355 if (obj1) {
17356 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
17357 if (!SWIG_IsOK(ecode2)) {
17358 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_PlaySound" "', expected argument " "2"" of type '" "unsigned int""'");
17359 }
17360 arg2 = static_cast< unsigned int >(val2);
17361 }
17362 {
17363 if (!wxPyCheckForApp()) SWIG_fail;
17364 PyThreadState* __tstate = wxPyBeginAllowThreads();
17365 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
17366 wxPyEndAllowThreads(__tstate);
17367 if (PyErr_Occurred()) SWIG_fail;
17368 }
17369 {
17370 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17371 }
17372 {
17373 if (temp1)
17374 delete arg1;
17375 }
17376 return resultobj;
17377 fail:
17378 {
17379 if (temp1)
17380 delete arg1;
17381 }
17382 return NULL;
17383 }
17384
17385
17386 SWIGINTERN PyObject *_wrap_Sound_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17387 PyObject *resultobj = 0;
17388
17389 if (!SWIG_Python_UnpackTuple(args,"Sound_Stop",0,0,0)) SWIG_fail;
17390 {
17391 if (!wxPyCheckForApp()) SWIG_fail;
17392 PyThreadState* __tstate = wxPyBeginAllowThreads();
17393 wxSound::Stop();
17394 wxPyEndAllowThreads(__tstate);
17395 if (PyErr_Occurred()) SWIG_fail;
17396 }
17397 resultobj = SWIG_Py_Void();
17398 return resultobj;
17399 fail:
17400 return NULL;
17401 }
17402
17403
17404 SWIGINTERN PyObject *Sound_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17405 PyObject *obj;
17406 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17407 SWIG_TypeNewClientData(SWIGTYPE_p_wxSound, SWIG_NewClientData(obj));
17408 return SWIG_Py_Void();
17409 }
17410
17411 SWIGINTERN PyObject *Sound_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17412 return SWIG_Python_InitShadowInstance(args);
17413 }
17414
17415 SWIGINTERN PyObject *_wrap_new_FileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17416 PyObject *resultobj = 0;
17417 wxString *arg1 = 0 ;
17418 wxString *arg2 = 0 ;
17419 wxString *arg3 = 0 ;
17420 wxString *arg4 = 0 ;
17421 wxFileTypeInfo *result = 0 ;
17422 bool temp1 = false ;
17423 bool temp2 = false ;
17424 bool temp3 = false ;
17425 bool temp4 = false ;
17426 PyObject * obj0 = 0 ;
17427 PyObject * obj1 = 0 ;
17428 PyObject * obj2 = 0 ;
17429 PyObject * obj3 = 0 ;
17430 char * kwnames[] = {
17431 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
17432 };
17433
17434 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17435 {
17436 arg1 = wxString_in_helper(obj0);
17437 if (arg1 == NULL) SWIG_fail;
17438 temp1 = true;
17439 }
17440 {
17441 arg2 = wxString_in_helper(obj1);
17442 if (arg2 == NULL) SWIG_fail;
17443 temp2 = true;
17444 }
17445 {
17446 arg3 = wxString_in_helper(obj2);
17447 if (arg3 == NULL) SWIG_fail;
17448 temp3 = true;
17449 }
17450 {
17451 arg4 = wxString_in_helper(obj3);
17452 if (arg4 == NULL) SWIG_fail;
17453 temp4 = true;
17454 }
17455 {
17456 PyThreadState* __tstate = wxPyBeginAllowThreads();
17457 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
17458 wxPyEndAllowThreads(__tstate);
17459 if (PyErr_Occurred()) SWIG_fail;
17460 }
17461 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_NEW | 0 );
17462 {
17463 if (temp1)
17464 delete arg1;
17465 }
17466 {
17467 if (temp2)
17468 delete arg2;
17469 }
17470 {
17471 if (temp3)
17472 delete arg3;
17473 }
17474 {
17475 if (temp4)
17476 delete arg4;
17477 }
17478 return resultobj;
17479 fail:
17480 {
17481 if (temp1)
17482 delete arg1;
17483 }
17484 {
17485 if (temp2)
17486 delete arg2;
17487 }
17488 {
17489 if (temp3)
17490 delete arg3;
17491 }
17492 {
17493 if (temp4)
17494 delete arg4;
17495 }
17496 return NULL;
17497 }
17498
17499
17500 SWIGINTERN PyObject *_wrap_new_FileTypeInfoSequence(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17501 PyObject *resultobj = 0;
17502 wxArrayString *arg1 = 0 ;
17503 wxFileTypeInfo *result = 0 ;
17504 bool temp1 = false ;
17505 PyObject * obj0 = 0 ;
17506 char * kwnames[] = {
17507 (char *) "sArray", NULL
17508 };
17509
17510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) SWIG_fail;
17511 {
17512 if (! PySequence_Check(obj0)) {
17513 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
17514 SWIG_fail;
17515 }
17516 arg1 = new wxArrayString;
17517 temp1 = true;
17518 int i, len=PySequence_Length(obj0);
17519 for (i=0; i<len; i++) {
17520 PyObject* item = PySequence_GetItem(obj0, i);
17521 wxString* s = wxString_in_helper(item);
17522 if (PyErr_Occurred()) SWIG_fail;
17523 arg1->Add(*s);
17524 delete s;
17525 Py_DECREF(item);
17526 }
17527 }
17528 {
17529 PyThreadState* __tstate = wxPyBeginAllowThreads();
17530 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
17531 wxPyEndAllowThreads(__tstate);
17532 if (PyErr_Occurred()) SWIG_fail;
17533 }
17534 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
17535 {
17536 if (temp1) delete arg1;
17537 }
17538 return resultobj;
17539 fail:
17540 {
17541 if (temp1) delete arg1;
17542 }
17543 return NULL;
17544 }
17545
17546
17547 SWIGINTERN PyObject *_wrap_new_NullFileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17548 PyObject *resultobj = 0;
17549 wxFileTypeInfo *result = 0 ;
17550
17551 if (!SWIG_Python_UnpackTuple(args,"new_NullFileTypeInfo",0,0,0)) SWIG_fail;
17552 {
17553 PyThreadState* __tstate = wxPyBeginAllowThreads();
17554 result = (wxFileTypeInfo *)new wxFileTypeInfo();
17555 wxPyEndAllowThreads(__tstate);
17556 if (PyErr_Occurred()) SWIG_fail;
17557 }
17558 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
17559 return resultobj;
17560 fail:
17561 return NULL;
17562 }
17563
17564
17565 SWIGINTERN PyObject *_wrap_FileTypeInfo_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17566 PyObject *resultobj = 0;
17567 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17568 bool result;
17569 void *argp1 = 0 ;
17570 int res1 = 0 ;
17571 PyObject *swig_obj[1] ;
17572
17573 if (!args) SWIG_fail;
17574 swig_obj[0] = args;
17575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17576 if (!SWIG_IsOK(res1)) {
17577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_IsValid" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17578 }
17579 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17580 {
17581 PyThreadState* __tstate = wxPyBeginAllowThreads();
17582 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
17583 wxPyEndAllowThreads(__tstate);
17584 if (PyErr_Occurred()) SWIG_fail;
17585 }
17586 {
17587 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17588 }
17589 return resultobj;
17590 fail:
17591 return NULL;
17592 }
17593
17594
17595 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17596 PyObject *resultobj = 0;
17597 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17598 wxString *arg2 = 0 ;
17599 int arg3 = (int) 0 ;
17600 void *argp1 = 0 ;
17601 int res1 = 0 ;
17602 bool temp2 = false ;
17603 int val3 ;
17604 int ecode3 = 0 ;
17605 PyObject * obj0 = 0 ;
17606 PyObject * obj1 = 0 ;
17607 PyObject * obj2 = 0 ;
17608 char * kwnames[] = {
17609 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
17610 };
17611
17612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17614 if (!SWIG_IsOK(res1)) {
17615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
17616 }
17617 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17618 {
17619 arg2 = wxString_in_helper(obj1);
17620 if (arg2 == NULL) SWIG_fail;
17621 temp2 = true;
17622 }
17623 if (obj2) {
17624 ecode3 = SWIG_AsVal_int(obj2, &val3);
17625 if (!SWIG_IsOK(ecode3)) {
17626 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "3"" of type '" "int""'");
17627 }
17628 arg3 = static_cast< int >(val3);
17629 }
17630 {
17631 PyThreadState* __tstate = wxPyBeginAllowThreads();
17632 (arg1)->SetIcon((wxString const &)*arg2,arg3);
17633 wxPyEndAllowThreads(__tstate);
17634 if (PyErr_Occurred()) SWIG_fail;
17635 }
17636 resultobj = SWIG_Py_Void();
17637 {
17638 if (temp2)
17639 delete arg2;
17640 }
17641 return resultobj;
17642 fail:
17643 {
17644 if (temp2)
17645 delete arg2;
17646 }
17647 return NULL;
17648 }
17649
17650
17651 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17652 PyObject *resultobj = 0;
17653 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17654 wxString *arg2 = 0 ;
17655 void *argp1 = 0 ;
17656 int res1 = 0 ;
17657 bool temp2 = false ;
17658 PyObject * obj0 = 0 ;
17659 PyObject * obj1 = 0 ;
17660 char * kwnames[] = {
17661 (char *) "self",(char *) "shortDesc", NULL
17662 };
17663
17664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) SWIG_fail;
17665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17666 if (!SWIG_IsOK(res1)) {
17667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
17668 }
17669 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17670 {
17671 arg2 = wxString_in_helper(obj1);
17672 if (arg2 == NULL) SWIG_fail;
17673 temp2 = true;
17674 }
17675 {
17676 PyThreadState* __tstate = wxPyBeginAllowThreads();
17677 (arg1)->SetShortDesc((wxString const &)*arg2);
17678 wxPyEndAllowThreads(__tstate);
17679 if (PyErr_Occurred()) SWIG_fail;
17680 }
17681 resultobj = SWIG_Py_Void();
17682 {
17683 if (temp2)
17684 delete arg2;
17685 }
17686 return resultobj;
17687 fail:
17688 {
17689 if (temp2)
17690 delete arg2;
17691 }
17692 return NULL;
17693 }
17694
17695
17696 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17697 PyObject *resultobj = 0;
17698 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17699 wxString *result = 0 ;
17700 void *argp1 = 0 ;
17701 int res1 = 0 ;
17702 PyObject *swig_obj[1] ;
17703
17704 if (!args) SWIG_fail;
17705 swig_obj[0] = args;
17706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17707 if (!SWIG_IsOK(res1)) {
17708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetMimeType" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17709 }
17710 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17711 {
17712 PyThreadState* __tstate = wxPyBeginAllowThreads();
17713 {
17714 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
17715 result = (wxString *) &_result_ref;
17716 }
17717 wxPyEndAllowThreads(__tstate);
17718 if (PyErr_Occurred()) SWIG_fail;
17719 }
17720 {
17721 #if wxUSE_UNICODE
17722 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17723 #else
17724 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17725 #endif
17726 }
17727 return resultobj;
17728 fail:
17729 return NULL;
17730 }
17731
17732
17733 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17734 PyObject *resultobj = 0;
17735 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17736 wxString *result = 0 ;
17737 void *argp1 = 0 ;
17738 int res1 = 0 ;
17739 PyObject *swig_obj[1] ;
17740
17741 if (!args) SWIG_fail;
17742 swig_obj[0] = args;
17743 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17744 if (!SWIG_IsOK(res1)) {
17745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17746 }
17747 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17748 {
17749 PyThreadState* __tstate = wxPyBeginAllowThreads();
17750 {
17751 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
17752 result = (wxString *) &_result_ref;
17753 }
17754 wxPyEndAllowThreads(__tstate);
17755 if (PyErr_Occurred()) SWIG_fail;
17756 }
17757 {
17758 #if wxUSE_UNICODE
17759 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17760 #else
17761 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17762 #endif
17763 }
17764 return resultobj;
17765 fail:
17766 return NULL;
17767 }
17768
17769
17770 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17771 PyObject *resultobj = 0;
17772 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17773 wxString *result = 0 ;
17774 void *argp1 = 0 ;
17775 int res1 = 0 ;
17776 PyObject *swig_obj[1] ;
17777
17778 if (!args) SWIG_fail;
17779 swig_obj[0] = args;
17780 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17781 if (!SWIG_IsOK(res1)) {
17782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17783 }
17784 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17785 {
17786 PyThreadState* __tstate = wxPyBeginAllowThreads();
17787 {
17788 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
17789 result = (wxString *) &_result_ref;
17790 }
17791 wxPyEndAllowThreads(__tstate);
17792 if (PyErr_Occurred()) SWIG_fail;
17793 }
17794 {
17795 #if wxUSE_UNICODE
17796 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17797 #else
17798 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17799 #endif
17800 }
17801 return resultobj;
17802 fail:
17803 return NULL;
17804 }
17805
17806
17807 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17808 PyObject *resultobj = 0;
17809 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17810 wxString *result = 0 ;
17811 void *argp1 = 0 ;
17812 int res1 = 0 ;
17813 PyObject *swig_obj[1] ;
17814
17815 if (!args) SWIG_fail;
17816 swig_obj[0] = args;
17817 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17818 if (!SWIG_IsOK(res1)) {
17819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17820 }
17821 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17822 {
17823 PyThreadState* __tstate = wxPyBeginAllowThreads();
17824 {
17825 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
17826 result = (wxString *) &_result_ref;
17827 }
17828 wxPyEndAllowThreads(__tstate);
17829 if (PyErr_Occurred()) SWIG_fail;
17830 }
17831 {
17832 #if wxUSE_UNICODE
17833 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17834 #else
17835 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17836 #endif
17837 }
17838 return resultobj;
17839 fail:
17840 return NULL;
17841 }
17842
17843
17844 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17845 PyObject *resultobj = 0;
17846 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17847 wxString *result = 0 ;
17848 void *argp1 = 0 ;
17849 int res1 = 0 ;
17850 PyObject *swig_obj[1] ;
17851
17852 if (!args) SWIG_fail;
17853 swig_obj[0] = args;
17854 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17855 if (!SWIG_IsOK(res1)) {
17856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetDescription" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17857 }
17858 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17859 {
17860 PyThreadState* __tstate = wxPyBeginAllowThreads();
17861 {
17862 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
17863 result = (wxString *) &_result_ref;
17864 }
17865 wxPyEndAllowThreads(__tstate);
17866 if (PyErr_Occurred()) SWIG_fail;
17867 }
17868 {
17869 #if wxUSE_UNICODE
17870 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17871 #else
17872 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17873 #endif
17874 }
17875 return resultobj;
17876 fail:
17877 return NULL;
17878 }
17879
17880
17881 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17882 PyObject *resultobj = 0;
17883 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17884 wxArrayString *result = 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_wxFileTypeInfo, 0 | 0 );
17892 if (!SWIG_IsOK(res1)) {
17893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensions" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17894 }
17895 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17896 {
17897 PyThreadState* __tstate = wxPyBeginAllowThreads();
17898 {
17899 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
17900 result = (wxArrayString *) &_result_ref;
17901 }
17902 wxPyEndAllowThreads(__tstate);
17903 if (PyErr_Occurred()) SWIG_fail;
17904 }
17905 {
17906 resultobj = wxArrayString2PyList_helper(*result);
17907 }
17908 return resultobj;
17909 fail:
17910 return NULL;
17911 }
17912
17913
17914 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17915 PyObject *resultobj = 0;
17916 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17917 size_t result;
17918 void *argp1 = 0 ;
17919 int res1 = 0 ;
17920 PyObject *swig_obj[1] ;
17921
17922 if (!args) SWIG_fail;
17923 swig_obj[0] = args;
17924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17925 if (!SWIG_IsOK(res1)) {
17926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensionsCount" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17927 }
17928 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17929 {
17930 PyThreadState* __tstate = wxPyBeginAllowThreads();
17931 result = (size_t)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
17932 wxPyEndAllowThreads(__tstate);
17933 if (PyErr_Occurred()) SWIG_fail;
17934 }
17935 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
17936 return resultobj;
17937 fail:
17938 return NULL;
17939 }
17940
17941
17942 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17943 PyObject *resultobj = 0;
17944 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17945 wxString *result = 0 ;
17946 void *argp1 = 0 ;
17947 int res1 = 0 ;
17948 PyObject *swig_obj[1] ;
17949
17950 if (!args) SWIG_fail;
17951 swig_obj[0] = args;
17952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17953 if (!SWIG_IsOK(res1)) {
17954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconFile" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17955 }
17956 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17957 {
17958 PyThreadState* __tstate = wxPyBeginAllowThreads();
17959 {
17960 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
17961 result = (wxString *) &_result_ref;
17962 }
17963 wxPyEndAllowThreads(__tstate);
17964 if (PyErr_Occurred()) SWIG_fail;
17965 }
17966 {
17967 #if wxUSE_UNICODE
17968 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17969 #else
17970 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17971 #endif
17972 }
17973 return resultobj;
17974 fail:
17975 return NULL;
17976 }
17977
17978
17979 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17980 PyObject *resultobj = 0;
17981 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17982 int result;
17983 void *argp1 = 0 ;
17984 int res1 = 0 ;
17985 PyObject *swig_obj[1] ;
17986
17987 if (!args) SWIG_fail;
17988 swig_obj[0] = args;
17989 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17990 if (!SWIG_IsOK(res1)) {
17991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconIndex" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17992 }
17993 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17994 {
17995 PyThreadState* __tstate = wxPyBeginAllowThreads();
17996 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
17997 wxPyEndAllowThreads(__tstate);
17998 if (PyErr_Occurred()) SWIG_fail;
17999 }
18000 resultobj = SWIG_From_int(static_cast< int >(result));
18001 return resultobj;
18002 fail:
18003 return NULL;
18004 }
18005
18006
18007 SWIGINTERN PyObject *FileTypeInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18008 PyObject *obj;
18009 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18010 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileTypeInfo, SWIG_NewClientData(obj));
18011 return SWIG_Py_Void();
18012 }
18013
18014 SWIGINTERN PyObject *FileTypeInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18015 return SWIG_Python_InitShadowInstance(args);
18016 }
18017
18018 SWIGINTERN PyObject *_wrap_new_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18019 PyObject *resultobj = 0;
18020 wxFileTypeInfo *arg1 = 0 ;
18021 wxFileType *result = 0 ;
18022 void *argp1 = 0 ;
18023 int res1 = 0 ;
18024 PyObject * obj0 = 0 ;
18025 char * kwnames[] = {
18026 (char *) "ftInfo", NULL
18027 };
18028
18029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) SWIG_fail;
18030 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
18031 if (!SWIG_IsOK(res1)) {
18032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
18033 }
18034 if (!argp1) {
18035 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
18036 }
18037 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
18038 {
18039 PyThreadState* __tstate = wxPyBeginAllowThreads();
18040 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
18041 wxPyEndAllowThreads(__tstate);
18042 if (PyErr_Occurred()) SWIG_fail;
18043 }
18044 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_NEW | 0 );
18045 return resultobj;
18046 fail:
18047 return NULL;
18048 }
18049
18050
18051 SWIGINTERN PyObject *_wrap_delete_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18052 PyObject *resultobj = 0;
18053 wxFileType *arg1 = (wxFileType *) 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, SWIG_POINTER_DISOWN | 0 );
18061 if (!SWIG_IsOK(res1)) {
18062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileType" "', expected argument " "1"" of type '" "wxFileType *""'");
18063 }
18064 arg1 = reinterpret_cast< wxFileType * >(argp1);
18065 {
18066 PyThreadState* __tstate = wxPyBeginAllowThreads();
18067 delete arg1;
18068
18069 wxPyEndAllowThreads(__tstate);
18070 if (PyErr_Occurred()) SWIG_fail;
18071 }
18072 resultobj = SWIG_Py_Void();
18073 return resultobj;
18074 fail:
18075 return NULL;
18076 }
18077
18078
18079 SWIGINTERN PyObject *_wrap_FileType_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18080 PyObject *resultobj = 0;
18081 wxFileType *arg1 = (wxFileType *) 0 ;
18082 PyObject *result = 0 ;
18083 void *argp1 = 0 ;
18084 int res1 = 0 ;
18085 PyObject *swig_obj[1] ;
18086
18087 if (!args) SWIG_fail;
18088 swig_obj[0] = args;
18089 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18090 if (!SWIG_IsOK(res1)) {
18091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeType" "', expected argument " "1"" of type '" "wxFileType *""'");
18092 }
18093 arg1 = reinterpret_cast< wxFileType * >(argp1);
18094 {
18095 PyThreadState* __tstate = wxPyBeginAllowThreads();
18096 result = (PyObject *)wxFileType_GetMimeType(arg1);
18097 wxPyEndAllowThreads(__tstate);
18098 if (PyErr_Occurred()) SWIG_fail;
18099 }
18100 resultobj = result;
18101 return resultobj;
18102 fail:
18103 return NULL;
18104 }
18105
18106
18107 SWIGINTERN PyObject *_wrap_FileType_GetMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18108 PyObject *resultobj = 0;
18109 wxFileType *arg1 = (wxFileType *) 0 ;
18110 PyObject *result = 0 ;
18111 void *argp1 = 0 ;
18112 int res1 = 0 ;
18113 PyObject *swig_obj[1] ;
18114
18115 if (!args) SWIG_fail;
18116 swig_obj[0] = args;
18117 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18118 if (!SWIG_IsOK(res1)) {
18119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeTypes" "', expected argument " "1"" of type '" "wxFileType *""'");
18120 }
18121 arg1 = reinterpret_cast< wxFileType * >(argp1);
18122 {
18123 PyThreadState* __tstate = wxPyBeginAllowThreads();
18124 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
18125 wxPyEndAllowThreads(__tstate);
18126 if (PyErr_Occurred()) SWIG_fail;
18127 }
18128 resultobj = result;
18129 return resultobj;
18130 fail:
18131 return NULL;
18132 }
18133
18134
18135 SWIGINTERN PyObject *_wrap_FileType_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18136 PyObject *resultobj = 0;
18137 wxFileType *arg1 = (wxFileType *) 0 ;
18138 PyObject *result = 0 ;
18139 void *argp1 = 0 ;
18140 int res1 = 0 ;
18141 PyObject *swig_obj[1] ;
18142
18143 if (!args) SWIG_fail;
18144 swig_obj[0] = args;
18145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18146 if (!SWIG_IsOK(res1)) {
18147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetExtensions" "', expected argument " "1"" of type '" "wxFileType *""'");
18148 }
18149 arg1 = reinterpret_cast< wxFileType * >(argp1);
18150 {
18151 PyThreadState* __tstate = wxPyBeginAllowThreads();
18152 result = (PyObject *)wxFileType_GetExtensions(arg1);
18153 wxPyEndAllowThreads(__tstate);
18154 if (PyErr_Occurred()) SWIG_fail;
18155 }
18156 resultobj = result;
18157 return resultobj;
18158 fail:
18159 return NULL;
18160 }
18161
18162
18163 SWIGINTERN PyObject *_wrap_FileType_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18164 PyObject *resultobj = 0;
18165 wxFileType *arg1 = (wxFileType *) 0 ;
18166 wxIcon *result = 0 ;
18167 void *argp1 = 0 ;
18168 int res1 = 0 ;
18169 PyObject *swig_obj[1] ;
18170
18171 if (!args) SWIG_fail;
18172 swig_obj[0] = args;
18173 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18174 if (!SWIG_IsOK(res1)) {
18175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
18176 }
18177 arg1 = reinterpret_cast< wxFileType * >(argp1);
18178 {
18179 PyThreadState* __tstate = wxPyBeginAllowThreads();
18180 result = (wxIcon *)wxFileType_GetIcon(arg1);
18181 wxPyEndAllowThreads(__tstate);
18182 if (PyErr_Occurred()) SWIG_fail;
18183 }
18184 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
18185 return resultobj;
18186 fail:
18187 return NULL;
18188 }
18189
18190
18191 SWIGINTERN PyObject *_wrap_FileType_GetIconInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18192 PyObject *resultobj = 0;
18193 wxFileType *arg1 = (wxFileType *) 0 ;
18194 PyObject *result = 0 ;
18195 void *argp1 = 0 ;
18196 int res1 = 0 ;
18197 PyObject *swig_obj[1] ;
18198
18199 if (!args) SWIG_fail;
18200 swig_obj[0] = args;
18201 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18202 if (!SWIG_IsOK(res1)) {
18203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIconInfo" "', expected argument " "1"" of type '" "wxFileType *""'");
18204 }
18205 arg1 = reinterpret_cast< wxFileType * >(argp1);
18206 {
18207 PyThreadState* __tstate = wxPyBeginAllowThreads();
18208 result = (PyObject *)wxFileType_GetIconInfo(arg1);
18209 wxPyEndAllowThreads(__tstate);
18210 if (PyErr_Occurred()) SWIG_fail;
18211 }
18212 resultobj = result;
18213 return resultobj;
18214 fail:
18215 return NULL;
18216 }
18217
18218
18219 SWIGINTERN PyObject *_wrap_FileType_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18220 PyObject *resultobj = 0;
18221 wxFileType *arg1 = (wxFileType *) 0 ;
18222 PyObject *result = 0 ;
18223 void *argp1 = 0 ;
18224 int res1 = 0 ;
18225 PyObject *swig_obj[1] ;
18226
18227 if (!args) SWIG_fail;
18228 swig_obj[0] = args;
18229 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18230 if (!SWIG_IsOK(res1)) {
18231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetDescription" "', expected argument " "1"" of type '" "wxFileType *""'");
18232 }
18233 arg1 = reinterpret_cast< wxFileType * >(argp1);
18234 {
18235 PyThreadState* __tstate = wxPyBeginAllowThreads();
18236 result = (PyObject *)wxFileType_GetDescription(arg1);
18237 wxPyEndAllowThreads(__tstate);
18238 if (PyErr_Occurred()) SWIG_fail;
18239 }
18240 resultobj = result;
18241 return resultobj;
18242 fail:
18243 return NULL;
18244 }
18245
18246
18247 SWIGINTERN PyObject *_wrap_FileType_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18248 PyObject *resultobj = 0;
18249 wxFileType *arg1 = (wxFileType *) 0 ;
18250 wxString *arg2 = 0 ;
18251 wxString const &arg3_defvalue = wxPyEmptyString ;
18252 wxString *arg3 = (wxString *) &arg3_defvalue ;
18253 PyObject *result = 0 ;
18254 void *argp1 = 0 ;
18255 int res1 = 0 ;
18256 bool temp2 = false ;
18257 bool temp3 = false ;
18258 PyObject * obj0 = 0 ;
18259 PyObject * obj1 = 0 ;
18260 PyObject * obj2 = 0 ;
18261 char * kwnames[] = {
18262 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18263 };
18264
18265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18266 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18267 if (!SWIG_IsOK(res1)) {
18268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18269 }
18270 arg1 = reinterpret_cast< wxFileType * >(argp1);
18271 {
18272 arg2 = wxString_in_helper(obj1);
18273 if (arg2 == NULL) SWIG_fail;
18274 temp2 = true;
18275 }
18276 if (obj2) {
18277 {
18278 arg3 = wxString_in_helper(obj2);
18279 if (arg3 == NULL) SWIG_fail;
18280 temp3 = true;
18281 }
18282 }
18283 {
18284 PyThreadState* __tstate = wxPyBeginAllowThreads();
18285 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18286 wxPyEndAllowThreads(__tstate);
18287 if (PyErr_Occurred()) SWIG_fail;
18288 }
18289 resultobj = result;
18290 {
18291 if (temp2)
18292 delete arg2;
18293 }
18294 {
18295 if (temp3)
18296 delete arg3;
18297 }
18298 return resultobj;
18299 fail:
18300 {
18301 if (temp2)
18302 delete arg2;
18303 }
18304 {
18305 if (temp3)
18306 delete arg3;
18307 }
18308 return NULL;
18309 }
18310
18311
18312 SWIGINTERN PyObject *_wrap_FileType_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18313 PyObject *resultobj = 0;
18314 wxFileType *arg1 = (wxFileType *) 0 ;
18315 wxString *arg2 = 0 ;
18316 wxString const &arg3_defvalue = wxPyEmptyString ;
18317 wxString *arg3 = (wxString *) &arg3_defvalue ;
18318 PyObject *result = 0 ;
18319 void *argp1 = 0 ;
18320 int res1 = 0 ;
18321 bool temp2 = false ;
18322 bool temp3 = false ;
18323 PyObject * obj0 = 0 ;
18324 PyObject * obj1 = 0 ;
18325 PyObject * obj2 = 0 ;
18326 char * kwnames[] = {
18327 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18328 };
18329
18330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18331 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18332 if (!SWIG_IsOK(res1)) {
18333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18334 }
18335 arg1 = reinterpret_cast< wxFileType * >(argp1);
18336 {
18337 arg2 = wxString_in_helper(obj1);
18338 if (arg2 == NULL) SWIG_fail;
18339 temp2 = true;
18340 }
18341 if (obj2) {
18342 {
18343 arg3 = wxString_in_helper(obj2);
18344 if (arg3 == NULL) SWIG_fail;
18345 temp3 = true;
18346 }
18347 }
18348 {
18349 PyThreadState* __tstate = wxPyBeginAllowThreads();
18350 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18351 wxPyEndAllowThreads(__tstate);
18352 if (PyErr_Occurred()) SWIG_fail;
18353 }
18354 resultobj = result;
18355 {
18356 if (temp2)
18357 delete arg2;
18358 }
18359 {
18360 if (temp3)
18361 delete arg3;
18362 }
18363 return resultobj;
18364 fail:
18365 {
18366 if (temp2)
18367 delete arg2;
18368 }
18369 {
18370 if (temp3)
18371 delete arg3;
18372 }
18373 return NULL;
18374 }
18375
18376
18377 SWIGINTERN PyObject *_wrap_FileType_GetAllCommands(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18378 PyObject *resultobj = 0;
18379 wxFileType *arg1 = (wxFileType *) 0 ;
18380 wxString *arg2 = 0 ;
18381 wxString const &arg3_defvalue = wxPyEmptyString ;
18382 wxString *arg3 = (wxString *) &arg3_defvalue ;
18383 PyObject *result = 0 ;
18384 void *argp1 = 0 ;
18385 int res1 = 0 ;
18386 bool temp2 = false ;
18387 bool temp3 = false ;
18388 PyObject * obj0 = 0 ;
18389 PyObject * obj1 = 0 ;
18390 PyObject * obj2 = 0 ;
18391 char * kwnames[] = {
18392 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18393 };
18394
18395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18396 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18397 if (!SWIG_IsOK(res1)) {
18398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetAllCommands" "', expected argument " "1"" of type '" "wxFileType *""'");
18399 }
18400 arg1 = reinterpret_cast< wxFileType * >(argp1);
18401 {
18402 arg2 = wxString_in_helper(obj1);
18403 if (arg2 == NULL) SWIG_fail;
18404 temp2 = true;
18405 }
18406 if (obj2) {
18407 {
18408 arg3 = wxString_in_helper(obj2);
18409 if (arg3 == NULL) SWIG_fail;
18410 temp3 = true;
18411 }
18412 }
18413 {
18414 PyThreadState* __tstate = wxPyBeginAllowThreads();
18415 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18416 wxPyEndAllowThreads(__tstate);
18417 if (PyErr_Occurred()) SWIG_fail;
18418 }
18419 resultobj = result;
18420 {
18421 if (temp2)
18422 delete arg2;
18423 }
18424 {
18425 if (temp3)
18426 delete arg3;
18427 }
18428 return resultobj;
18429 fail:
18430 {
18431 if (temp2)
18432 delete arg2;
18433 }
18434 {
18435 if (temp3)
18436 delete arg3;
18437 }
18438 return NULL;
18439 }
18440
18441
18442 SWIGINTERN PyObject *_wrap_FileType_SetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18443 PyObject *resultobj = 0;
18444 wxFileType *arg1 = (wxFileType *) 0 ;
18445 wxString *arg2 = 0 ;
18446 wxString *arg3 = 0 ;
18447 bool arg4 = (bool) true ;
18448 bool result;
18449 void *argp1 = 0 ;
18450 int res1 = 0 ;
18451 bool temp2 = false ;
18452 bool temp3 = false ;
18453 bool val4 ;
18454 int ecode4 = 0 ;
18455 PyObject * obj0 = 0 ;
18456 PyObject * obj1 = 0 ;
18457 PyObject * obj2 = 0 ;
18458 PyObject * obj3 = 0 ;
18459 char * kwnames[] = {
18460 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
18461 };
18462
18463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18464 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18465 if (!SWIG_IsOK(res1)) {
18466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18467 }
18468 arg1 = reinterpret_cast< wxFileType * >(argp1);
18469 {
18470 arg2 = wxString_in_helper(obj1);
18471 if (arg2 == NULL) SWIG_fail;
18472 temp2 = true;
18473 }
18474 {
18475 arg3 = wxString_in_helper(obj2);
18476 if (arg3 == NULL) SWIG_fail;
18477 temp3 = true;
18478 }
18479 if (obj3) {
18480 ecode4 = SWIG_AsVal_bool(obj3, &val4);
18481 if (!SWIG_IsOK(ecode4)) {
18482 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileType_SetCommand" "', expected argument " "4"" of type '" "bool""'");
18483 }
18484 arg4 = static_cast< bool >(val4);
18485 }
18486 {
18487 PyThreadState* __tstate = wxPyBeginAllowThreads();
18488 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
18489 wxPyEndAllowThreads(__tstate);
18490 if (PyErr_Occurred()) SWIG_fail;
18491 }
18492 {
18493 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18494 }
18495 {
18496 if (temp2)
18497 delete arg2;
18498 }
18499 {
18500 if (temp3)
18501 delete arg3;
18502 }
18503 return resultobj;
18504 fail:
18505 {
18506 if (temp2)
18507 delete arg2;
18508 }
18509 {
18510 if (temp3)
18511 delete arg3;
18512 }
18513 return NULL;
18514 }
18515
18516
18517 SWIGINTERN PyObject *_wrap_FileType_SetDefaultIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18518 PyObject *resultobj = 0;
18519 wxFileType *arg1 = (wxFileType *) 0 ;
18520 wxString const &arg2_defvalue = wxPyEmptyString ;
18521 wxString *arg2 = (wxString *) &arg2_defvalue ;
18522 int arg3 = (int) 0 ;
18523 bool result;
18524 void *argp1 = 0 ;
18525 int res1 = 0 ;
18526 bool temp2 = false ;
18527 int val3 ;
18528 int ecode3 = 0 ;
18529 PyObject * obj0 = 0 ;
18530 PyObject * obj1 = 0 ;
18531 PyObject * obj2 = 0 ;
18532 char * kwnames[] = {
18533 (char *) "self",(char *) "cmd",(char *) "index", NULL
18534 };
18535
18536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18538 if (!SWIG_IsOK(res1)) {
18539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetDefaultIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
18540 }
18541 arg1 = reinterpret_cast< wxFileType * >(argp1);
18542 if (obj1) {
18543 {
18544 arg2 = wxString_in_helper(obj1);
18545 if (arg2 == NULL) SWIG_fail;
18546 temp2 = true;
18547 }
18548 }
18549 if (obj2) {
18550 ecode3 = SWIG_AsVal_int(obj2, &val3);
18551 if (!SWIG_IsOK(ecode3)) {
18552 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileType_SetDefaultIcon" "', expected argument " "3"" of type '" "int""'");
18553 }
18554 arg3 = static_cast< int >(val3);
18555 }
18556 {
18557 PyThreadState* __tstate = wxPyBeginAllowThreads();
18558 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
18559 wxPyEndAllowThreads(__tstate);
18560 if (PyErr_Occurred()) SWIG_fail;
18561 }
18562 {
18563 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18564 }
18565 {
18566 if (temp2)
18567 delete arg2;
18568 }
18569 return resultobj;
18570 fail:
18571 {
18572 if (temp2)
18573 delete arg2;
18574 }
18575 return NULL;
18576 }
18577
18578
18579 SWIGINTERN PyObject *_wrap_FileType_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18580 PyObject *resultobj = 0;
18581 wxFileType *arg1 = (wxFileType *) 0 ;
18582 bool result;
18583 void *argp1 = 0 ;
18584 int res1 = 0 ;
18585 PyObject *swig_obj[1] ;
18586
18587 if (!args) SWIG_fail;
18588 swig_obj[0] = args;
18589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18590 if (!SWIG_IsOK(res1)) {
18591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_Unassociate" "', expected argument " "1"" of type '" "wxFileType *""'");
18592 }
18593 arg1 = reinterpret_cast< wxFileType * >(argp1);
18594 {
18595 PyThreadState* __tstate = wxPyBeginAllowThreads();
18596 result = (bool)(arg1)->Unassociate();
18597 wxPyEndAllowThreads(__tstate);
18598 if (PyErr_Occurred()) SWIG_fail;
18599 }
18600 {
18601 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18602 }
18603 return resultobj;
18604 fail:
18605 return NULL;
18606 }
18607
18608
18609 SWIGINTERN PyObject *_wrap_FileType_ExpandCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18610 PyObject *resultobj = 0;
18611 wxString *arg1 = 0 ;
18612 wxString *arg2 = 0 ;
18613 wxString const &arg3_defvalue = wxPyEmptyString ;
18614 wxString *arg3 = (wxString *) &arg3_defvalue ;
18615 wxString result;
18616 bool temp1 = false ;
18617 bool temp2 = false ;
18618 bool temp3 = false ;
18619 PyObject * obj0 = 0 ;
18620 PyObject * obj1 = 0 ;
18621 PyObject * obj2 = 0 ;
18622 char * kwnames[] = {
18623 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
18624 };
18625
18626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18627 {
18628 arg1 = wxString_in_helper(obj0);
18629 if (arg1 == NULL) SWIG_fail;
18630 temp1 = true;
18631 }
18632 {
18633 arg2 = wxString_in_helper(obj1);
18634 if (arg2 == NULL) SWIG_fail;
18635 temp2 = true;
18636 }
18637 if (obj2) {
18638 {
18639 arg3 = wxString_in_helper(obj2);
18640 if (arg3 == NULL) SWIG_fail;
18641 temp3 = true;
18642 }
18643 }
18644 {
18645 PyThreadState* __tstate = wxPyBeginAllowThreads();
18646 result = wxFileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18647 wxPyEndAllowThreads(__tstate);
18648 if (PyErr_Occurred()) SWIG_fail;
18649 }
18650 {
18651 #if wxUSE_UNICODE
18652 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18653 #else
18654 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18655 #endif
18656 }
18657 {
18658 if (temp1)
18659 delete arg1;
18660 }
18661 {
18662 if (temp2)
18663 delete arg2;
18664 }
18665 {
18666 if (temp3)
18667 delete arg3;
18668 }
18669 return resultobj;
18670 fail:
18671 {
18672 if (temp1)
18673 delete arg1;
18674 }
18675 {
18676 if (temp2)
18677 delete arg2;
18678 }
18679 {
18680 if (temp3)
18681 delete arg3;
18682 }
18683 return NULL;
18684 }
18685
18686
18687 SWIGINTERN PyObject *FileType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18688 PyObject *obj;
18689 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18690 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileType, SWIG_NewClientData(obj));
18691 return SWIG_Py_Void();
18692 }
18693
18694 SWIGINTERN PyObject *FileType_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18695 return SWIG_Python_InitShadowInstance(args);
18696 }
18697
18698 SWIGINTERN int TheMimeTypesManager_set(PyObject *) {
18699 SWIG_Error(SWIG_AttributeError,"Variable TheMimeTypesManager is read-only.");
18700 return 1;
18701 }
18702
18703
18704 SWIGINTERN PyObject *TheMimeTypesManager_get(void) {
18705 PyObject *pyobj = 0;
18706
18707 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0 );
18708 return pyobj;
18709 }
18710
18711
18712 SWIGINTERN PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18713 PyObject *resultobj = 0;
18714 wxString *arg1 = 0 ;
18715 wxString *arg2 = 0 ;
18716 bool result;
18717 bool temp1 = false ;
18718 bool temp2 = false ;
18719 PyObject * obj0 = 0 ;
18720 PyObject * obj1 = 0 ;
18721 char * kwnames[] = {
18722 (char *) "mimeType",(char *) "wildcard", NULL
18723 };
18724
18725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) SWIG_fail;
18726 {
18727 arg1 = wxString_in_helper(obj0);
18728 if (arg1 == NULL) SWIG_fail;
18729 temp1 = true;
18730 }
18731 {
18732 arg2 = wxString_in_helper(obj1);
18733 if (arg2 == NULL) SWIG_fail;
18734 temp2 = true;
18735 }
18736 {
18737 PyThreadState* __tstate = wxPyBeginAllowThreads();
18738 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
18739 wxPyEndAllowThreads(__tstate);
18740 if (PyErr_Occurred()) SWIG_fail;
18741 }
18742 {
18743 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18744 }
18745 {
18746 if (temp1)
18747 delete arg1;
18748 }
18749 {
18750 if (temp2)
18751 delete arg2;
18752 }
18753 return resultobj;
18754 fail:
18755 {
18756 if (temp1)
18757 delete arg1;
18758 }
18759 {
18760 if (temp2)
18761 delete arg2;
18762 }
18763 return NULL;
18764 }
18765
18766
18767 SWIGINTERN PyObject *_wrap_new_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18768 PyObject *resultobj = 0;
18769 wxMimeTypesManager *result = 0 ;
18770
18771 if (!SWIG_Python_UnpackTuple(args,"new_MimeTypesManager",0,0,0)) SWIG_fail;
18772 {
18773 PyThreadState* __tstate = wxPyBeginAllowThreads();
18774 result = (wxMimeTypesManager *)new wxMimeTypesManager();
18775 wxPyEndAllowThreads(__tstate);
18776 if (PyErr_Occurred()) SWIG_fail;
18777 }
18778 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_NEW | 0 );
18779 return resultobj;
18780 fail:
18781 return NULL;
18782 }
18783
18784
18785 SWIGINTERN PyObject *_wrap_MimeTypesManager_Initialize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18786 PyObject *resultobj = 0;
18787 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18788 int arg2 = (int) wxMAILCAP_ALL ;
18789 wxString const &arg3_defvalue = wxPyEmptyString ;
18790 wxString *arg3 = (wxString *) &arg3_defvalue ;
18791 void *argp1 = 0 ;
18792 int res1 = 0 ;
18793 int val2 ;
18794 int ecode2 = 0 ;
18795 bool temp3 = false ;
18796 PyObject * obj0 = 0 ;
18797 PyObject * obj1 = 0 ;
18798 PyObject * obj2 = 0 ;
18799 char * kwnames[] = {
18800 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
18801 };
18802
18803 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18804 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18805 if (!SWIG_IsOK(res1)) {
18806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Initialize" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18807 }
18808 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18809 if (obj1) {
18810 ecode2 = SWIG_AsVal_int(obj1, &val2);
18811 if (!SWIG_IsOK(ecode2)) {
18812 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MimeTypesManager_Initialize" "', expected argument " "2"" of type '" "int""'");
18813 }
18814 arg2 = static_cast< int >(val2);
18815 }
18816 if (obj2) {
18817 {
18818 arg3 = wxString_in_helper(obj2);
18819 if (arg3 == NULL) SWIG_fail;
18820 temp3 = true;
18821 }
18822 }
18823 {
18824 PyThreadState* __tstate = wxPyBeginAllowThreads();
18825 (arg1)->Initialize(arg2,(wxString const &)*arg3);
18826 wxPyEndAllowThreads(__tstate);
18827 if (PyErr_Occurred()) SWIG_fail;
18828 }
18829 resultobj = SWIG_Py_Void();
18830 {
18831 if (temp3)
18832 delete arg3;
18833 }
18834 return resultobj;
18835 fail:
18836 {
18837 if (temp3)
18838 delete arg3;
18839 }
18840 return NULL;
18841 }
18842
18843
18844 SWIGINTERN PyObject *_wrap_MimeTypesManager_ClearData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18845 PyObject *resultobj = 0;
18846 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18847 void *argp1 = 0 ;
18848 int res1 = 0 ;
18849 PyObject *swig_obj[1] ;
18850
18851 if (!args) SWIG_fail;
18852 swig_obj[0] = args;
18853 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18854 if (!SWIG_IsOK(res1)) {
18855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ClearData" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18856 }
18857 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18858 {
18859 PyThreadState* __tstate = wxPyBeginAllowThreads();
18860 (arg1)->ClearData();
18861 wxPyEndAllowThreads(__tstate);
18862 if (PyErr_Occurred()) SWIG_fail;
18863 }
18864 resultobj = SWIG_Py_Void();
18865 return resultobj;
18866 fail:
18867 return NULL;
18868 }
18869
18870
18871 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18872 PyObject *resultobj = 0;
18873 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18874 wxString *arg2 = 0 ;
18875 wxFileType *result = 0 ;
18876 void *argp1 = 0 ;
18877 int res1 = 0 ;
18878 bool temp2 = false ;
18879 PyObject * obj0 = 0 ;
18880 PyObject * obj1 = 0 ;
18881 char * kwnames[] = {
18882 (char *) "self",(char *) "ext", NULL
18883 };
18884
18885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) SWIG_fail;
18886 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18887 if (!SWIG_IsOK(res1)) {
18888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromExtension" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18889 }
18890 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18891 {
18892 arg2 = wxString_in_helper(obj1);
18893 if (arg2 == NULL) SWIG_fail;
18894 temp2 = true;
18895 }
18896 {
18897 PyThreadState* __tstate = wxPyBeginAllowThreads();
18898 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
18899 wxPyEndAllowThreads(__tstate);
18900 if (PyErr_Occurred()) SWIG_fail;
18901 }
18902 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
18903 {
18904 if (temp2)
18905 delete arg2;
18906 }
18907 return resultobj;
18908 fail:
18909 {
18910 if (temp2)
18911 delete arg2;
18912 }
18913 return NULL;
18914 }
18915
18916
18917 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18918 PyObject *resultobj = 0;
18919 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18920 wxString *arg2 = 0 ;
18921 wxFileType *result = 0 ;
18922 void *argp1 = 0 ;
18923 int res1 = 0 ;
18924 bool temp2 = false ;
18925 PyObject * obj0 = 0 ;
18926 PyObject * obj1 = 0 ;
18927 char * kwnames[] = {
18928 (char *) "self",(char *) "mimeType", NULL
18929 };
18930
18931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
18932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18933 if (!SWIG_IsOK(res1)) {
18934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromMimeType" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18935 }
18936 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18937 {
18938 arg2 = wxString_in_helper(obj1);
18939 if (arg2 == NULL) SWIG_fail;
18940 temp2 = true;
18941 }
18942 {
18943 PyThreadState* __tstate = wxPyBeginAllowThreads();
18944 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
18945 wxPyEndAllowThreads(__tstate);
18946 if (PyErr_Occurred()) SWIG_fail;
18947 }
18948 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
18949 {
18950 if (temp2)
18951 delete arg2;
18952 }
18953 return resultobj;
18954 fail:
18955 {
18956 if (temp2)
18957 delete arg2;
18958 }
18959 return NULL;
18960 }
18961
18962
18963 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18964 PyObject *resultobj = 0;
18965 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18966 wxString *arg2 = 0 ;
18967 bool arg3 = (bool) false ;
18968 bool result;
18969 void *argp1 = 0 ;
18970 int res1 = 0 ;
18971 bool temp2 = false ;
18972 bool val3 ;
18973 int ecode3 = 0 ;
18974 PyObject * obj0 = 0 ;
18975 PyObject * obj1 = 0 ;
18976 PyObject * obj2 = 0 ;
18977 char * kwnames[] = {
18978 (char *) "self",(char *) "filename",(char *) "fallback", NULL
18979 };
18980
18981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18983 if (!SWIG_IsOK(res1)) {
18984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18985 }
18986 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18987 {
18988 arg2 = wxString_in_helper(obj1);
18989 if (arg2 == NULL) SWIG_fail;
18990 temp2 = true;
18991 }
18992 if (obj2) {
18993 ecode3 = SWIG_AsVal_bool(obj2, &val3);
18994 if (!SWIG_IsOK(ecode3)) {
18995 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "3"" of type '" "bool""'");
18996 }
18997 arg3 = static_cast< bool >(val3);
18998 }
18999 {
19000 PyThreadState* __tstate = wxPyBeginAllowThreads();
19001 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
19002 wxPyEndAllowThreads(__tstate);
19003 if (PyErr_Occurred()) SWIG_fail;
19004 }
19005 {
19006 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19007 }
19008 {
19009 if (temp2)
19010 delete arg2;
19011 }
19012 return resultobj;
19013 fail:
19014 {
19015 if (temp2)
19016 delete arg2;
19017 }
19018 return NULL;
19019 }
19020
19021
19022 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19023 PyObject *resultobj = 0;
19024 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19025 wxString *arg2 = 0 ;
19026 bool result;
19027 void *argp1 = 0 ;
19028 int res1 = 0 ;
19029 bool temp2 = false ;
19030 PyObject * obj0 = 0 ;
19031 PyObject * obj1 = 0 ;
19032 char * kwnames[] = {
19033 (char *) "self",(char *) "filename", NULL
19034 };
19035
19036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) SWIG_fail;
19037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19038 if (!SWIG_IsOK(res1)) {
19039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMimeTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19040 }
19041 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19042 {
19043 arg2 = wxString_in_helper(obj1);
19044 if (arg2 == NULL) SWIG_fail;
19045 temp2 = true;
19046 }
19047 {
19048 PyThreadState* __tstate = wxPyBeginAllowThreads();
19049 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
19050 wxPyEndAllowThreads(__tstate);
19051 if (PyErr_Occurred()) SWIG_fail;
19052 }
19053 {
19054 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19055 }
19056 {
19057 if (temp2)
19058 delete arg2;
19059 }
19060 return resultobj;
19061 fail:
19062 {
19063 if (temp2)
19064 delete arg2;
19065 }
19066 return NULL;
19067 }
19068
19069
19070 SWIGINTERN PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19071 PyObject *resultobj = 0;
19072 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19073 PyObject *result = 0 ;
19074 void *argp1 = 0 ;
19075 int res1 = 0 ;
19076 PyObject *swig_obj[1] ;
19077
19078 if (!args) SWIG_fail;
19079 swig_obj[0] = args;
19080 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19081 if (!SWIG_IsOK(res1)) {
19082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_EnumAllFileTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19083 }
19084 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19085 {
19086 PyThreadState* __tstate = wxPyBeginAllowThreads();
19087 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
19088 wxPyEndAllowThreads(__tstate);
19089 if (PyErr_Occurred()) SWIG_fail;
19090 }
19091 resultobj = result;
19092 return resultobj;
19093 fail:
19094 return NULL;
19095 }
19096
19097
19098 SWIGINTERN PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19099 PyObject *resultobj = 0;
19100 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19101 wxFileTypeInfo *arg2 = 0 ;
19102 void *argp1 = 0 ;
19103 int res1 = 0 ;
19104 void *argp2 = 0 ;
19105 int res2 = 0 ;
19106 PyObject * obj0 = 0 ;
19107 PyObject * obj1 = 0 ;
19108 char * kwnames[] = {
19109 (char *) "self",(char *) "ft", NULL
19110 };
19111
19112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) SWIG_fail;
19113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19114 if (!SWIG_IsOK(res1)) {
19115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19116 }
19117 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19118 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
19119 if (!SWIG_IsOK(res2)) {
19120 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19121 }
19122 if (!argp2) {
19123 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19124 }
19125 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
19126 {
19127 PyThreadState* __tstate = wxPyBeginAllowThreads();
19128 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
19129 wxPyEndAllowThreads(__tstate);
19130 if (PyErr_Occurred()) SWIG_fail;
19131 }
19132 resultobj = SWIG_Py_Void();
19133 return resultobj;
19134 fail:
19135 return NULL;
19136 }
19137
19138
19139 SWIGINTERN PyObject *_wrap_MimeTypesManager_Associate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19140 PyObject *resultobj = 0;
19141 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19142 wxFileTypeInfo *arg2 = 0 ;
19143 wxFileType *result = 0 ;
19144 void *argp1 = 0 ;
19145 int res1 = 0 ;
19146 void *argp2 = 0 ;
19147 int res2 = 0 ;
19148 PyObject * obj0 = 0 ;
19149 PyObject * obj1 = 0 ;
19150 char * kwnames[] = {
19151 (char *) "self",(char *) "ftInfo", NULL
19152 };
19153
19154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) SWIG_fail;
19155 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19156 if (!SWIG_IsOK(res1)) {
19157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Associate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19158 }
19159 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19160 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
19161 if (!SWIG_IsOK(res2)) {
19162 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19163 }
19164 if (!argp2) {
19165 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19166 }
19167 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
19168 {
19169 PyThreadState* __tstate = wxPyBeginAllowThreads();
19170 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
19171 wxPyEndAllowThreads(__tstate);
19172 if (PyErr_Occurred()) SWIG_fail;
19173 }
19174 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
19175 return resultobj;
19176 fail:
19177 return NULL;
19178 }
19179
19180
19181 SWIGINTERN PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19182 PyObject *resultobj = 0;
19183 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19184 wxFileType *arg2 = (wxFileType *) 0 ;
19185 bool result;
19186 void *argp1 = 0 ;
19187 int res1 = 0 ;
19188 void *argp2 = 0 ;
19189 int res2 = 0 ;
19190 PyObject * obj0 = 0 ;
19191 PyObject * obj1 = 0 ;
19192 char * kwnames[] = {
19193 (char *) "self",(char *) "ft", NULL
19194 };
19195
19196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) SWIG_fail;
19197 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19198 if (!SWIG_IsOK(res1)) {
19199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19200 }
19201 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19202 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFileType, 0 | 0 );
19203 if (!SWIG_IsOK(res2)) {
19204 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "2"" of type '" "wxFileType *""'");
19205 }
19206 arg2 = reinterpret_cast< wxFileType * >(argp2);
19207 {
19208 PyThreadState* __tstate = wxPyBeginAllowThreads();
19209 result = (bool)(arg1)->Unassociate(arg2);
19210 wxPyEndAllowThreads(__tstate);
19211 if (PyErr_Occurred()) SWIG_fail;
19212 }
19213 {
19214 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19215 }
19216 return resultobj;
19217 fail:
19218 return NULL;
19219 }
19220
19221
19222 SWIGINTERN PyObject *_wrap_delete_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19223 PyObject *resultobj = 0;
19224 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19225 void *argp1 = 0 ;
19226 int res1 = 0 ;
19227 PyObject *swig_obj[1] ;
19228
19229 if (!args) SWIG_fail;
19230 swig_obj[0] = args;
19231 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_DISOWN | 0 );
19232 if (!SWIG_IsOK(res1)) {
19233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MimeTypesManager" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19234 }
19235 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19236 {
19237 PyThreadState* __tstate = wxPyBeginAllowThreads();
19238 delete arg1;
19239
19240 wxPyEndAllowThreads(__tstate);
19241 if (PyErr_Occurred()) SWIG_fail;
19242 }
19243 resultobj = SWIG_Py_Void();
19244 return resultobj;
19245 fail:
19246 return NULL;
19247 }
19248
19249
19250 SWIGINTERN PyObject *MimeTypesManager_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19251 PyObject *obj;
19252 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19253 SWIG_TypeNewClientData(SWIGTYPE_p_wxMimeTypesManager, SWIG_NewClientData(obj));
19254 return SWIG_Py_Void();
19255 }
19256
19257 SWIGINTERN PyObject *MimeTypesManager_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19258 return SWIG_Python_InitShadowInstance(args);
19259 }
19260
19261 SWIGINTERN int ART_TOOLBAR_set(PyObject *) {
19262 SWIG_Error(SWIG_AttributeError,"Variable ART_TOOLBAR is read-only.");
19263 return 1;
19264 }
19265
19266
19267 SWIGINTERN PyObject *ART_TOOLBAR_get(void) {
19268 PyObject *pyobj = 0;
19269
19270 {
19271 #if wxUSE_UNICODE
19272 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
19273 #else
19274 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
19275 #endif
19276 }
19277 return pyobj;
19278 }
19279
19280
19281 SWIGINTERN int ART_MENU_set(PyObject *) {
19282 SWIG_Error(SWIG_AttributeError,"Variable ART_MENU is read-only.");
19283 return 1;
19284 }
19285
19286
19287 SWIGINTERN PyObject *ART_MENU_get(void) {
19288 PyObject *pyobj = 0;
19289
19290 {
19291 #if wxUSE_UNICODE
19292 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
19293 #else
19294 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
19295 #endif
19296 }
19297 return pyobj;
19298 }
19299
19300
19301 SWIGINTERN int ART_FRAME_ICON_set(PyObject *) {
19302 SWIG_Error(SWIG_AttributeError,"Variable ART_FRAME_ICON is read-only.");
19303 return 1;
19304 }
19305
19306
19307 SWIGINTERN PyObject *ART_FRAME_ICON_get(void) {
19308 PyObject *pyobj = 0;
19309
19310 {
19311 #if wxUSE_UNICODE
19312 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
19313 #else
19314 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
19315 #endif
19316 }
19317 return pyobj;
19318 }
19319
19320
19321 SWIGINTERN int ART_CMN_DIALOG_set(PyObject *) {
19322 SWIG_Error(SWIG_AttributeError,"Variable ART_CMN_DIALOG is read-only.");
19323 return 1;
19324 }
19325
19326
19327 SWIGINTERN PyObject *ART_CMN_DIALOG_get(void) {
19328 PyObject *pyobj = 0;
19329
19330 {
19331 #if wxUSE_UNICODE
19332 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
19333 #else
19334 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
19335 #endif
19336 }
19337 return pyobj;
19338 }
19339
19340
19341 SWIGINTERN int ART_HELP_BROWSER_set(PyObject *) {
19342 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BROWSER is read-only.");
19343 return 1;
19344 }
19345
19346
19347 SWIGINTERN PyObject *ART_HELP_BROWSER_get(void) {
19348 PyObject *pyobj = 0;
19349
19350 {
19351 #if wxUSE_UNICODE
19352 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
19353 #else
19354 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
19355 #endif
19356 }
19357 return pyobj;
19358 }
19359
19360
19361 SWIGINTERN int ART_MESSAGE_BOX_set(PyObject *) {
19362 SWIG_Error(SWIG_AttributeError,"Variable ART_MESSAGE_BOX is read-only.");
19363 return 1;
19364 }
19365
19366
19367 SWIGINTERN PyObject *ART_MESSAGE_BOX_get(void) {
19368 PyObject *pyobj = 0;
19369
19370 {
19371 #if wxUSE_UNICODE
19372 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
19373 #else
19374 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
19375 #endif
19376 }
19377 return pyobj;
19378 }
19379
19380
19381 SWIGINTERN int ART_BUTTON_set(PyObject *) {
19382 SWIG_Error(SWIG_AttributeError,"Variable ART_BUTTON is read-only.");
19383 return 1;
19384 }
19385
19386
19387 SWIGINTERN PyObject *ART_BUTTON_get(void) {
19388 PyObject *pyobj = 0;
19389
19390 {
19391 #if wxUSE_UNICODE
19392 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
19393 #else
19394 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
19395 #endif
19396 }
19397 return pyobj;
19398 }
19399
19400
19401 SWIGINTERN int ART_OTHER_set(PyObject *) {
19402 SWIG_Error(SWIG_AttributeError,"Variable ART_OTHER is read-only.");
19403 return 1;
19404 }
19405
19406
19407 SWIGINTERN PyObject *ART_OTHER_get(void) {
19408 PyObject *pyobj = 0;
19409
19410 {
19411 #if wxUSE_UNICODE
19412 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
19413 #else
19414 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
19415 #endif
19416 }
19417 return pyobj;
19418 }
19419
19420
19421 SWIGINTERN int ART_ADD_BOOKMARK_set(PyObject *) {
19422 SWIG_Error(SWIG_AttributeError,"Variable ART_ADD_BOOKMARK is read-only.");
19423 return 1;
19424 }
19425
19426
19427 SWIGINTERN PyObject *ART_ADD_BOOKMARK_get(void) {
19428 PyObject *pyobj = 0;
19429
19430 {
19431 #if wxUSE_UNICODE
19432 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
19433 #else
19434 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
19435 #endif
19436 }
19437 return pyobj;
19438 }
19439
19440
19441 SWIGINTERN int ART_DEL_BOOKMARK_set(PyObject *) {
19442 SWIG_Error(SWIG_AttributeError,"Variable ART_DEL_BOOKMARK is read-only.");
19443 return 1;
19444 }
19445
19446
19447 SWIGINTERN PyObject *ART_DEL_BOOKMARK_get(void) {
19448 PyObject *pyobj = 0;
19449
19450 {
19451 #if wxUSE_UNICODE
19452 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
19453 #else
19454 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
19455 #endif
19456 }
19457 return pyobj;
19458 }
19459
19460
19461 SWIGINTERN int ART_HELP_SIDE_PANEL_set(PyObject *) {
19462 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
19463 return 1;
19464 }
19465
19466
19467 SWIGINTERN PyObject *ART_HELP_SIDE_PANEL_get(void) {
19468 PyObject *pyobj = 0;
19469
19470 {
19471 #if wxUSE_UNICODE
19472 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
19473 #else
19474 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
19475 #endif
19476 }
19477 return pyobj;
19478 }
19479
19480
19481 SWIGINTERN int ART_HELP_SETTINGS_set(PyObject *) {
19482 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SETTINGS is read-only.");
19483 return 1;
19484 }
19485
19486
19487 SWIGINTERN PyObject *ART_HELP_SETTINGS_get(void) {
19488 PyObject *pyobj = 0;
19489
19490 {
19491 #if wxUSE_UNICODE
19492 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
19493 #else
19494 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
19495 #endif
19496 }
19497 return pyobj;
19498 }
19499
19500
19501 SWIGINTERN int ART_HELP_BOOK_set(PyObject *) {
19502 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BOOK is read-only.");
19503 return 1;
19504 }
19505
19506
19507 SWIGINTERN PyObject *ART_HELP_BOOK_get(void) {
19508 PyObject *pyobj = 0;
19509
19510 {
19511 #if wxUSE_UNICODE
19512 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
19513 #else
19514 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
19515 #endif
19516 }
19517 return pyobj;
19518 }
19519
19520
19521 SWIGINTERN int ART_HELP_FOLDER_set(PyObject *) {
19522 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_FOLDER is read-only.");
19523 return 1;
19524 }
19525
19526
19527 SWIGINTERN PyObject *ART_HELP_FOLDER_get(void) {
19528 PyObject *pyobj = 0;
19529
19530 {
19531 #if wxUSE_UNICODE
19532 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
19533 #else
19534 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
19535 #endif
19536 }
19537 return pyobj;
19538 }
19539
19540
19541 SWIGINTERN int ART_HELP_PAGE_set(PyObject *) {
19542 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_PAGE is read-only.");
19543 return 1;
19544 }
19545
19546
19547 SWIGINTERN PyObject *ART_HELP_PAGE_get(void) {
19548 PyObject *pyobj = 0;
19549
19550 {
19551 #if wxUSE_UNICODE
19552 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
19553 #else
19554 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
19555 #endif
19556 }
19557 return pyobj;
19558 }
19559
19560
19561 SWIGINTERN int ART_GO_BACK_set(PyObject *) {
19562 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_BACK is read-only.");
19563 return 1;
19564 }
19565
19566
19567 SWIGINTERN PyObject *ART_GO_BACK_get(void) {
19568 PyObject *pyobj = 0;
19569
19570 {
19571 #if wxUSE_UNICODE
19572 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
19573 #else
19574 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
19575 #endif
19576 }
19577 return pyobj;
19578 }
19579
19580
19581 SWIGINTERN int ART_GO_FORWARD_set(PyObject *) {
19582 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_FORWARD is read-only.");
19583 return 1;
19584 }
19585
19586
19587 SWIGINTERN PyObject *ART_GO_FORWARD_get(void) {
19588 PyObject *pyobj = 0;
19589
19590 {
19591 #if wxUSE_UNICODE
19592 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
19593 #else
19594 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
19595 #endif
19596 }
19597 return pyobj;
19598 }
19599
19600
19601 SWIGINTERN int ART_GO_UP_set(PyObject *) {
19602 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_UP is read-only.");
19603 return 1;
19604 }
19605
19606
19607 SWIGINTERN PyObject *ART_GO_UP_get(void) {
19608 PyObject *pyobj = 0;
19609
19610 {
19611 #if wxUSE_UNICODE
19612 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
19613 #else
19614 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
19615 #endif
19616 }
19617 return pyobj;
19618 }
19619
19620
19621 SWIGINTERN int ART_GO_DOWN_set(PyObject *) {
19622 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DOWN is read-only.");
19623 return 1;
19624 }
19625
19626
19627 SWIGINTERN PyObject *ART_GO_DOWN_get(void) {
19628 PyObject *pyobj = 0;
19629
19630 {
19631 #if wxUSE_UNICODE
19632 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
19633 #else
19634 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
19635 #endif
19636 }
19637 return pyobj;
19638 }
19639
19640
19641 SWIGINTERN int ART_GO_TO_PARENT_set(PyObject *) {
19642 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_TO_PARENT is read-only.");
19643 return 1;
19644 }
19645
19646
19647 SWIGINTERN PyObject *ART_GO_TO_PARENT_get(void) {
19648 PyObject *pyobj = 0;
19649
19650 {
19651 #if wxUSE_UNICODE
19652 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
19653 #else
19654 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
19655 #endif
19656 }
19657 return pyobj;
19658 }
19659
19660
19661 SWIGINTERN int ART_GO_HOME_set(PyObject *) {
19662 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_HOME is read-only.");
19663 return 1;
19664 }
19665
19666
19667 SWIGINTERN PyObject *ART_GO_HOME_get(void) {
19668 PyObject *pyobj = 0;
19669
19670 {
19671 #if wxUSE_UNICODE
19672 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
19673 #else
19674 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
19675 #endif
19676 }
19677 return pyobj;
19678 }
19679
19680
19681 SWIGINTERN int ART_FILE_OPEN_set(PyObject *) {
19682 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_OPEN is read-only.");
19683 return 1;
19684 }
19685
19686
19687 SWIGINTERN PyObject *ART_FILE_OPEN_get(void) {
19688 PyObject *pyobj = 0;
19689
19690 {
19691 #if wxUSE_UNICODE
19692 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
19693 #else
19694 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
19695 #endif
19696 }
19697 return pyobj;
19698 }
19699
19700
19701 SWIGINTERN int ART_FILE_SAVE_set(PyObject *) {
19702 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE is read-only.");
19703 return 1;
19704 }
19705
19706
19707 SWIGINTERN PyObject *ART_FILE_SAVE_get(void) {
19708 PyObject *pyobj = 0;
19709
19710 {
19711 #if wxUSE_UNICODE
19712 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
19713 #else
19714 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
19715 #endif
19716 }
19717 return pyobj;
19718 }
19719
19720
19721 SWIGINTERN int ART_FILE_SAVE_AS_set(PyObject *) {
19722 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE_AS is read-only.");
19723 return 1;
19724 }
19725
19726
19727 SWIGINTERN PyObject *ART_FILE_SAVE_AS_get(void) {
19728 PyObject *pyobj = 0;
19729
19730 {
19731 #if wxUSE_UNICODE
19732 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
19733 #else
19734 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
19735 #endif
19736 }
19737 return pyobj;
19738 }
19739
19740
19741 SWIGINTERN int ART_PRINT_set(PyObject *) {
19742 SWIG_Error(SWIG_AttributeError,"Variable ART_PRINT is read-only.");
19743 return 1;
19744 }
19745
19746
19747 SWIGINTERN PyObject *ART_PRINT_get(void) {
19748 PyObject *pyobj = 0;
19749
19750 {
19751 #if wxUSE_UNICODE
19752 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
19753 #else
19754 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
19755 #endif
19756 }
19757 return pyobj;
19758 }
19759
19760
19761 SWIGINTERN int ART_HELP_set(PyObject *) {
19762 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP is read-only.");
19763 return 1;
19764 }
19765
19766
19767 SWIGINTERN PyObject *ART_HELP_get(void) {
19768 PyObject *pyobj = 0;
19769
19770 {
19771 #if wxUSE_UNICODE
19772 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
19773 #else
19774 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
19775 #endif
19776 }
19777 return pyobj;
19778 }
19779
19780
19781 SWIGINTERN int ART_TIP_set(PyObject *) {
19782 SWIG_Error(SWIG_AttributeError,"Variable ART_TIP is read-only.");
19783 return 1;
19784 }
19785
19786
19787 SWIGINTERN PyObject *ART_TIP_get(void) {
19788 PyObject *pyobj = 0;
19789
19790 {
19791 #if wxUSE_UNICODE
19792 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
19793 #else
19794 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
19795 #endif
19796 }
19797 return pyobj;
19798 }
19799
19800
19801 SWIGINTERN int ART_REPORT_VIEW_set(PyObject *) {
19802 SWIG_Error(SWIG_AttributeError,"Variable ART_REPORT_VIEW is read-only.");
19803 return 1;
19804 }
19805
19806
19807 SWIGINTERN PyObject *ART_REPORT_VIEW_get(void) {
19808 PyObject *pyobj = 0;
19809
19810 {
19811 #if wxUSE_UNICODE
19812 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
19813 #else
19814 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
19815 #endif
19816 }
19817 return pyobj;
19818 }
19819
19820
19821 SWIGINTERN int ART_LIST_VIEW_set(PyObject *) {
19822 SWIG_Error(SWIG_AttributeError,"Variable ART_LIST_VIEW is read-only.");
19823 return 1;
19824 }
19825
19826
19827 SWIGINTERN PyObject *ART_LIST_VIEW_get(void) {
19828 PyObject *pyobj = 0;
19829
19830 {
19831 #if wxUSE_UNICODE
19832 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
19833 #else
19834 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
19835 #endif
19836 }
19837 return pyobj;
19838 }
19839
19840
19841 SWIGINTERN int ART_NEW_DIR_set(PyObject *) {
19842 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW_DIR is read-only.");
19843 return 1;
19844 }
19845
19846
19847 SWIGINTERN PyObject *ART_NEW_DIR_get(void) {
19848 PyObject *pyobj = 0;
19849
19850 {
19851 #if wxUSE_UNICODE
19852 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
19853 #else
19854 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
19855 #endif
19856 }
19857 return pyobj;
19858 }
19859
19860
19861 SWIGINTERN int ART_HARDDISK_set(PyObject *) {
19862 SWIG_Error(SWIG_AttributeError,"Variable ART_HARDDISK is read-only.");
19863 return 1;
19864 }
19865
19866
19867 SWIGINTERN PyObject *ART_HARDDISK_get(void) {
19868 PyObject *pyobj = 0;
19869
19870 {
19871 #if wxUSE_UNICODE
19872 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
19873 #else
19874 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
19875 #endif
19876 }
19877 return pyobj;
19878 }
19879
19880
19881 SWIGINTERN int ART_FLOPPY_set(PyObject *) {
19882 SWIG_Error(SWIG_AttributeError,"Variable ART_FLOPPY is read-only.");
19883 return 1;
19884 }
19885
19886
19887 SWIGINTERN PyObject *ART_FLOPPY_get(void) {
19888 PyObject *pyobj = 0;
19889
19890 {
19891 #if wxUSE_UNICODE
19892 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
19893 #else
19894 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
19895 #endif
19896 }
19897 return pyobj;
19898 }
19899
19900
19901 SWIGINTERN int ART_CDROM_set(PyObject *) {
19902 SWIG_Error(SWIG_AttributeError,"Variable ART_CDROM is read-only.");
19903 return 1;
19904 }
19905
19906
19907 SWIGINTERN PyObject *ART_CDROM_get(void) {
19908 PyObject *pyobj = 0;
19909
19910 {
19911 #if wxUSE_UNICODE
19912 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
19913 #else
19914 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
19915 #endif
19916 }
19917 return pyobj;
19918 }
19919
19920
19921 SWIGINTERN int ART_REMOVABLE_set(PyObject *) {
19922 SWIG_Error(SWIG_AttributeError,"Variable ART_REMOVABLE is read-only.");
19923 return 1;
19924 }
19925
19926
19927 SWIGINTERN PyObject *ART_REMOVABLE_get(void) {
19928 PyObject *pyobj = 0;
19929
19930 {
19931 #if wxUSE_UNICODE
19932 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
19933 #else
19934 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
19935 #endif
19936 }
19937 return pyobj;
19938 }
19939
19940
19941 SWIGINTERN int ART_FOLDER_set(PyObject *) {
19942 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER is read-only.");
19943 return 1;
19944 }
19945
19946
19947 SWIGINTERN PyObject *ART_FOLDER_get(void) {
19948 PyObject *pyobj = 0;
19949
19950 {
19951 #if wxUSE_UNICODE
19952 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
19953 #else
19954 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
19955 #endif
19956 }
19957 return pyobj;
19958 }
19959
19960
19961 SWIGINTERN int ART_FOLDER_OPEN_set(PyObject *) {
19962 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER_OPEN is read-only.");
19963 return 1;
19964 }
19965
19966
19967 SWIGINTERN PyObject *ART_FOLDER_OPEN_get(void) {
19968 PyObject *pyobj = 0;
19969
19970 {
19971 #if wxUSE_UNICODE
19972 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
19973 #else
19974 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
19975 #endif
19976 }
19977 return pyobj;
19978 }
19979
19980
19981 SWIGINTERN int ART_GO_DIR_UP_set(PyObject *) {
19982 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DIR_UP is read-only.");
19983 return 1;
19984 }
19985
19986
19987 SWIGINTERN PyObject *ART_GO_DIR_UP_get(void) {
19988 PyObject *pyobj = 0;
19989
19990 {
19991 #if wxUSE_UNICODE
19992 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
19993 #else
19994 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
19995 #endif
19996 }
19997 return pyobj;
19998 }
19999
20000
20001 SWIGINTERN int ART_EXECUTABLE_FILE_set(PyObject *) {
20002 SWIG_Error(SWIG_AttributeError,"Variable ART_EXECUTABLE_FILE is read-only.");
20003 return 1;
20004 }
20005
20006
20007 SWIGINTERN PyObject *ART_EXECUTABLE_FILE_get(void) {
20008 PyObject *pyobj = 0;
20009
20010 {
20011 #if wxUSE_UNICODE
20012 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
20013 #else
20014 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
20015 #endif
20016 }
20017 return pyobj;
20018 }
20019
20020
20021 SWIGINTERN int ART_NORMAL_FILE_set(PyObject *) {
20022 SWIG_Error(SWIG_AttributeError,"Variable ART_NORMAL_FILE is read-only.");
20023 return 1;
20024 }
20025
20026
20027 SWIGINTERN PyObject *ART_NORMAL_FILE_get(void) {
20028 PyObject *pyobj = 0;
20029
20030 {
20031 #if wxUSE_UNICODE
20032 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
20033 #else
20034 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
20035 #endif
20036 }
20037 return pyobj;
20038 }
20039
20040
20041 SWIGINTERN int ART_TICK_MARK_set(PyObject *) {
20042 SWIG_Error(SWIG_AttributeError,"Variable ART_TICK_MARK is read-only.");
20043 return 1;
20044 }
20045
20046
20047 SWIGINTERN PyObject *ART_TICK_MARK_get(void) {
20048 PyObject *pyobj = 0;
20049
20050 {
20051 #if wxUSE_UNICODE
20052 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
20053 #else
20054 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
20055 #endif
20056 }
20057 return pyobj;
20058 }
20059
20060
20061 SWIGINTERN int ART_CROSS_MARK_set(PyObject *) {
20062 SWIG_Error(SWIG_AttributeError,"Variable ART_CROSS_MARK is read-only.");
20063 return 1;
20064 }
20065
20066
20067 SWIGINTERN PyObject *ART_CROSS_MARK_get(void) {
20068 PyObject *pyobj = 0;
20069
20070 {
20071 #if wxUSE_UNICODE
20072 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
20073 #else
20074 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
20075 #endif
20076 }
20077 return pyobj;
20078 }
20079
20080
20081 SWIGINTERN int ART_ERROR_set(PyObject *) {
20082 SWIG_Error(SWIG_AttributeError,"Variable ART_ERROR is read-only.");
20083 return 1;
20084 }
20085
20086
20087 SWIGINTERN PyObject *ART_ERROR_get(void) {
20088 PyObject *pyobj = 0;
20089
20090 {
20091 #if wxUSE_UNICODE
20092 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
20093 #else
20094 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
20095 #endif
20096 }
20097 return pyobj;
20098 }
20099
20100
20101 SWIGINTERN int ART_QUESTION_set(PyObject *) {
20102 SWIG_Error(SWIG_AttributeError,"Variable ART_QUESTION is read-only.");
20103 return 1;
20104 }
20105
20106
20107 SWIGINTERN PyObject *ART_QUESTION_get(void) {
20108 PyObject *pyobj = 0;
20109
20110 {
20111 #if wxUSE_UNICODE
20112 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
20113 #else
20114 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
20115 #endif
20116 }
20117 return pyobj;
20118 }
20119
20120
20121 SWIGINTERN int ART_WARNING_set(PyObject *) {
20122 SWIG_Error(SWIG_AttributeError,"Variable ART_WARNING is read-only.");
20123 return 1;
20124 }
20125
20126
20127 SWIGINTERN PyObject *ART_WARNING_get(void) {
20128 PyObject *pyobj = 0;
20129
20130 {
20131 #if wxUSE_UNICODE
20132 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
20133 #else
20134 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
20135 #endif
20136 }
20137 return pyobj;
20138 }
20139
20140
20141 SWIGINTERN int ART_INFORMATION_set(PyObject *) {
20142 SWIG_Error(SWIG_AttributeError,"Variable ART_INFORMATION is read-only.");
20143 return 1;
20144 }
20145
20146
20147 SWIGINTERN PyObject *ART_INFORMATION_get(void) {
20148 PyObject *pyobj = 0;
20149
20150 {
20151 #if wxUSE_UNICODE
20152 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
20153 #else
20154 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
20155 #endif
20156 }
20157 return pyobj;
20158 }
20159
20160
20161 SWIGINTERN int ART_MISSING_IMAGE_set(PyObject *) {
20162 SWIG_Error(SWIG_AttributeError,"Variable ART_MISSING_IMAGE is read-only.");
20163 return 1;
20164 }
20165
20166
20167 SWIGINTERN PyObject *ART_MISSING_IMAGE_get(void) {
20168 PyObject *pyobj = 0;
20169
20170 {
20171 #if wxUSE_UNICODE
20172 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
20173 #else
20174 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
20175 #endif
20176 }
20177 return pyobj;
20178 }
20179
20180
20181 SWIGINTERN int ART_COPY_set(PyObject *) {
20182 SWIG_Error(SWIG_AttributeError,"Variable ART_COPY is read-only.");
20183 return 1;
20184 }
20185
20186
20187 SWIGINTERN PyObject *ART_COPY_get(void) {
20188 PyObject *pyobj = 0;
20189
20190 {
20191 #if wxUSE_UNICODE
20192 pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
20193 #else
20194 pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
20195 #endif
20196 }
20197 return pyobj;
20198 }
20199
20200
20201 SWIGINTERN int ART_CUT_set(PyObject *) {
20202 SWIG_Error(SWIG_AttributeError,"Variable ART_CUT is read-only.");
20203 return 1;
20204 }
20205
20206
20207 SWIGINTERN PyObject *ART_CUT_get(void) {
20208 PyObject *pyobj = 0;
20209
20210 {
20211 #if wxUSE_UNICODE
20212 pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
20213 #else
20214 pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
20215 #endif
20216 }
20217 return pyobj;
20218 }
20219
20220
20221 SWIGINTERN int ART_PASTE_set(PyObject *) {
20222 SWIG_Error(SWIG_AttributeError,"Variable ART_PASTE is read-only.");
20223 return 1;
20224 }
20225
20226
20227 SWIGINTERN PyObject *ART_PASTE_get(void) {
20228 PyObject *pyobj = 0;
20229
20230 {
20231 #if wxUSE_UNICODE
20232 pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
20233 #else
20234 pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
20235 #endif
20236 }
20237 return pyobj;
20238 }
20239
20240
20241 SWIGINTERN int ART_DELETE_set(PyObject *) {
20242 SWIG_Error(SWIG_AttributeError,"Variable ART_DELETE is read-only.");
20243 return 1;
20244 }
20245
20246
20247 SWIGINTERN PyObject *ART_DELETE_get(void) {
20248 PyObject *pyobj = 0;
20249
20250 {
20251 #if wxUSE_UNICODE
20252 pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
20253 #else
20254 pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
20255 #endif
20256 }
20257 return pyobj;
20258 }
20259
20260
20261 SWIGINTERN int ART_NEW_set(PyObject *) {
20262 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW is read-only.");
20263 return 1;
20264 }
20265
20266
20267 SWIGINTERN PyObject *ART_NEW_get(void) {
20268 PyObject *pyobj = 0;
20269
20270 {
20271 #if wxUSE_UNICODE
20272 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
20273 #else
20274 pyobj = PyString_FromStringAndSize((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
20275 #endif
20276 }
20277 return pyobj;
20278 }
20279
20280
20281 SWIGINTERN int ART_UNDO_set(PyObject *) {
20282 SWIG_Error(SWIG_AttributeError,"Variable ART_UNDO is read-only.");
20283 return 1;
20284 }
20285
20286
20287 SWIGINTERN PyObject *ART_UNDO_get(void) {
20288 PyObject *pyobj = 0;
20289
20290 {
20291 #if wxUSE_UNICODE
20292 pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
20293 #else
20294 pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
20295 #endif
20296 }
20297 return pyobj;
20298 }
20299
20300
20301 SWIGINTERN int ART_REDO_set(PyObject *) {
20302 SWIG_Error(SWIG_AttributeError,"Variable ART_REDO is read-only.");
20303 return 1;
20304 }
20305
20306
20307 SWIGINTERN PyObject *ART_REDO_get(void) {
20308 PyObject *pyobj = 0;
20309
20310 {
20311 #if wxUSE_UNICODE
20312 pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
20313 #else
20314 pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
20315 #endif
20316 }
20317 return pyobj;
20318 }
20319
20320
20321 SWIGINTERN int ART_QUIT_set(PyObject *) {
20322 SWIG_Error(SWIG_AttributeError,"Variable ART_QUIT is read-only.");
20323 return 1;
20324 }
20325
20326
20327 SWIGINTERN PyObject *ART_QUIT_get(void) {
20328 PyObject *pyobj = 0;
20329
20330 {
20331 #if wxUSE_UNICODE
20332 pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
20333 #else
20334 pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
20335 #endif
20336 }
20337 return pyobj;
20338 }
20339
20340
20341 SWIGINTERN int ART_FIND_set(PyObject *) {
20342 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND is read-only.");
20343 return 1;
20344 }
20345
20346
20347 SWIGINTERN PyObject *ART_FIND_get(void) {
20348 PyObject *pyobj = 0;
20349
20350 {
20351 #if wxUSE_UNICODE
20352 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
20353 #else
20354 pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
20355 #endif
20356 }
20357 return pyobj;
20358 }
20359
20360
20361 SWIGINTERN int ART_FIND_AND_REPLACE_set(PyObject *) {
20362 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND_AND_REPLACE is read-only.");
20363 return 1;
20364 }
20365
20366
20367 SWIGINTERN PyObject *ART_FIND_AND_REPLACE_get(void) {
20368 PyObject *pyobj = 0;
20369
20370 {
20371 #if wxUSE_UNICODE
20372 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
20373 #else
20374 pyobj = PyString_FromStringAndSize((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
20375 #endif
20376 }
20377 return pyobj;
20378 }
20379
20380
20381 SWIGINTERN PyObject *_wrap_new_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20382 PyObject *resultobj = 0;
20383 wxPyArtProvider *result = 0 ;
20384
20385 if (!SWIG_Python_UnpackTuple(args,"new_ArtProvider",0,0,0)) SWIG_fail;
20386 {
20387 if (!wxPyCheckForApp()) SWIG_fail;
20388 PyThreadState* __tstate = wxPyBeginAllowThreads();
20389 result = (wxPyArtProvider *)new wxPyArtProvider();
20390 wxPyEndAllowThreads(__tstate);
20391 if (PyErr_Occurred()) SWIG_fail;
20392 }
20393 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_NEW | 0 );
20394 return resultobj;
20395 fail:
20396 return NULL;
20397 }
20398
20399
20400 SWIGINTERN PyObject *_wrap_delete_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20401 PyObject *resultobj = 0;
20402 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20403 void *argp1 = 0 ;
20404 int res1 = 0 ;
20405 PyObject *swig_obj[1] ;
20406
20407 if (!args) SWIG_fail;
20408 swig_obj[0] = args;
20409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
20410 if (!SWIG_IsOK(res1)) {
20411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArtProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20412 }
20413 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20414 {
20415 PyThreadState* __tstate = wxPyBeginAllowThreads();
20416 delete arg1;
20417
20418 wxPyEndAllowThreads(__tstate);
20419 if (PyErr_Occurred()) SWIG_fail;
20420 }
20421 resultobj = SWIG_Py_Void();
20422 return resultobj;
20423 fail:
20424 return NULL;
20425 }
20426
20427
20428 SWIGINTERN PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20429 PyObject *resultobj = 0;
20430 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20431 PyObject *arg2 = (PyObject *) 0 ;
20432 PyObject *arg3 = (PyObject *) 0 ;
20433 void *argp1 = 0 ;
20434 int res1 = 0 ;
20435 PyObject * obj0 = 0 ;
20436 PyObject * obj1 = 0 ;
20437 PyObject * obj2 = 0 ;
20438 char * kwnames[] = {
20439 (char *) "self",(char *) "self",(char *) "_class", NULL
20440 };
20441
20442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20443 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20444 if (!SWIG_IsOK(res1)) {
20445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20446 }
20447 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20448 arg2 = obj1;
20449 arg3 = obj2;
20450 {
20451 PyThreadState* __tstate = wxPyBeginAllowThreads();
20452 (arg1)->_setCallbackInfo(arg2,arg3);
20453 wxPyEndAllowThreads(__tstate);
20454 if (PyErr_Occurred()) SWIG_fail;
20455 }
20456 resultobj = SWIG_Py_Void();
20457 return resultobj;
20458 fail:
20459 return NULL;
20460 }
20461
20462
20463 SWIGINTERN PyObject *_wrap_ArtProvider_Push(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20464 PyObject *resultobj = 0;
20465 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20466 int res1 = 0 ;
20467 PyObject * obj0 = 0 ;
20468 char * kwnames[] = {
20469 (char *) "provider", NULL
20470 };
20471
20472 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Push",kwnames,&obj0)) SWIG_fail;
20473 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
20474 if (!SWIG_IsOK(res1)) {
20475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Push" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20476 }
20477 {
20478 PyThreadState* __tstate = wxPyBeginAllowThreads();
20479 wxPyArtProvider::Push(arg1);
20480 wxPyEndAllowThreads(__tstate);
20481 if (PyErr_Occurred()) SWIG_fail;
20482 }
20483 resultobj = SWIG_Py_Void();
20484 return resultobj;
20485 fail:
20486 return NULL;
20487 }
20488
20489
20490 SWIGINTERN PyObject *_wrap_ArtProvider_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20491 PyObject *resultobj = 0;
20492 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20493 int res1 = 0 ;
20494 PyObject * obj0 = 0 ;
20495 char * kwnames[] = {
20496 (char *) "provider", NULL
20497 };
20498
20499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Insert",kwnames,&obj0)) SWIG_fail;
20500 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
20501 if (!SWIG_IsOK(res1)) {
20502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Insert" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20503 }
20504 {
20505 PyThreadState* __tstate = wxPyBeginAllowThreads();
20506 wxPyArtProvider::Insert(arg1);
20507 wxPyEndAllowThreads(__tstate);
20508 if (PyErr_Occurred()) SWIG_fail;
20509 }
20510 resultobj = SWIG_Py_Void();
20511 return resultobj;
20512 fail:
20513 return NULL;
20514 }
20515
20516
20517 SWIGINTERN PyObject *_wrap_ArtProvider_Pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20518 PyObject *resultobj = 0;
20519 bool result;
20520
20521 if (!SWIG_Python_UnpackTuple(args,"ArtProvider_Pop",0,0,0)) SWIG_fail;
20522 {
20523 PyThreadState* __tstate = wxPyBeginAllowThreads();
20524 result = (bool)wxPyArtProvider::Pop();
20525 wxPyEndAllowThreads(__tstate);
20526 if (PyErr_Occurred()) SWIG_fail;
20527 }
20528 {
20529 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20530 }
20531 return resultobj;
20532 fail:
20533 return NULL;
20534 }
20535
20536
20537 SWIGINTERN PyObject *_wrap_ArtProvider_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20538 PyObject *resultobj = 0;
20539 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20540 bool result;
20541 void *argp1 = 0 ;
20542 int res1 = 0 ;
20543 PyObject * obj0 = 0 ;
20544 char * kwnames[] = {
20545 (char *) "provider", NULL
20546 };
20547
20548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Delete",kwnames,&obj0)) SWIG_fail;
20549 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20550 if (!SWIG_IsOK(res1)) {
20551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Delete" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20552 }
20553 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20554 {
20555 PyThreadState* __tstate = wxPyBeginAllowThreads();
20556 result = (bool)wxPyArtProvider::Delete(arg1);
20557 wxPyEndAllowThreads(__tstate);
20558 if (PyErr_Occurred()) SWIG_fail;
20559 }
20560 {
20561 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20562 }
20563 return resultobj;
20564 fail:
20565 return NULL;
20566 }
20567
20568
20569 SWIGINTERN PyObject *_wrap_ArtProvider_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20570 PyObject *resultobj = 0;
20571 wxString *arg1 = 0 ;
20572 wxString const &arg2_defvalue = wxPyART_OTHER ;
20573 wxString *arg2 = (wxString *) &arg2_defvalue ;
20574 wxSize const &arg3_defvalue = wxDefaultSize ;
20575 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
20576 wxBitmap result;
20577 bool temp1 = false ;
20578 bool temp2 = false ;
20579 wxSize temp3 ;
20580 PyObject * obj0 = 0 ;
20581 PyObject * obj1 = 0 ;
20582 PyObject * obj2 = 0 ;
20583 char * kwnames[] = {
20584 (char *) "id",(char *) "client",(char *) "size", NULL
20585 };
20586
20587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20588 {
20589 arg1 = wxString_in_helper(obj0);
20590 if (arg1 == NULL) SWIG_fail;
20591 temp1 = true;
20592 }
20593 if (obj1) {
20594 {
20595 arg2 = wxString_in_helper(obj1);
20596 if (arg2 == NULL) SWIG_fail;
20597 temp2 = true;
20598 }
20599 }
20600 if (obj2) {
20601 {
20602 arg3 = &temp3;
20603 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
20604 }
20605 }
20606 {
20607 if (!wxPyCheckForApp()) SWIG_fail;
20608 PyThreadState* __tstate = wxPyBeginAllowThreads();
20609 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
20610 wxPyEndAllowThreads(__tstate);
20611 if (PyErr_Occurred()) SWIG_fail;
20612 }
20613 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
20614 {
20615 if (temp1)
20616 delete arg1;
20617 }
20618 {
20619 if (temp2)
20620 delete arg2;
20621 }
20622 return resultobj;
20623 fail:
20624 {
20625 if (temp1)
20626 delete arg1;
20627 }
20628 {
20629 if (temp2)
20630 delete arg2;
20631 }
20632 return NULL;
20633 }
20634
20635
20636 SWIGINTERN PyObject *_wrap_ArtProvider_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20637 PyObject *resultobj = 0;
20638 wxString *arg1 = 0 ;
20639 wxString const &arg2_defvalue = wxPyART_OTHER ;
20640 wxString *arg2 = (wxString *) &arg2_defvalue ;
20641 wxSize const &arg3_defvalue = wxDefaultSize ;
20642 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
20643 wxIcon result;
20644 bool temp1 = false ;
20645 bool temp2 = false ;
20646 wxSize temp3 ;
20647 PyObject * obj0 = 0 ;
20648 PyObject * obj1 = 0 ;
20649 PyObject * obj2 = 0 ;
20650 char * kwnames[] = {
20651 (char *) "id",(char *) "client",(char *) "size", NULL
20652 };
20653
20654 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20655 {
20656 arg1 = wxString_in_helper(obj0);
20657 if (arg1 == NULL) SWIG_fail;
20658 temp1 = true;
20659 }
20660 if (obj1) {
20661 {
20662 arg2 = wxString_in_helper(obj1);
20663 if (arg2 == NULL) SWIG_fail;
20664 temp2 = true;
20665 }
20666 }
20667 if (obj2) {
20668 {
20669 arg3 = &temp3;
20670 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
20671 }
20672 }
20673 {
20674 if (!wxPyCheckForApp()) SWIG_fail;
20675 PyThreadState* __tstate = wxPyBeginAllowThreads();
20676 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
20677 wxPyEndAllowThreads(__tstate);
20678 if (PyErr_Occurred()) SWIG_fail;
20679 }
20680 resultobj = SWIG_NewPointerObj((new wxIcon(static_cast< const wxIcon& >(result))), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
20681 {
20682 if (temp1)
20683 delete arg1;
20684 }
20685 {
20686 if (temp2)
20687 delete arg2;
20688 }
20689 return resultobj;
20690 fail:
20691 {
20692 if (temp1)
20693 delete arg1;
20694 }
20695 {
20696 if (temp2)
20697 delete arg2;
20698 }
20699 return NULL;
20700 }
20701
20702
20703 SWIGINTERN PyObject *_wrap_ArtProvider_GetSizeHint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20704 PyObject *resultobj = 0;
20705 wxString *arg1 = 0 ;
20706 bool arg2 = (bool) false ;
20707 wxSize result;
20708 bool temp1 = false ;
20709 bool val2 ;
20710 int ecode2 = 0 ;
20711 PyObject * obj0 = 0 ;
20712 PyObject * obj1 = 0 ;
20713 char * kwnames[] = {
20714 (char *) "client",(char *) "platform_dependent", NULL
20715 };
20716
20717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ArtProvider_GetSizeHint",kwnames,&obj0,&obj1)) SWIG_fail;
20718 {
20719 arg1 = wxString_in_helper(obj0);
20720 if (arg1 == NULL) SWIG_fail;
20721 temp1 = true;
20722 }
20723 if (obj1) {
20724 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20725 if (!SWIG_IsOK(ecode2)) {
20726 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ArtProvider_GetSizeHint" "', expected argument " "2"" of type '" "bool""'");
20727 }
20728 arg2 = static_cast< bool >(val2);
20729 }
20730 {
20731 PyThreadState* __tstate = wxPyBeginAllowThreads();
20732 result = wxPyArtProvider::GetSizeHint((wxString const &)*arg1,arg2);
20733 wxPyEndAllowThreads(__tstate);
20734 if (PyErr_Occurred()) SWIG_fail;
20735 }
20736 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
20737 {
20738 if (temp1)
20739 delete arg1;
20740 }
20741 return resultobj;
20742 fail:
20743 {
20744 if (temp1)
20745 delete arg1;
20746 }
20747 return NULL;
20748 }
20749
20750
20751 SWIGINTERN PyObject *_wrap_ArtProvider_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20752 PyObject *resultobj = 0;
20753 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20754 void *argp1 = 0 ;
20755 int res1 = 0 ;
20756 PyObject *swig_obj[1] ;
20757
20758 if (!args) SWIG_fail;
20759 swig_obj[0] = args;
20760 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20761 if (!SWIG_IsOK(res1)) {
20762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Destroy" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20763 }
20764 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20765 {
20766 PyThreadState* __tstate = wxPyBeginAllowThreads();
20767 wxPyArtProvider_Destroy(arg1);
20768 wxPyEndAllowThreads(__tstate);
20769 if (PyErr_Occurred()) SWIG_fail;
20770 }
20771 resultobj = SWIG_Py_Void();
20772 return resultobj;
20773 fail:
20774 return NULL;
20775 }
20776
20777
20778 SWIGINTERN PyObject *ArtProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20779 PyObject *obj;
20780 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20781 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyArtProvider, SWIG_NewClientData(obj));
20782 return SWIG_Py_Void();
20783 }
20784
20785 SWIGINTERN PyObject *ArtProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20786 return SWIG_Python_InitShadowInstance(args);
20787 }
20788
20789 SWIGINTERN PyObject *_wrap_delete_ConfigBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20790 PyObject *resultobj = 0;
20791 wxConfigBase *arg1 = (wxConfigBase *) 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, SWIG_POINTER_DISOWN | 0 );
20799 if (!SWIG_IsOK(res1)) {
20800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigBase" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20801 }
20802 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20803 {
20804 PyThreadState* __tstate = wxPyBeginAllowThreads();
20805 delete arg1;
20806
20807 wxPyEndAllowThreads(__tstate);
20808 if (PyErr_Occurred()) SWIG_fail;
20809 }
20810 resultobj = SWIG_Py_Void();
20811 return resultobj;
20812 fail:
20813 return NULL;
20814 }
20815
20816
20817 SWIGINTERN PyObject *_wrap_ConfigBase_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20818 PyObject *resultobj = 0;
20819 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20820 wxConfigBase *result = 0 ;
20821 int res1 = 0 ;
20822 PyObject * obj0 = 0 ;
20823 char * kwnames[] = {
20824 (char *) "config", NULL
20825 };
20826
20827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) SWIG_fail;
20828 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
20829 if (!SWIG_IsOK(res1)) {
20830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Set" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20831 }
20832 {
20833 PyThreadState* __tstate = wxPyBeginAllowThreads();
20834 result = (wxConfigBase *)wxConfigBase::Set(arg1);
20835 wxPyEndAllowThreads(__tstate);
20836 if (PyErr_Occurred()) SWIG_fail;
20837 }
20838 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
20839 return resultobj;
20840 fail:
20841 return NULL;
20842 }
20843
20844
20845 SWIGINTERN PyObject *_wrap_ConfigBase_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20846 PyObject *resultobj = 0;
20847 bool arg1 = (bool) true ;
20848 wxConfigBase *result = 0 ;
20849 bool val1 ;
20850 int ecode1 = 0 ;
20851 PyObject * obj0 = 0 ;
20852 char * kwnames[] = {
20853 (char *) "createOnDemand", NULL
20854 };
20855
20856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) SWIG_fail;
20857 if (obj0) {
20858 ecode1 = SWIG_AsVal_bool(obj0, &val1);
20859 if (!SWIG_IsOK(ecode1)) {
20860 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ConfigBase_Get" "', expected argument " "1"" of type '" "bool""'");
20861 }
20862 arg1 = static_cast< bool >(val1);
20863 }
20864 {
20865 PyThreadState* __tstate = wxPyBeginAllowThreads();
20866 result = (wxConfigBase *)wxConfigBase::Get(arg1);
20867 wxPyEndAllowThreads(__tstate);
20868 if (PyErr_Occurred()) SWIG_fail;
20869 }
20870 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
20871 return resultobj;
20872 fail:
20873 return NULL;
20874 }
20875
20876
20877 SWIGINTERN PyObject *_wrap_ConfigBase_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20878 PyObject *resultobj = 0;
20879 wxConfigBase *result = 0 ;
20880
20881 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_Create",0,0,0)) SWIG_fail;
20882 {
20883 PyThreadState* __tstate = wxPyBeginAllowThreads();
20884 result = (wxConfigBase *)wxConfigBase::Create();
20885 wxPyEndAllowThreads(__tstate);
20886 if (PyErr_Occurred()) SWIG_fail;
20887 }
20888 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
20889 return resultobj;
20890 fail:
20891 return NULL;
20892 }
20893
20894
20895 SWIGINTERN PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20896 PyObject *resultobj = 0;
20897
20898 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_DontCreateOnDemand",0,0,0)) SWIG_fail;
20899 {
20900 PyThreadState* __tstate = wxPyBeginAllowThreads();
20901 wxConfigBase::DontCreateOnDemand();
20902 wxPyEndAllowThreads(__tstate);
20903 if (PyErr_Occurred()) SWIG_fail;
20904 }
20905 resultobj = SWIG_Py_Void();
20906 return resultobj;
20907 fail:
20908 return NULL;
20909 }
20910
20911
20912 SWIGINTERN PyObject *_wrap_ConfigBase_SetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20913 PyObject *resultobj = 0;
20914 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20915 wxString *arg2 = 0 ;
20916 void *argp1 = 0 ;
20917 int res1 = 0 ;
20918 bool temp2 = false ;
20919 PyObject * obj0 = 0 ;
20920 PyObject * obj1 = 0 ;
20921 char * kwnames[] = {
20922 (char *) "self",(char *) "path", NULL
20923 };
20924
20925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) SWIG_fail;
20926 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20927 if (!SWIG_IsOK(res1)) {
20928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetPath" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20929 }
20930 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20931 {
20932 arg2 = wxString_in_helper(obj1);
20933 if (arg2 == NULL) SWIG_fail;
20934 temp2 = true;
20935 }
20936 {
20937 PyThreadState* __tstate = wxPyBeginAllowThreads();
20938 (arg1)->SetPath((wxString const &)*arg2);
20939 wxPyEndAllowThreads(__tstate);
20940 if (PyErr_Occurred()) SWIG_fail;
20941 }
20942 resultobj = SWIG_Py_Void();
20943 {
20944 if (temp2)
20945 delete arg2;
20946 }
20947 return resultobj;
20948 fail:
20949 {
20950 if (temp2)
20951 delete arg2;
20952 }
20953 return NULL;
20954 }
20955
20956
20957 SWIGINTERN PyObject *_wrap_ConfigBase_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20958 PyObject *resultobj = 0;
20959 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20960 wxString *result = 0 ;
20961 void *argp1 = 0 ;
20962 int res1 = 0 ;
20963 PyObject *swig_obj[1] ;
20964
20965 if (!args) SWIG_fail;
20966 swig_obj[0] = args;
20967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20968 if (!SWIG_IsOK(res1)) {
20969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetPath" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20970 }
20971 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20972 {
20973 PyThreadState* __tstate = wxPyBeginAllowThreads();
20974 {
20975 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
20976 result = (wxString *) &_result_ref;
20977 }
20978 wxPyEndAllowThreads(__tstate);
20979 if (PyErr_Occurred()) SWIG_fail;
20980 }
20981 {
20982 #if wxUSE_UNICODE
20983 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
20984 #else
20985 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
20986 #endif
20987 }
20988 return resultobj;
20989 fail:
20990 return NULL;
20991 }
20992
20993
20994 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20995 PyObject *resultobj = 0;
20996 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20997 PyObject *result = 0 ;
20998 void *argp1 = 0 ;
20999 int res1 = 0 ;
21000 PyObject *swig_obj[1] ;
21001
21002 if (!args) SWIG_fail;
21003 swig_obj[0] = args;
21004 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21005 if (!SWIG_IsOK(res1)) {
21006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21007 }
21008 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21009 {
21010 PyThreadState* __tstate = wxPyBeginAllowThreads();
21011 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
21012 wxPyEndAllowThreads(__tstate);
21013 if (PyErr_Occurred()) SWIG_fail;
21014 }
21015 resultobj = result;
21016 return resultobj;
21017 fail:
21018 return NULL;
21019 }
21020
21021
21022 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21023 PyObject *resultobj = 0;
21024 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21025 long arg2 ;
21026 PyObject *result = 0 ;
21027 void *argp1 = 0 ;
21028 int res1 = 0 ;
21029 long val2 ;
21030 int ecode2 = 0 ;
21031 PyObject * obj0 = 0 ;
21032 PyObject * obj1 = 0 ;
21033 char * kwnames[] = {
21034 (char *) "self",(char *) "index", NULL
21035 };
21036
21037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) SWIG_fail;
21038 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21039 if (!SWIG_IsOK(res1)) {
21040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21041 }
21042 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21043 ecode2 = SWIG_AsVal_long(obj1, &val2);
21044 if (!SWIG_IsOK(ecode2)) {
21045 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "2"" of type '" "long""'");
21046 }
21047 arg2 = static_cast< long >(val2);
21048 {
21049 PyThreadState* __tstate = wxPyBeginAllowThreads();
21050 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
21051 wxPyEndAllowThreads(__tstate);
21052 if (PyErr_Occurred()) SWIG_fail;
21053 }
21054 resultobj = result;
21055 return resultobj;
21056 fail:
21057 return NULL;
21058 }
21059
21060
21061 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21062 PyObject *resultobj = 0;
21063 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21064 PyObject *result = 0 ;
21065 void *argp1 = 0 ;
21066 int res1 = 0 ;
21067 PyObject *swig_obj[1] ;
21068
21069 if (!args) SWIG_fail;
21070 swig_obj[0] = args;
21071 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21072 if (!SWIG_IsOK(res1)) {
21073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21074 }
21075 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21076 {
21077 PyThreadState* __tstate = wxPyBeginAllowThreads();
21078 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
21079 wxPyEndAllowThreads(__tstate);
21080 if (PyErr_Occurred()) SWIG_fail;
21081 }
21082 resultobj = result;
21083 return resultobj;
21084 fail:
21085 return NULL;
21086 }
21087
21088
21089 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21090 PyObject *resultobj = 0;
21091 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21092 long arg2 ;
21093 PyObject *result = 0 ;
21094 void *argp1 = 0 ;
21095 int res1 = 0 ;
21096 long val2 ;
21097 int ecode2 = 0 ;
21098 PyObject * obj0 = 0 ;
21099 PyObject * obj1 = 0 ;
21100 char * kwnames[] = {
21101 (char *) "self",(char *) "index", NULL
21102 };
21103
21104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) SWIG_fail;
21105 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21106 if (!SWIG_IsOK(res1)) {
21107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21108 }
21109 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21110 ecode2 = SWIG_AsVal_long(obj1, &val2);
21111 if (!SWIG_IsOK(ecode2)) {
21112 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "2"" of type '" "long""'");
21113 }
21114 arg2 = static_cast< long >(val2);
21115 {
21116 PyThreadState* __tstate = wxPyBeginAllowThreads();
21117 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
21118 wxPyEndAllowThreads(__tstate);
21119 if (PyErr_Occurred()) SWIG_fail;
21120 }
21121 resultobj = result;
21122 return resultobj;
21123 fail:
21124 return NULL;
21125 }
21126
21127
21128 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21129 PyObject *resultobj = 0;
21130 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21131 bool arg2 = (bool) false ;
21132 size_t result;
21133 void *argp1 = 0 ;
21134 int res1 = 0 ;
21135 bool val2 ;
21136 int ecode2 = 0 ;
21137 PyObject * obj0 = 0 ;
21138 PyObject * obj1 = 0 ;
21139 char * kwnames[] = {
21140 (char *) "self",(char *) "recursive", NULL
21141 };
21142
21143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) SWIG_fail;
21144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21145 if (!SWIG_IsOK(res1)) {
21146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21147 }
21148 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21149 if (obj1) {
21150 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21151 if (!SWIG_IsOK(ecode2)) {
21152 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "2"" of type '" "bool""'");
21153 }
21154 arg2 = static_cast< bool >(val2);
21155 }
21156 {
21157 PyThreadState* __tstate = wxPyBeginAllowThreads();
21158 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
21159 wxPyEndAllowThreads(__tstate);
21160 if (PyErr_Occurred()) SWIG_fail;
21161 }
21162 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
21163 return resultobj;
21164 fail:
21165 return NULL;
21166 }
21167
21168
21169 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21170 PyObject *resultobj = 0;
21171 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21172 bool arg2 = (bool) false ;
21173 size_t result;
21174 void *argp1 = 0 ;
21175 int res1 = 0 ;
21176 bool val2 ;
21177 int ecode2 = 0 ;
21178 PyObject * obj0 = 0 ;
21179 PyObject * obj1 = 0 ;
21180 char * kwnames[] = {
21181 (char *) "self",(char *) "recursive", NULL
21182 };
21183
21184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) SWIG_fail;
21185 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21186 if (!SWIG_IsOK(res1)) {
21187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21188 }
21189 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21190 if (obj1) {
21191 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21192 if (!SWIG_IsOK(ecode2)) {
21193 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "2"" of type '" "bool""'");
21194 }
21195 arg2 = static_cast< bool >(val2);
21196 }
21197 {
21198 PyThreadState* __tstate = wxPyBeginAllowThreads();
21199 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
21200 wxPyEndAllowThreads(__tstate);
21201 if (PyErr_Occurred()) SWIG_fail;
21202 }
21203 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
21204 return resultobj;
21205 fail:
21206 return NULL;
21207 }
21208
21209
21210 SWIGINTERN PyObject *_wrap_ConfigBase_HasGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21211 PyObject *resultobj = 0;
21212 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21213 wxString *arg2 = 0 ;
21214 bool result;
21215 void *argp1 = 0 ;
21216 int res1 = 0 ;
21217 bool temp2 = false ;
21218 PyObject * obj0 = 0 ;
21219 PyObject * obj1 = 0 ;
21220 char * kwnames[] = {
21221 (char *) "self",(char *) "name", NULL
21222 };
21223
21224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) SWIG_fail;
21225 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21226 if (!SWIG_IsOK(res1)) {
21227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasGroup" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21228 }
21229 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21230 {
21231 arg2 = wxString_in_helper(obj1);
21232 if (arg2 == NULL) SWIG_fail;
21233 temp2 = true;
21234 }
21235 {
21236 PyThreadState* __tstate = wxPyBeginAllowThreads();
21237 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
21238 wxPyEndAllowThreads(__tstate);
21239 if (PyErr_Occurred()) SWIG_fail;
21240 }
21241 {
21242 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21243 }
21244 {
21245 if (temp2)
21246 delete arg2;
21247 }
21248 return resultobj;
21249 fail:
21250 {
21251 if (temp2)
21252 delete arg2;
21253 }
21254 return NULL;
21255 }
21256
21257
21258 SWIGINTERN PyObject *_wrap_ConfigBase_HasEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21259 PyObject *resultobj = 0;
21260 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21261 wxString *arg2 = 0 ;
21262 bool result;
21263 void *argp1 = 0 ;
21264 int res1 = 0 ;
21265 bool temp2 = false ;
21266 PyObject * obj0 = 0 ;
21267 PyObject * obj1 = 0 ;
21268 char * kwnames[] = {
21269 (char *) "self",(char *) "name", NULL
21270 };
21271
21272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) SWIG_fail;
21273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21274 if (!SWIG_IsOK(res1)) {
21275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasEntry" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21276 }
21277 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21278 {
21279 arg2 = wxString_in_helper(obj1);
21280 if (arg2 == NULL) SWIG_fail;
21281 temp2 = true;
21282 }
21283 {
21284 PyThreadState* __tstate = wxPyBeginAllowThreads();
21285 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
21286 wxPyEndAllowThreads(__tstate);
21287 if (PyErr_Occurred()) SWIG_fail;
21288 }
21289 {
21290 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21291 }
21292 {
21293 if (temp2)
21294 delete arg2;
21295 }
21296 return resultobj;
21297 fail:
21298 {
21299 if (temp2)
21300 delete arg2;
21301 }
21302 return NULL;
21303 }
21304
21305
21306 SWIGINTERN PyObject *_wrap_ConfigBase_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21307 PyObject *resultobj = 0;
21308 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21309 wxString *arg2 = 0 ;
21310 bool result;
21311 void *argp1 = 0 ;
21312 int res1 = 0 ;
21313 bool temp2 = false ;
21314 PyObject * obj0 = 0 ;
21315 PyObject * obj1 = 0 ;
21316 char * kwnames[] = {
21317 (char *) "self",(char *) "name", NULL
21318 };
21319
21320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) 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_Exists" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
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 {
21332 PyThreadState* __tstate = wxPyBeginAllowThreads();
21333 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
21334 wxPyEndAllowThreads(__tstate);
21335 if (PyErr_Occurred()) SWIG_fail;
21336 }
21337 {
21338 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21339 }
21340 {
21341 if (temp2)
21342 delete arg2;
21343 }
21344 return resultobj;
21345 fail:
21346 {
21347 if (temp2)
21348 delete arg2;
21349 }
21350 return NULL;
21351 }
21352
21353
21354 SWIGINTERN PyObject *_wrap_ConfigBase_GetEntryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21355 PyObject *resultobj = 0;
21356 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21357 wxString *arg2 = 0 ;
21358 wxConfigBase::EntryType result;
21359 void *argp1 = 0 ;
21360 int res1 = 0 ;
21361 bool temp2 = false ;
21362 PyObject * obj0 = 0 ;
21363 PyObject * obj1 = 0 ;
21364 char * kwnames[] = {
21365 (char *) "self",(char *) "name", NULL
21366 };
21367
21368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) SWIG_fail;
21369 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21370 if (!SWIG_IsOK(res1)) {
21371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetEntryType" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21372 }
21373 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21374 {
21375 arg2 = wxString_in_helper(obj1);
21376 if (arg2 == NULL) SWIG_fail;
21377 temp2 = true;
21378 }
21379 {
21380 PyThreadState* __tstate = wxPyBeginAllowThreads();
21381 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
21382 wxPyEndAllowThreads(__tstate);
21383 if (PyErr_Occurred()) SWIG_fail;
21384 }
21385 resultobj = SWIG_From_int(static_cast< int >(result));
21386 {
21387 if (temp2)
21388 delete arg2;
21389 }
21390 return resultobj;
21391 fail:
21392 {
21393 if (temp2)
21394 delete arg2;
21395 }
21396 return NULL;
21397 }
21398
21399
21400 SWIGINTERN PyObject *_wrap_ConfigBase_Read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21401 PyObject *resultobj = 0;
21402 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21403 wxString *arg2 = 0 ;
21404 wxString const &arg3_defvalue = wxPyEmptyString ;
21405 wxString *arg3 = (wxString *) &arg3_defvalue ;
21406 wxString result;
21407 void *argp1 = 0 ;
21408 int res1 = 0 ;
21409 bool temp2 = false ;
21410 bool temp3 = false ;
21411 PyObject * obj0 = 0 ;
21412 PyObject * obj1 = 0 ;
21413 PyObject * obj2 = 0 ;
21414 char * kwnames[] = {
21415 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21416 };
21417
21418 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21419 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21420 if (!SWIG_IsOK(res1)) {
21421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Read" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21422 }
21423 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21424 {
21425 arg2 = wxString_in_helper(obj1);
21426 if (arg2 == NULL) SWIG_fail;
21427 temp2 = true;
21428 }
21429 if (obj2) {
21430 {
21431 arg3 = wxString_in_helper(obj2);
21432 if (arg3 == NULL) SWIG_fail;
21433 temp3 = true;
21434 }
21435 }
21436 {
21437 PyThreadState* __tstate = wxPyBeginAllowThreads();
21438 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
21439 wxPyEndAllowThreads(__tstate);
21440 if (PyErr_Occurred()) SWIG_fail;
21441 }
21442 {
21443 #if wxUSE_UNICODE
21444 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21445 #else
21446 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21447 #endif
21448 }
21449 {
21450 if (temp2)
21451 delete arg2;
21452 }
21453 {
21454 if (temp3)
21455 delete arg3;
21456 }
21457 return resultobj;
21458 fail:
21459 {
21460 if (temp2)
21461 delete arg2;
21462 }
21463 {
21464 if (temp3)
21465 delete arg3;
21466 }
21467 return NULL;
21468 }
21469
21470
21471 SWIGINTERN PyObject *_wrap_ConfigBase_ReadInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21472 PyObject *resultobj = 0;
21473 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21474 wxString *arg2 = 0 ;
21475 long arg3 = (long) 0 ;
21476 long result;
21477 void *argp1 = 0 ;
21478 int res1 = 0 ;
21479 bool temp2 = false ;
21480 long val3 ;
21481 int ecode3 = 0 ;
21482 PyObject * obj0 = 0 ;
21483 PyObject * obj1 = 0 ;
21484 PyObject * obj2 = 0 ;
21485 char * kwnames[] = {
21486 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21487 };
21488
21489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21491 if (!SWIG_IsOK(res1)) {
21492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21493 }
21494 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21495 {
21496 arg2 = wxString_in_helper(obj1);
21497 if (arg2 == NULL) SWIG_fail;
21498 temp2 = true;
21499 }
21500 if (obj2) {
21501 ecode3 = SWIG_AsVal_long(obj2, &val3);
21502 if (!SWIG_IsOK(ecode3)) {
21503 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadInt" "', expected argument " "3"" of type '" "long""'");
21504 }
21505 arg3 = static_cast< long >(val3);
21506 }
21507 {
21508 PyThreadState* __tstate = wxPyBeginAllowThreads();
21509 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
21510 wxPyEndAllowThreads(__tstate);
21511 if (PyErr_Occurred()) SWIG_fail;
21512 }
21513 resultobj = SWIG_From_long(static_cast< long >(result));
21514 {
21515 if (temp2)
21516 delete arg2;
21517 }
21518 return resultobj;
21519 fail:
21520 {
21521 if (temp2)
21522 delete arg2;
21523 }
21524 return NULL;
21525 }
21526
21527
21528 SWIGINTERN PyObject *_wrap_ConfigBase_ReadFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21529 PyObject *resultobj = 0;
21530 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21531 wxString *arg2 = 0 ;
21532 double arg3 = (double) 0.0 ;
21533 double result;
21534 void *argp1 = 0 ;
21535 int res1 = 0 ;
21536 bool temp2 = false ;
21537 double val3 ;
21538 int ecode3 = 0 ;
21539 PyObject * obj0 = 0 ;
21540 PyObject * obj1 = 0 ;
21541 PyObject * obj2 = 0 ;
21542 char * kwnames[] = {
21543 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21544 };
21545
21546 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21547 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21548 if (!SWIG_IsOK(res1)) {
21549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21550 }
21551 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21552 {
21553 arg2 = wxString_in_helper(obj1);
21554 if (arg2 == NULL) SWIG_fail;
21555 temp2 = true;
21556 }
21557 if (obj2) {
21558 ecode3 = SWIG_AsVal_double(obj2, &val3);
21559 if (!SWIG_IsOK(ecode3)) {
21560 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadFloat" "', expected argument " "3"" of type '" "double""'");
21561 }
21562 arg3 = static_cast< double >(val3);
21563 }
21564 {
21565 PyThreadState* __tstate = wxPyBeginAllowThreads();
21566 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
21567 wxPyEndAllowThreads(__tstate);
21568 if (PyErr_Occurred()) SWIG_fail;
21569 }
21570 resultobj = SWIG_From_double(static_cast< double >(result));
21571 {
21572 if (temp2)
21573 delete arg2;
21574 }
21575 return resultobj;
21576 fail:
21577 {
21578 if (temp2)
21579 delete arg2;
21580 }
21581 return NULL;
21582 }
21583
21584
21585 SWIGINTERN PyObject *_wrap_ConfigBase_ReadBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21586 PyObject *resultobj = 0;
21587 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21588 wxString *arg2 = 0 ;
21589 bool arg3 = (bool) false ;
21590 bool result;
21591 void *argp1 = 0 ;
21592 int res1 = 0 ;
21593 bool temp2 = false ;
21594 bool val3 ;
21595 int ecode3 = 0 ;
21596 PyObject * obj0 = 0 ;
21597 PyObject * obj1 = 0 ;
21598 PyObject * obj2 = 0 ;
21599 char * kwnames[] = {
21600 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21601 };
21602
21603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21604 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21605 if (!SWIG_IsOK(res1)) {
21606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21607 }
21608 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21609 {
21610 arg2 = wxString_in_helper(obj1);
21611 if (arg2 == NULL) SWIG_fail;
21612 temp2 = true;
21613 }
21614 if (obj2) {
21615 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21616 if (!SWIG_IsOK(ecode3)) {
21617 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadBool" "', expected argument " "3"" of type '" "bool""'");
21618 }
21619 arg3 = static_cast< bool >(val3);
21620 }
21621 {
21622 PyThreadState* __tstate = wxPyBeginAllowThreads();
21623 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
21624 wxPyEndAllowThreads(__tstate);
21625 if (PyErr_Occurred()) SWIG_fail;
21626 }
21627 {
21628 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21629 }
21630 {
21631 if (temp2)
21632 delete arg2;
21633 }
21634 return resultobj;
21635 fail:
21636 {
21637 if (temp2)
21638 delete arg2;
21639 }
21640 return NULL;
21641 }
21642
21643
21644 SWIGINTERN PyObject *_wrap_ConfigBase_Write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21645 PyObject *resultobj = 0;
21646 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21647 wxString *arg2 = 0 ;
21648 wxString *arg3 = 0 ;
21649 bool result;
21650 void *argp1 = 0 ;
21651 int res1 = 0 ;
21652 bool temp2 = false ;
21653 bool temp3 = false ;
21654 PyObject * obj0 = 0 ;
21655 PyObject * obj1 = 0 ;
21656 PyObject * obj2 = 0 ;
21657 char * kwnames[] = {
21658 (char *) "self",(char *) "key",(char *) "value", NULL
21659 };
21660
21661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21662 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21663 if (!SWIG_IsOK(res1)) {
21664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Write" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21665 }
21666 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21667 {
21668 arg2 = wxString_in_helper(obj1);
21669 if (arg2 == NULL) SWIG_fail;
21670 temp2 = true;
21671 }
21672 {
21673 arg3 = wxString_in_helper(obj2);
21674 if (arg3 == NULL) SWIG_fail;
21675 temp3 = true;
21676 }
21677 {
21678 PyThreadState* __tstate = wxPyBeginAllowThreads();
21679 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
21680 wxPyEndAllowThreads(__tstate);
21681 if (PyErr_Occurred()) SWIG_fail;
21682 }
21683 {
21684 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21685 }
21686 {
21687 if (temp2)
21688 delete arg2;
21689 }
21690 {
21691 if (temp3)
21692 delete arg3;
21693 }
21694 return resultobj;
21695 fail:
21696 {
21697 if (temp2)
21698 delete arg2;
21699 }
21700 {
21701 if (temp3)
21702 delete arg3;
21703 }
21704 return NULL;
21705 }
21706
21707
21708 SWIGINTERN PyObject *_wrap_ConfigBase_WriteInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21709 PyObject *resultobj = 0;
21710 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21711 wxString *arg2 = 0 ;
21712 long arg3 ;
21713 bool result;
21714 void *argp1 = 0 ;
21715 int res1 = 0 ;
21716 bool temp2 = false ;
21717 long val3 ;
21718 int ecode3 = 0 ;
21719 PyObject * obj0 = 0 ;
21720 PyObject * obj1 = 0 ;
21721 PyObject * obj2 = 0 ;
21722 char * kwnames[] = {
21723 (char *) "self",(char *) "key",(char *) "value", NULL
21724 };
21725
21726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21727 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21728 if (!SWIG_IsOK(res1)) {
21729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21730 }
21731 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21732 {
21733 arg2 = wxString_in_helper(obj1);
21734 if (arg2 == NULL) SWIG_fail;
21735 temp2 = true;
21736 }
21737 ecode3 = SWIG_AsVal_long(obj2, &val3);
21738 if (!SWIG_IsOK(ecode3)) {
21739 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteInt" "', expected argument " "3"" of type '" "long""'");
21740 }
21741 arg3 = static_cast< long >(val3);
21742 {
21743 PyThreadState* __tstate = wxPyBeginAllowThreads();
21744 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21745 wxPyEndAllowThreads(__tstate);
21746 if (PyErr_Occurred()) SWIG_fail;
21747 }
21748 {
21749 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21750 }
21751 {
21752 if (temp2)
21753 delete arg2;
21754 }
21755 return resultobj;
21756 fail:
21757 {
21758 if (temp2)
21759 delete arg2;
21760 }
21761 return NULL;
21762 }
21763
21764
21765 SWIGINTERN PyObject *_wrap_ConfigBase_WriteFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21766 PyObject *resultobj = 0;
21767 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21768 wxString *arg2 = 0 ;
21769 double arg3 ;
21770 bool result;
21771 void *argp1 = 0 ;
21772 int res1 = 0 ;
21773 bool temp2 = false ;
21774 double val3 ;
21775 int ecode3 = 0 ;
21776 PyObject * obj0 = 0 ;
21777 PyObject * obj1 = 0 ;
21778 PyObject * obj2 = 0 ;
21779 char * kwnames[] = {
21780 (char *) "self",(char *) "key",(char *) "value", NULL
21781 };
21782
21783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21785 if (!SWIG_IsOK(res1)) {
21786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21787 }
21788 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21789 {
21790 arg2 = wxString_in_helper(obj1);
21791 if (arg2 == NULL) SWIG_fail;
21792 temp2 = true;
21793 }
21794 ecode3 = SWIG_AsVal_double(obj2, &val3);
21795 if (!SWIG_IsOK(ecode3)) {
21796 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteFloat" "', expected argument " "3"" of type '" "double""'");
21797 }
21798 arg3 = static_cast< double >(val3);
21799 {
21800 PyThreadState* __tstate = wxPyBeginAllowThreads();
21801 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21802 wxPyEndAllowThreads(__tstate);
21803 if (PyErr_Occurred()) SWIG_fail;
21804 }
21805 {
21806 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21807 }
21808 {
21809 if (temp2)
21810 delete arg2;
21811 }
21812 return resultobj;
21813 fail:
21814 {
21815 if (temp2)
21816 delete arg2;
21817 }
21818 return NULL;
21819 }
21820
21821
21822 SWIGINTERN PyObject *_wrap_ConfigBase_WriteBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21823 PyObject *resultobj = 0;
21824 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21825 wxString *arg2 = 0 ;
21826 bool arg3 ;
21827 bool result;
21828 void *argp1 = 0 ;
21829 int res1 = 0 ;
21830 bool temp2 = false ;
21831 bool val3 ;
21832 int ecode3 = 0 ;
21833 PyObject * obj0 = 0 ;
21834 PyObject * obj1 = 0 ;
21835 PyObject * obj2 = 0 ;
21836 char * kwnames[] = {
21837 (char *) "self",(char *) "key",(char *) "value", NULL
21838 };
21839
21840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21841 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21842 if (!SWIG_IsOK(res1)) {
21843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21844 }
21845 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21846 {
21847 arg2 = wxString_in_helper(obj1);
21848 if (arg2 == NULL) SWIG_fail;
21849 temp2 = true;
21850 }
21851 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21852 if (!SWIG_IsOK(ecode3)) {
21853 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteBool" "', expected argument " "3"" of type '" "bool""'");
21854 }
21855 arg3 = static_cast< bool >(val3);
21856 {
21857 PyThreadState* __tstate = wxPyBeginAllowThreads();
21858 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21859 wxPyEndAllowThreads(__tstate);
21860 if (PyErr_Occurred()) SWIG_fail;
21861 }
21862 {
21863 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21864 }
21865 {
21866 if (temp2)
21867 delete arg2;
21868 }
21869 return resultobj;
21870 fail:
21871 {
21872 if (temp2)
21873 delete arg2;
21874 }
21875 return NULL;
21876 }
21877
21878
21879 SWIGINTERN PyObject *_wrap_ConfigBase_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21880 PyObject *resultobj = 0;
21881 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21882 bool arg2 = (bool) false ;
21883 bool result;
21884 void *argp1 = 0 ;
21885 int res1 = 0 ;
21886 bool val2 ;
21887 int ecode2 = 0 ;
21888 PyObject * obj0 = 0 ;
21889 PyObject * obj1 = 0 ;
21890 char * kwnames[] = {
21891 (char *) "self",(char *) "currentOnly", NULL
21892 };
21893
21894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) SWIG_fail;
21895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21896 if (!SWIG_IsOK(res1)) {
21897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Flush" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21898 }
21899 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21900 if (obj1) {
21901 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21902 if (!SWIG_IsOK(ecode2)) {
21903 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_Flush" "', expected argument " "2"" of type '" "bool""'");
21904 }
21905 arg2 = static_cast< bool >(val2);
21906 }
21907 {
21908 PyThreadState* __tstate = wxPyBeginAllowThreads();
21909 result = (bool)(arg1)->Flush(arg2);
21910 wxPyEndAllowThreads(__tstate);
21911 if (PyErr_Occurred()) SWIG_fail;
21912 }
21913 {
21914 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21915 }
21916 return resultobj;
21917 fail:
21918 return NULL;
21919 }
21920
21921
21922 SWIGINTERN PyObject *_wrap_ConfigBase_RenameEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21923 PyObject *resultobj = 0;
21924 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21925 wxString *arg2 = 0 ;
21926 wxString *arg3 = 0 ;
21927 bool result;
21928 void *argp1 = 0 ;
21929 int res1 = 0 ;
21930 bool temp2 = false ;
21931 bool temp3 = false ;
21932 PyObject * obj0 = 0 ;
21933 PyObject * obj1 = 0 ;
21934 PyObject * obj2 = 0 ;
21935 char * kwnames[] = {
21936 (char *) "self",(char *) "oldName",(char *) "newName", NULL
21937 };
21938
21939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21940 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21941 if (!SWIG_IsOK(res1)) {
21942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21943 }
21944 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21945 {
21946 arg2 = wxString_in_helper(obj1);
21947 if (arg2 == NULL) SWIG_fail;
21948 temp2 = true;
21949 }
21950 {
21951 arg3 = wxString_in_helper(obj2);
21952 if (arg3 == NULL) SWIG_fail;
21953 temp3 = true;
21954 }
21955 {
21956 PyThreadState* __tstate = wxPyBeginAllowThreads();
21957 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
21958 wxPyEndAllowThreads(__tstate);
21959 if (PyErr_Occurred()) SWIG_fail;
21960 }
21961 {
21962 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21963 }
21964 {
21965 if (temp2)
21966 delete arg2;
21967 }
21968 {
21969 if (temp3)
21970 delete arg3;
21971 }
21972 return resultobj;
21973 fail:
21974 {
21975 if (temp2)
21976 delete arg2;
21977 }
21978 {
21979 if (temp3)
21980 delete arg3;
21981 }
21982 return NULL;
21983 }
21984
21985
21986 SWIGINTERN PyObject *_wrap_ConfigBase_RenameGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21987 PyObject *resultobj = 0;
21988 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21989 wxString *arg2 = 0 ;
21990 wxString *arg3 = 0 ;
21991 bool result;
21992 void *argp1 = 0 ;
21993 int res1 = 0 ;
21994 bool temp2 = false ;
21995 bool temp3 = false ;
21996 PyObject * obj0 = 0 ;
21997 PyObject * obj1 = 0 ;
21998 PyObject * obj2 = 0 ;
21999 char * kwnames[] = {
22000 (char *) "self",(char *) "oldName",(char *) "newName", NULL
22001 };
22002
22003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22005 if (!SWIG_IsOK(res1)) {
22006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22007 }
22008 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22009 {
22010 arg2 = wxString_in_helper(obj1);
22011 if (arg2 == NULL) SWIG_fail;
22012 temp2 = true;
22013 }
22014 {
22015 arg3 = wxString_in_helper(obj2);
22016 if (arg3 == NULL) SWIG_fail;
22017 temp3 = true;
22018 }
22019 {
22020 PyThreadState* __tstate = wxPyBeginAllowThreads();
22021 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
22022 wxPyEndAllowThreads(__tstate);
22023 if (PyErr_Occurred()) SWIG_fail;
22024 }
22025 {
22026 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22027 }
22028 {
22029 if (temp2)
22030 delete arg2;
22031 }
22032 {
22033 if (temp3)
22034 delete arg3;
22035 }
22036 return resultobj;
22037 fail:
22038 {
22039 if (temp2)
22040 delete arg2;
22041 }
22042 {
22043 if (temp3)
22044 delete arg3;
22045 }
22046 return NULL;
22047 }
22048
22049
22050 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22051 PyObject *resultobj = 0;
22052 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22053 wxString *arg2 = 0 ;
22054 bool arg3 = (bool) true ;
22055 bool result;
22056 void *argp1 = 0 ;
22057 int res1 = 0 ;
22058 bool temp2 = false ;
22059 bool val3 ;
22060 int ecode3 = 0 ;
22061 PyObject * obj0 = 0 ;
22062 PyObject * obj1 = 0 ;
22063 PyObject * obj2 = 0 ;
22064 char * kwnames[] = {
22065 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
22066 };
22067
22068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22069 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22070 if (!SWIG_IsOK(res1)) {
22071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22072 }
22073 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22074 {
22075 arg2 = wxString_in_helper(obj1);
22076 if (arg2 == NULL) SWIG_fail;
22077 temp2 = true;
22078 }
22079 if (obj2) {
22080 ecode3 = SWIG_AsVal_bool(obj2, &val3);
22081 if (!SWIG_IsOK(ecode3)) {
22082 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "3"" of type '" "bool""'");
22083 }
22084 arg3 = static_cast< bool >(val3);
22085 }
22086 {
22087 PyThreadState* __tstate = wxPyBeginAllowThreads();
22088 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
22089 wxPyEndAllowThreads(__tstate);
22090 if (PyErr_Occurred()) SWIG_fail;
22091 }
22092 {
22093 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22094 }
22095 {
22096 if (temp2)
22097 delete arg2;
22098 }
22099 return resultobj;
22100 fail:
22101 {
22102 if (temp2)
22103 delete arg2;
22104 }
22105 return NULL;
22106 }
22107
22108
22109 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22110 PyObject *resultobj = 0;
22111 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22112 wxString *arg2 = 0 ;
22113 bool result;
22114 void *argp1 = 0 ;
22115 int res1 = 0 ;
22116 bool temp2 = false ;
22117 PyObject * obj0 = 0 ;
22118 PyObject * obj1 = 0 ;
22119 char * kwnames[] = {
22120 (char *) "self",(char *) "key", NULL
22121 };
22122
22123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) SWIG_fail;
22124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22125 if (!SWIG_IsOK(res1)) {
22126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22127 }
22128 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22129 {
22130 arg2 = wxString_in_helper(obj1);
22131 if (arg2 == NULL) SWIG_fail;
22132 temp2 = true;
22133 }
22134 {
22135 PyThreadState* __tstate = wxPyBeginAllowThreads();
22136 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
22137 wxPyEndAllowThreads(__tstate);
22138 if (PyErr_Occurred()) SWIG_fail;
22139 }
22140 {
22141 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22142 }
22143 {
22144 if (temp2)
22145 delete arg2;
22146 }
22147 return resultobj;
22148 fail:
22149 {
22150 if (temp2)
22151 delete arg2;
22152 }
22153 return NULL;
22154 }
22155
22156
22157 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22158 PyObject *resultobj = 0;
22159 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22160 bool result;
22161 void *argp1 = 0 ;
22162 int res1 = 0 ;
22163 PyObject *swig_obj[1] ;
22164
22165 if (!args) SWIG_fail;
22166 swig_obj[0] = args;
22167 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22168 if (!SWIG_IsOK(res1)) {
22169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteAll" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22170 }
22171 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22172 {
22173 PyThreadState* __tstate = wxPyBeginAllowThreads();
22174 result = (bool)(arg1)->DeleteAll();
22175 wxPyEndAllowThreads(__tstate);
22176 if (PyErr_Occurred()) SWIG_fail;
22177 }
22178 {
22179 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22180 }
22181 return resultobj;
22182 fail:
22183 return NULL;
22184 }
22185
22186
22187 SWIGINTERN PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22188 PyObject *resultobj = 0;
22189 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22190 bool arg2 = (bool) true ;
22191 void *argp1 = 0 ;
22192 int res1 = 0 ;
22193 bool val2 ;
22194 int ecode2 = 0 ;
22195 PyObject * obj0 = 0 ;
22196 PyObject * obj1 = 0 ;
22197 char * kwnames[] = {
22198 (char *) "self",(char *) "doIt", NULL
22199 };
22200
22201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
22202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22203 if (!SWIG_IsOK(res1)) {
22204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22205 }
22206 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22207 if (obj1) {
22208 ecode2 = SWIG_AsVal_bool(obj1, &val2);
22209 if (!SWIG_IsOK(ecode2)) {
22210 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "2"" of type '" "bool""'");
22211 }
22212 arg2 = static_cast< bool >(val2);
22213 }
22214 {
22215 PyThreadState* __tstate = wxPyBeginAllowThreads();
22216 (arg1)->SetExpandEnvVars(arg2);
22217 wxPyEndAllowThreads(__tstate);
22218 if (PyErr_Occurred()) SWIG_fail;
22219 }
22220 resultobj = SWIG_Py_Void();
22221 return resultobj;
22222 fail:
22223 return NULL;
22224 }
22225
22226
22227 SWIGINTERN PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22228 PyObject *resultobj = 0;
22229 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22230 bool result;
22231 void *argp1 = 0 ;
22232 int res1 = 0 ;
22233 PyObject *swig_obj[1] ;
22234
22235 if (!args) SWIG_fail;
22236 swig_obj[0] = args;
22237 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22238 if (!SWIG_IsOK(res1)) {
22239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsExpandingEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22240 }
22241 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22242 {
22243 PyThreadState* __tstate = wxPyBeginAllowThreads();
22244 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
22245 wxPyEndAllowThreads(__tstate);
22246 if (PyErr_Occurred()) SWIG_fail;
22247 }
22248 {
22249 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22250 }
22251 return resultobj;
22252 fail:
22253 return NULL;
22254 }
22255
22256
22257 SWIGINTERN PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22258 PyObject *resultobj = 0;
22259 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22260 bool arg2 = (bool) true ;
22261 void *argp1 = 0 ;
22262 int res1 = 0 ;
22263 bool val2 ;
22264 int ecode2 = 0 ;
22265 PyObject * obj0 = 0 ;
22266 PyObject * obj1 = 0 ;
22267 char * kwnames[] = {
22268 (char *) "self",(char *) "doIt", NULL
22269 };
22270
22271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
22272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22273 if (!SWIG_IsOK(res1)) {
22274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22275 }
22276 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22277 if (obj1) {
22278 ecode2 = SWIG_AsVal_bool(obj1, &val2);
22279 if (!SWIG_IsOK(ecode2)) {
22280 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "2"" of type '" "bool""'");
22281 }
22282 arg2 = static_cast< bool >(val2);
22283 }
22284 {
22285 PyThreadState* __tstate = wxPyBeginAllowThreads();
22286 (arg1)->SetRecordDefaults(arg2);
22287 wxPyEndAllowThreads(__tstate);
22288 if (PyErr_Occurred()) SWIG_fail;
22289 }
22290 resultobj = SWIG_Py_Void();
22291 return resultobj;
22292 fail:
22293 return NULL;
22294 }
22295
22296
22297 SWIGINTERN PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22298 PyObject *resultobj = 0;
22299 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22300 bool result;
22301 void *argp1 = 0 ;
22302 int res1 = 0 ;
22303 PyObject *swig_obj[1] ;
22304
22305 if (!args) SWIG_fail;
22306 swig_obj[0] = args;
22307 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22308 if (!SWIG_IsOK(res1)) {
22309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsRecordingDefaults" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22310 }
22311 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22312 {
22313 PyThreadState* __tstate = wxPyBeginAllowThreads();
22314 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
22315 wxPyEndAllowThreads(__tstate);
22316 if (PyErr_Occurred()) SWIG_fail;
22317 }
22318 {
22319 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22320 }
22321 return resultobj;
22322 fail:
22323 return NULL;
22324 }
22325
22326
22327 SWIGINTERN PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22328 PyObject *resultobj = 0;
22329 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22330 wxString *arg2 = 0 ;
22331 wxString result;
22332 void *argp1 = 0 ;
22333 int res1 = 0 ;
22334 bool temp2 = false ;
22335 PyObject * obj0 = 0 ;
22336 PyObject * obj1 = 0 ;
22337 char * kwnames[] = {
22338 (char *) "self",(char *) "str", NULL
22339 };
22340
22341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
22342 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22343 if (!SWIG_IsOK(res1)) {
22344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22345 }
22346 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22347 {
22348 arg2 = wxString_in_helper(obj1);
22349 if (arg2 == NULL) SWIG_fail;
22350 temp2 = true;
22351 }
22352 {
22353 PyThreadState* __tstate = wxPyBeginAllowThreads();
22354 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
22355 wxPyEndAllowThreads(__tstate);
22356 if (PyErr_Occurred()) SWIG_fail;
22357 }
22358 {
22359 #if wxUSE_UNICODE
22360 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22361 #else
22362 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22363 #endif
22364 }
22365 {
22366 if (temp2)
22367 delete arg2;
22368 }
22369 return resultobj;
22370 fail:
22371 {
22372 if (temp2)
22373 delete arg2;
22374 }
22375 return NULL;
22376 }
22377
22378
22379 SWIGINTERN PyObject *_wrap_ConfigBase_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22380 PyObject *resultobj = 0;
22381 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22382 wxString result;
22383 void *argp1 = 0 ;
22384 int res1 = 0 ;
22385 PyObject *swig_obj[1] ;
22386
22387 if (!args) SWIG_fail;
22388 swig_obj[0] = args;
22389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22390 if (!SWIG_IsOK(res1)) {
22391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetAppName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22392 }
22393 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22394 {
22395 PyThreadState* __tstate = wxPyBeginAllowThreads();
22396 result = ((wxConfigBase const *)arg1)->GetAppName();
22397 wxPyEndAllowThreads(__tstate);
22398 if (PyErr_Occurred()) SWIG_fail;
22399 }
22400 {
22401 #if wxUSE_UNICODE
22402 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22403 #else
22404 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22405 #endif
22406 }
22407 return resultobj;
22408 fail:
22409 return NULL;
22410 }
22411
22412
22413 SWIGINTERN PyObject *_wrap_ConfigBase_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22414 PyObject *resultobj = 0;
22415 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22416 wxString result;
22417 void *argp1 = 0 ;
22418 int res1 = 0 ;
22419 PyObject *swig_obj[1] ;
22420
22421 if (!args) SWIG_fail;
22422 swig_obj[0] = args;
22423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22424 if (!SWIG_IsOK(res1)) {
22425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetVendorName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22426 }
22427 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22428 {
22429 PyThreadState* __tstate = wxPyBeginAllowThreads();
22430 result = ((wxConfigBase const *)arg1)->GetVendorName();
22431 wxPyEndAllowThreads(__tstate);
22432 if (PyErr_Occurred()) SWIG_fail;
22433 }
22434 {
22435 #if wxUSE_UNICODE
22436 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22437 #else
22438 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22439 #endif
22440 }
22441 return resultobj;
22442 fail:
22443 return NULL;
22444 }
22445
22446
22447 SWIGINTERN PyObject *_wrap_ConfigBase_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22448 PyObject *resultobj = 0;
22449 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22450 wxString *arg2 = 0 ;
22451 void *argp1 = 0 ;
22452 int res1 = 0 ;
22453 bool temp2 = false ;
22454 PyObject * obj0 = 0 ;
22455 PyObject * obj1 = 0 ;
22456 char * kwnames[] = {
22457 (char *) "self",(char *) "appName", NULL
22458 };
22459
22460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
22461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22462 if (!SWIG_IsOK(res1)) {
22463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetAppName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22464 }
22465 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22466 {
22467 arg2 = wxString_in_helper(obj1);
22468 if (arg2 == NULL) SWIG_fail;
22469 temp2 = true;
22470 }
22471 {
22472 PyThreadState* __tstate = wxPyBeginAllowThreads();
22473 (arg1)->SetAppName((wxString const &)*arg2);
22474 wxPyEndAllowThreads(__tstate);
22475 if (PyErr_Occurred()) SWIG_fail;
22476 }
22477 resultobj = SWIG_Py_Void();
22478 {
22479 if (temp2)
22480 delete arg2;
22481 }
22482 return resultobj;
22483 fail:
22484 {
22485 if (temp2)
22486 delete arg2;
22487 }
22488 return NULL;
22489 }
22490
22491
22492 SWIGINTERN PyObject *_wrap_ConfigBase_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22493 PyObject *resultobj = 0;
22494 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22495 wxString *arg2 = 0 ;
22496 void *argp1 = 0 ;
22497 int res1 = 0 ;
22498 bool temp2 = false ;
22499 PyObject * obj0 = 0 ;
22500 PyObject * obj1 = 0 ;
22501 char * kwnames[] = {
22502 (char *) "self",(char *) "vendorName", NULL
22503 };
22504
22505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
22506 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22507 if (!SWIG_IsOK(res1)) {
22508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetVendorName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22509 }
22510 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22511 {
22512 arg2 = wxString_in_helper(obj1);
22513 if (arg2 == NULL) SWIG_fail;
22514 temp2 = true;
22515 }
22516 {
22517 PyThreadState* __tstate = wxPyBeginAllowThreads();
22518 (arg1)->SetVendorName((wxString const &)*arg2);
22519 wxPyEndAllowThreads(__tstate);
22520 if (PyErr_Occurred()) SWIG_fail;
22521 }
22522 resultobj = SWIG_Py_Void();
22523 {
22524 if (temp2)
22525 delete arg2;
22526 }
22527 return resultobj;
22528 fail:
22529 {
22530 if (temp2)
22531 delete arg2;
22532 }
22533 return NULL;
22534 }
22535
22536
22537 SWIGINTERN PyObject *_wrap_ConfigBase_SetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22538 PyObject *resultobj = 0;
22539 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22540 long arg2 ;
22541 void *argp1 = 0 ;
22542 int res1 = 0 ;
22543 long val2 ;
22544 int ecode2 = 0 ;
22545 PyObject * obj0 = 0 ;
22546 PyObject * obj1 = 0 ;
22547 char * kwnames[] = {
22548 (char *) "self",(char *) "style", NULL
22549 };
22550
22551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) SWIG_fail;
22552 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22553 if (!SWIG_IsOK(res1)) {
22554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetStyle" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22555 }
22556 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22557 ecode2 = SWIG_AsVal_long(obj1, &val2);
22558 if (!SWIG_IsOK(ecode2)) {
22559 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetStyle" "', expected argument " "2"" of type '" "long""'");
22560 }
22561 arg2 = static_cast< long >(val2);
22562 {
22563 PyThreadState* __tstate = wxPyBeginAllowThreads();
22564 (arg1)->SetStyle(arg2);
22565 wxPyEndAllowThreads(__tstate);
22566 if (PyErr_Occurred()) SWIG_fail;
22567 }
22568 resultobj = SWIG_Py_Void();
22569 return resultobj;
22570 fail:
22571 return NULL;
22572 }
22573
22574
22575 SWIGINTERN PyObject *_wrap_ConfigBase_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22576 PyObject *resultobj = 0;
22577 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22578 long result;
22579 void *argp1 = 0 ;
22580 int res1 = 0 ;
22581 PyObject *swig_obj[1] ;
22582
22583 if (!args) SWIG_fail;
22584 swig_obj[0] = args;
22585 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22586 if (!SWIG_IsOK(res1)) {
22587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetStyle" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22588 }
22589 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22590 {
22591 PyThreadState* __tstate = wxPyBeginAllowThreads();
22592 result = (long)((wxConfigBase const *)arg1)->GetStyle();
22593 wxPyEndAllowThreads(__tstate);
22594 if (PyErr_Occurred()) SWIG_fail;
22595 }
22596 resultobj = SWIG_From_long(static_cast< long >(result));
22597 return resultobj;
22598 fail:
22599 return NULL;
22600 }
22601
22602
22603 SWIGINTERN PyObject *ConfigBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22604 PyObject *obj;
22605 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22606 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigBase, SWIG_NewClientData(obj));
22607 return SWIG_Py_Void();
22608 }
22609
22610 SWIGINTERN PyObject *_wrap_new_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22611 PyObject *resultobj = 0;
22612 wxString const &arg1_defvalue = wxPyEmptyString ;
22613 wxString *arg1 = (wxString *) &arg1_defvalue ;
22614 wxString const &arg2_defvalue = wxPyEmptyString ;
22615 wxString *arg2 = (wxString *) &arg2_defvalue ;
22616 wxString const &arg3_defvalue = wxPyEmptyString ;
22617 wxString *arg3 = (wxString *) &arg3_defvalue ;
22618 wxString const &arg4_defvalue = wxPyEmptyString ;
22619 wxString *arg4 = (wxString *) &arg4_defvalue ;
22620 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
22621 wxConfig *result = 0 ;
22622 bool temp1 = false ;
22623 bool temp2 = false ;
22624 bool temp3 = false ;
22625 bool temp4 = false ;
22626 long val5 ;
22627 int ecode5 = 0 ;
22628 PyObject * obj0 = 0 ;
22629 PyObject * obj1 = 0 ;
22630 PyObject * obj2 = 0 ;
22631 PyObject * obj3 = 0 ;
22632 PyObject * obj4 = 0 ;
22633 char * kwnames[] = {
22634 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
22635 };
22636
22637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
22638 if (obj0) {
22639 {
22640 arg1 = wxString_in_helper(obj0);
22641 if (arg1 == NULL) SWIG_fail;
22642 temp1 = true;
22643 }
22644 }
22645 if (obj1) {
22646 {
22647 arg2 = wxString_in_helper(obj1);
22648 if (arg2 == NULL) SWIG_fail;
22649 temp2 = true;
22650 }
22651 }
22652 if (obj2) {
22653 {
22654 arg3 = wxString_in_helper(obj2);
22655 if (arg3 == NULL) SWIG_fail;
22656 temp3 = true;
22657 }
22658 }
22659 if (obj3) {
22660 {
22661 arg4 = wxString_in_helper(obj3);
22662 if (arg4 == NULL) SWIG_fail;
22663 temp4 = true;
22664 }
22665 }
22666 if (obj4) {
22667 ecode5 = SWIG_AsVal_long(obj4, &val5);
22668 if (!SWIG_IsOK(ecode5)) {
22669 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Config" "', expected argument " "5"" of type '" "long""'");
22670 }
22671 arg5 = static_cast< long >(val5);
22672 }
22673 {
22674 PyThreadState* __tstate = wxPyBeginAllowThreads();
22675 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
22676 wxPyEndAllowThreads(__tstate);
22677 if (PyErr_Occurred()) SWIG_fail;
22678 }
22679 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfig, SWIG_POINTER_NEW | 0 );
22680 {
22681 if (temp1)
22682 delete arg1;
22683 }
22684 {
22685 if (temp2)
22686 delete arg2;
22687 }
22688 {
22689 if (temp3)
22690 delete arg3;
22691 }
22692 {
22693 if (temp4)
22694 delete arg4;
22695 }
22696 return resultobj;
22697 fail:
22698 {
22699 if (temp1)
22700 delete arg1;
22701 }
22702 {
22703 if (temp2)
22704 delete arg2;
22705 }
22706 {
22707 if (temp3)
22708 delete arg3;
22709 }
22710 {
22711 if (temp4)
22712 delete arg4;
22713 }
22714 return NULL;
22715 }
22716
22717
22718 SWIGINTERN PyObject *_wrap_delete_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22719 PyObject *resultobj = 0;
22720 wxConfig *arg1 = (wxConfig *) 0 ;
22721 void *argp1 = 0 ;
22722 int res1 = 0 ;
22723 PyObject *swig_obj[1] ;
22724
22725 if (!args) SWIG_fail;
22726 swig_obj[0] = args;
22727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfig, SWIG_POINTER_DISOWN | 0 );
22728 if (!SWIG_IsOK(res1)) {
22729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Config" "', expected argument " "1"" of type '" "wxConfig *""'");
22730 }
22731 arg1 = reinterpret_cast< wxConfig * >(argp1);
22732 {
22733 PyThreadState* __tstate = wxPyBeginAllowThreads();
22734 delete arg1;
22735
22736 wxPyEndAllowThreads(__tstate);
22737 if (PyErr_Occurred()) SWIG_fail;
22738 }
22739 resultobj = SWIG_Py_Void();
22740 return resultobj;
22741 fail:
22742 return NULL;
22743 }
22744
22745
22746 SWIGINTERN PyObject *Config_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22747 PyObject *obj;
22748 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22749 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfig, SWIG_NewClientData(obj));
22750 return SWIG_Py_Void();
22751 }
22752
22753 SWIGINTERN PyObject *Config_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22754 return SWIG_Python_InitShadowInstance(args);
22755 }
22756
22757 SWIGINTERN PyObject *_wrap_new_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22758 PyObject *resultobj = 0;
22759 wxString const &arg1_defvalue = wxPyEmptyString ;
22760 wxString *arg1 = (wxString *) &arg1_defvalue ;
22761 wxString const &arg2_defvalue = wxPyEmptyString ;
22762 wxString *arg2 = (wxString *) &arg2_defvalue ;
22763 wxString const &arg3_defvalue = wxPyEmptyString ;
22764 wxString *arg3 = (wxString *) &arg3_defvalue ;
22765 wxString const &arg4_defvalue = wxPyEmptyString ;
22766 wxString *arg4 = (wxString *) &arg4_defvalue ;
22767 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
22768 wxFileConfig *result = 0 ;
22769 bool temp1 = false ;
22770 bool temp2 = false ;
22771 bool temp3 = false ;
22772 bool temp4 = false ;
22773 long val5 ;
22774 int ecode5 = 0 ;
22775 PyObject * obj0 = 0 ;
22776 PyObject * obj1 = 0 ;
22777 PyObject * obj2 = 0 ;
22778 PyObject * obj3 = 0 ;
22779 PyObject * obj4 = 0 ;
22780 char * kwnames[] = {
22781 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
22782 };
22783
22784 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
22785 if (obj0) {
22786 {
22787 arg1 = wxString_in_helper(obj0);
22788 if (arg1 == NULL) SWIG_fail;
22789 temp1 = true;
22790 }
22791 }
22792 if (obj1) {
22793 {
22794 arg2 = wxString_in_helper(obj1);
22795 if (arg2 == NULL) SWIG_fail;
22796 temp2 = true;
22797 }
22798 }
22799 if (obj2) {
22800 {
22801 arg3 = wxString_in_helper(obj2);
22802 if (arg3 == NULL) SWIG_fail;
22803 temp3 = true;
22804 }
22805 }
22806 if (obj3) {
22807 {
22808 arg4 = wxString_in_helper(obj3);
22809 if (arg4 == NULL) SWIG_fail;
22810 temp4 = true;
22811 }
22812 }
22813 if (obj4) {
22814 ecode5 = SWIG_AsVal_long(obj4, &val5);
22815 if (!SWIG_IsOK(ecode5)) {
22816 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FileConfig" "', expected argument " "5"" of type '" "long""'");
22817 }
22818 arg5 = static_cast< long >(val5);
22819 }
22820 {
22821 PyThreadState* __tstate = wxPyBeginAllowThreads();
22822 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
22823 wxPyEndAllowThreads(__tstate);
22824 if (PyErr_Occurred()) SWIG_fail;
22825 }
22826 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileConfig, SWIG_POINTER_NEW | 0 );
22827 {
22828 if (temp1)
22829 delete arg1;
22830 }
22831 {
22832 if (temp2)
22833 delete arg2;
22834 }
22835 {
22836 if (temp3)
22837 delete arg3;
22838 }
22839 {
22840 if (temp4)
22841 delete arg4;
22842 }
22843 return resultobj;
22844 fail:
22845 {
22846 if (temp1)
22847 delete arg1;
22848 }
22849 {
22850 if (temp2)
22851 delete arg2;
22852 }
22853 {
22854 if (temp3)
22855 delete arg3;
22856 }
22857 {
22858 if (temp4)
22859 delete arg4;
22860 }
22861 return NULL;
22862 }
22863
22864
22865 SWIGINTERN PyObject *_wrap_delete_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22866 PyObject *resultobj = 0;
22867 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
22868 void *argp1 = 0 ;
22869 int res1 = 0 ;
22870 PyObject *swig_obj[1] ;
22871
22872 if (!args) SWIG_fail;
22873 swig_obj[0] = args;
22874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileConfig, SWIG_POINTER_DISOWN | 0 );
22875 if (!SWIG_IsOK(res1)) {
22876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileConfig" "', expected argument " "1"" of type '" "wxFileConfig *""'");
22877 }
22878 arg1 = reinterpret_cast< wxFileConfig * >(argp1);
22879 {
22880 PyThreadState* __tstate = wxPyBeginAllowThreads();
22881 delete arg1;
22882
22883 wxPyEndAllowThreads(__tstate);
22884 if (PyErr_Occurred()) SWIG_fail;
22885 }
22886 resultobj = SWIG_Py_Void();
22887 return resultobj;
22888 fail:
22889 return NULL;
22890 }
22891
22892
22893 SWIGINTERN PyObject *FileConfig_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22894 PyObject *obj;
22895 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22896 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileConfig, SWIG_NewClientData(obj));
22897 return SWIG_Py_Void();
22898 }
22899
22900 SWIGINTERN PyObject *FileConfig_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22901 return SWIG_Python_InitShadowInstance(args);
22902 }
22903
22904 SWIGINTERN PyObject *_wrap_new_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22905 PyObject *resultobj = 0;
22906 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22907 wxString *arg2 = 0 ;
22908 wxConfigPathChanger *result = 0 ;
22909 void *argp1 = 0 ;
22910 int res1 = 0 ;
22911 bool temp2 = false ;
22912 PyObject * obj0 = 0 ;
22913 PyObject * obj1 = 0 ;
22914 char * kwnames[] = {
22915 (char *) "config",(char *) "entry", NULL
22916 };
22917
22918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) SWIG_fail;
22919 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22920 if (!SWIG_IsOK(res1)) {
22921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22922 }
22923 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22924 {
22925 arg2 = wxString_in_helper(obj1);
22926 if (arg2 == NULL) SWIG_fail;
22927 temp2 = true;
22928 }
22929 {
22930 PyThreadState* __tstate = wxPyBeginAllowThreads();
22931 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
22932 wxPyEndAllowThreads(__tstate);
22933 if (PyErr_Occurred()) SWIG_fail;
22934 }
22935 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_NEW | 0 );
22936 {
22937 if (temp2)
22938 delete arg2;
22939 }
22940 return resultobj;
22941 fail:
22942 {
22943 if (temp2)
22944 delete arg2;
22945 }
22946 return NULL;
22947 }
22948
22949
22950 SWIGINTERN PyObject *_wrap_delete_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22951 PyObject *resultobj = 0;
22952 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
22953 void *argp1 = 0 ;
22954 int res1 = 0 ;
22955 PyObject *swig_obj[1] ;
22956
22957 if (!args) SWIG_fail;
22958 swig_obj[0] = args;
22959 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_DISOWN | 0 );
22960 if (!SWIG_IsOK(res1)) {
22961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigPathChanger *""'");
22962 }
22963 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
22964 {
22965 PyThreadState* __tstate = wxPyBeginAllowThreads();
22966 delete arg1;
22967
22968 wxPyEndAllowThreads(__tstate);
22969 if (PyErr_Occurred()) SWIG_fail;
22970 }
22971 resultobj = SWIG_Py_Void();
22972 return resultobj;
22973 fail:
22974 return NULL;
22975 }
22976
22977
22978 SWIGINTERN PyObject *_wrap_ConfigPathChanger_Name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22979 PyObject *resultobj = 0;
22980 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
22981 wxString *result = 0 ;
22982 void *argp1 = 0 ;
22983 int res1 = 0 ;
22984 PyObject *swig_obj[1] ;
22985
22986 if (!args) SWIG_fail;
22987 swig_obj[0] = args;
22988 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, 0 | 0 );
22989 if (!SWIG_IsOK(res1)) {
22990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigPathChanger_Name" "', expected argument " "1"" of type '" "wxConfigPathChanger const *""'");
22991 }
22992 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
22993 {
22994 PyThreadState* __tstate = wxPyBeginAllowThreads();
22995 {
22996 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
22997 result = (wxString *) &_result_ref;
22998 }
22999 wxPyEndAllowThreads(__tstate);
23000 if (PyErr_Occurred()) SWIG_fail;
23001 }
23002 {
23003 #if wxUSE_UNICODE
23004 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
23005 #else
23006 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
23007 #endif
23008 }
23009 return resultobj;
23010 fail:
23011 return NULL;
23012 }
23013
23014
23015 SWIGINTERN PyObject *ConfigPathChanger_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23016 PyObject *obj;
23017 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23018 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigPathChanger, SWIG_NewClientData(obj));
23019 return SWIG_Py_Void();
23020 }
23021
23022 SWIGINTERN PyObject *ConfigPathChanger_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23023 return SWIG_Python_InitShadowInstance(args);
23024 }
23025
23026 SWIGINTERN PyObject *_wrap_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23027 PyObject *resultobj = 0;
23028 wxString *arg1 = 0 ;
23029 wxString result;
23030 bool temp1 = false ;
23031 PyObject * obj0 = 0 ;
23032 char * kwnames[] = {
23033 (char *) "sz", NULL
23034 };
23035
23036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) SWIG_fail;
23037 {
23038 arg1 = wxString_in_helper(obj0);
23039 if (arg1 == NULL) SWIG_fail;
23040 temp1 = true;
23041 }
23042 {
23043 PyThreadState* __tstate = wxPyBeginAllowThreads();
23044 result = wxExpandEnvVars((wxString const &)*arg1);
23045 wxPyEndAllowThreads(__tstate);
23046 if (PyErr_Occurred()) SWIG_fail;
23047 }
23048 {
23049 #if wxUSE_UNICODE
23050 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23051 #else
23052 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23053 #endif
23054 }
23055 {
23056 if (temp1)
23057 delete arg1;
23058 }
23059 return resultobj;
23060 fail:
23061 {
23062 if (temp1)
23063 delete arg1;
23064 }
23065 return NULL;
23066 }
23067
23068
23069 SWIGINTERN int DefaultDateTimeFormat_set(PyObject *) {
23070 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTimeFormat is read-only.");
23071 return 1;
23072 }
23073
23074
23075 SWIGINTERN PyObject *DefaultDateTimeFormat_get(void) {
23076 PyObject *pyobj = 0;
23077
23078 {
23079 #if wxUSE_UNICODE
23080 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
23081 #else
23082 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
23083 #endif
23084 }
23085 return pyobj;
23086 }
23087
23088
23089 SWIGINTERN int DefaultTimeSpanFormat_set(PyObject *) {
23090 SWIG_Error(SWIG_AttributeError,"Variable DefaultTimeSpanFormat is read-only.");
23091 return 1;
23092 }
23093
23094
23095 SWIGINTERN PyObject *DefaultTimeSpanFormat_get(void) {
23096 PyObject *pyobj = 0;
23097
23098 {
23099 #if wxUSE_UNICODE
23100 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
23101 #else
23102 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
23103 #endif
23104 }
23105 return pyobj;
23106 }
23107
23108
23109 SWIGINTERN PyObject *_wrap_DateTime_SetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23110 PyObject *resultobj = 0;
23111 wxDateTime::Country arg1 ;
23112 int val1 ;
23113 int ecode1 = 0 ;
23114 PyObject * obj0 = 0 ;
23115 char * kwnames[] = {
23116 (char *) "country", NULL
23117 };
23118
23119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) SWIG_fail;
23120 ecode1 = SWIG_AsVal_int(obj0, &val1);
23121 if (!SWIG_IsOK(ecode1)) {
23122 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
23123 }
23124 arg1 = static_cast< wxDateTime::Country >(val1);
23125 {
23126 PyThreadState* __tstate = wxPyBeginAllowThreads();
23127 wxDateTime::SetCountry(arg1);
23128 wxPyEndAllowThreads(__tstate);
23129 if (PyErr_Occurred()) SWIG_fail;
23130 }
23131 resultobj = SWIG_Py_Void();
23132 return resultobj;
23133 fail:
23134 return NULL;
23135 }
23136
23137
23138 SWIGINTERN PyObject *_wrap_DateTime_GetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23139 PyObject *resultobj = 0;
23140 wxDateTime::Country result;
23141
23142 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetCountry",0,0,0)) SWIG_fail;
23143 {
23144 PyThreadState* __tstate = wxPyBeginAllowThreads();
23145 result = (wxDateTime::Country)wxDateTime::GetCountry();
23146 wxPyEndAllowThreads(__tstate);
23147 if (PyErr_Occurred()) SWIG_fail;
23148 }
23149 resultobj = SWIG_From_int(static_cast< int >(result));
23150 return resultobj;
23151 fail:
23152 return NULL;
23153 }
23154
23155
23156 SWIGINTERN PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23157 PyObject *resultobj = 0;
23158 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
23159 bool result;
23160 int val1 ;
23161 int ecode1 = 0 ;
23162 PyObject * obj0 = 0 ;
23163 char * kwnames[] = {
23164 (char *) "country", NULL
23165 };
23166
23167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) SWIG_fail;
23168 if (obj0) {
23169 ecode1 = SWIG_AsVal_int(obj0, &val1);
23170 if (!SWIG_IsOK(ecode1)) {
23171 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsWestEuropeanCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
23172 }
23173 arg1 = static_cast< wxDateTime::Country >(val1);
23174 }
23175 {
23176 PyThreadState* __tstate = wxPyBeginAllowThreads();
23177 result = (bool)wxDateTime::IsWestEuropeanCountry(arg1);
23178 wxPyEndAllowThreads(__tstate);
23179 if (PyErr_Occurred()) SWIG_fail;
23180 }
23181 {
23182 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23183 }
23184 return resultobj;
23185 fail:
23186 return NULL;
23187 }
23188
23189
23190 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23191 PyObject *resultobj = 0;
23192 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23193 int result;
23194 int val1 ;
23195 int ecode1 = 0 ;
23196 PyObject * obj0 = 0 ;
23197 char * kwnames[] = {
23198 (char *) "cal", NULL
23199 };
23200
23201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) SWIG_fail;
23202 if (obj0) {
23203 ecode1 = SWIG_AsVal_int(obj0, &val1);
23204 if (!SWIG_IsOK(ecode1)) {
23205 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentYear" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
23206 }
23207 arg1 = static_cast< wxDateTime::Calendar >(val1);
23208 }
23209 {
23210 PyThreadState* __tstate = wxPyBeginAllowThreads();
23211 result = (int)wxDateTime::GetCurrentYear(arg1);
23212 wxPyEndAllowThreads(__tstate);
23213 if (PyErr_Occurred()) SWIG_fail;
23214 }
23215 resultobj = SWIG_From_int(static_cast< int >(result));
23216 return resultobj;
23217 fail:
23218 return NULL;
23219 }
23220
23221
23222 SWIGINTERN PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23223 PyObject *resultobj = 0;
23224 int arg1 ;
23225 int result;
23226 int val1 ;
23227 int ecode1 = 0 ;
23228 PyObject * obj0 = 0 ;
23229 char * kwnames[] = {
23230 (char *) "year", NULL
23231 };
23232
23233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) SWIG_fail;
23234 ecode1 = SWIG_AsVal_int(obj0, &val1);
23235 if (!SWIG_IsOK(ecode1)) {
23236 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_ConvertYearToBC" "', expected argument " "1"" of type '" "int""'");
23237 }
23238 arg1 = static_cast< int >(val1);
23239 {
23240 PyThreadState* __tstate = wxPyBeginAllowThreads();
23241 result = (int)wxDateTime::ConvertYearToBC(arg1);
23242 wxPyEndAllowThreads(__tstate);
23243 if (PyErr_Occurred()) SWIG_fail;
23244 }
23245 resultobj = SWIG_From_int(static_cast< int >(result));
23246 return resultobj;
23247 fail:
23248 return NULL;
23249 }
23250
23251
23252 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23253 PyObject *resultobj = 0;
23254 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23255 wxDateTime::Month result;
23256 int val1 ;
23257 int ecode1 = 0 ;
23258 PyObject * obj0 = 0 ;
23259 char * kwnames[] = {
23260 (char *) "cal", NULL
23261 };
23262
23263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) SWIG_fail;
23264 if (obj0) {
23265 ecode1 = SWIG_AsVal_int(obj0, &val1);
23266 if (!SWIG_IsOK(ecode1)) {
23267 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentMonth" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
23268 }
23269 arg1 = static_cast< wxDateTime::Calendar >(val1);
23270 }
23271 {
23272 PyThreadState* __tstate = wxPyBeginAllowThreads();
23273 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth(arg1);
23274 wxPyEndAllowThreads(__tstate);
23275 if (PyErr_Occurred()) SWIG_fail;
23276 }
23277 resultobj = SWIG_From_int(static_cast< int >(result));
23278 return resultobj;
23279 fail:
23280 return NULL;
23281 }
23282
23283
23284 SWIGINTERN PyObject *_wrap_DateTime_IsLeapYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23285 PyObject *resultobj = 0;
23286 int arg1 = (int) wxDateTime::Inv_Year ;
23287 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23288 bool result;
23289 int val1 ;
23290 int ecode1 = 0 ;
23291 int val2 ;
23292 int ecode2 = 0 ;
23293 PyObject * obj0 = 0 ;
23294 PyObject * obj1 = 0 ;
23295 char * kwnames[] = {
23296 (char *) "year",(char *) "cal", NULL
23297 };
23298
23299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) SWIG_fail;
23300 if (obj0) {
23301 ecode1 = SWIG_AsVal_int(obj0, &val1);
23302 if (!SWIG_IsOK(ecode1)) {
23303 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsLeapYear" "', expected argument " "1"" of type '" "int""'");
23304 }
23305 arg1 = static_cast< int >(val1);
23306 }
23307 if (obj1) {
23308 ecode2 = SWIG_AsVal_int(obj1, &val2);
23309 if (!SWIG_IsOK(ecode2)) {
23310 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsLeapYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
23311 }
23312 arg2 = static_cast< wxDateTime::Calendar >(val2);
23313 }
23314 {
23315 PyThreadState* __tstate = wxPyBeginAllowThreads();
23316 result = (bool)wxDateTime::IsLeapYear(arg1,arg2);
23317 wxPyEndAllowThreads(__tstate);
23318 if (PyErr_Occurred()) SWIG_fail;
23319 }
23320 {
23321 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23322 }
23323 return resultobj;
23324 fail:
23325 return NULL;
23326 }
23327
23328
23329 SWIGINTERN PyObject *_wrap_DateTime_GetCentury(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23330 PyObject *resultobj = 0;
23331 int arg1 = (int) wxDateTime::Inv_Year ;
23332 int result;
23333 int val1 ;
23334 int ecode1 = 0 ;
23335 PyObject * obj0 = 0 ;
23336 char * kwnames[] = {
23337 (char *) "year", NULL
23338 };
23339
23340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) SWIG_fail;
23341 if (obj0) {
23342 ecode1 = SWIG_AsVal_int(obj0, &val1);
23343 if (!SWIG_IsOK(ecode1)) {
23344 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCentury" "', expected argument " "1"" of type '" "int""'");
23345 }
23346 arg1 = static_cast< int >(val1);
23347 }
23348 {
23349 PyThreadState* __tstate = wxPyBeginAllowThreads();
23350 result = (int)wxDateTime::GetCentury(arg1);
23351 wxPyEndAllowThreads(__tstate);
23352 if (PyErr_Occurred()) SWIG_fail;
23353 }
23354 resultobj = SWIG_From_int(static_cast< int >(result));
23355 return resultobj;
23356 fail:
23357 return NULL;
23358 }
23359
23360
23361 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23362 PyObject *resultobj = 0;
23363 int arg1 ;
23364 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23365 int result;
23366 int val1 ;
23367 int ecode1 = 0 ;
23368 int val2 ;
23369 int ecode2 = 0 ;
23370 PyObject * obj0 = 0 ;
23371 PyObject * obj1 = 0 ;
23372 char * kwnames[] = {
23373 (char *) "year",(char *) "cal", NULL
23374 };
23375
23376 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) SWIG_fail;
23377 ecode1 = SWIG_AsVal_int(obj0, &val1);
23378 if (!SWIG_IsOK(ecode1)) {
23379 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "1"" of type '" "int""'");
23380 }
23381 arg1 = static_cast< int >(val1);
23382 if (obj1) {
23383 ecode2 = SWIG_AsVal_int(obj1, &val2);
23384 if (!SWIG_IsOK(ecode2)) {
23385 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
23386 }
23387 arg2 = static_cast< wxDateTime::Calendar >(val2);
23388 }
23389 {
23390 PyThreadState* __tstate = wxPyBeginAllowThreads();
23391 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2);
23392 wxPyEndAllowThreads(__tstate);
23393 if (PyErr_Occurred()) SWIG_fail;
23394 }
23395 resultobj = SWIG_From_int(static_cast< int >(result));
23396 return resultobj;
23397 fail:
23398 return NULL;
23399 }
23400
23401
23402 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23403 PyObject *resultobj = 0;
23404 wxDateTime::Month arg1 ;
23405 int arg2 = (int) wxDateTime::Inv_Year ;
23406 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23407 int result;
23408 int val1 ;
23409 int ecode1 = 0 ;
23410 int val2 ;
23411 int ecode2 = 0 ;
23412 int val3 ;
23413 int ecode3 = 0 ;
23414 PyObject * obj0 = 0 ;
23415 PyObject * obj1 = 0 ;
23416 PyObject * obj2 = 0 ;
23417 char * kwnames[] = {
23418 (char *) "month",(char *) "year",(char *) "cal", NULL
23419 };
23420
23421 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23422 ecode1 = SWIG_AsVal_int(obj0, &val1);
23423 if (!SWIG_IsOK(ecode1)) {
23424 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
23425 }
23426 arg1 = static_cast< wxDateTime::Month >(val1);
23427 if (obj1) {
23428 ecode2 = SWIG_AsVal_int(obj1, &val2);
23429 if (!SWIG_IsOK(ecode2)) {
23430 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "2"" of type '" "int""'");
23431 }
23432 arg2 = static_cast< int >(val2);
23433 }
23434 if (obj2) {
23435 ecode3 = SWIG_AsVal_int(obj2, &val3);
23436 if (!SWIG_IsOK(ecode3)) {
23437 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "3"" of type '" "wxDateTime::Calendar""'");
23438 }
23439 arg3 = static_cast< wxDateTime::Calendar >(val3);
23440 }
23441 {
23442 PyThreadState* __tstate = wxPyBeginAllowThreads();
23443 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2,arg3);
23444 wxPyEndAllowThreads(__tstate);
23445 if (PyErr_Occurred()) SWIG_fail;
23446 }
23447 resultobj = SWIG_From_int(static_cast< int >(result));
23448 return resultobj;
23449 fail:
23450 return NULL;
23451 }
23452
23453
23454 SWIGINTERN PyObject *_wrap_DateTime_GetMonthName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23455 PyObject *resultobj = 0;
23456 wxDateTime::Month arg1 ;
23457 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
23458 wxString result;
23459 int val1 ;
23460 int ecode1 = 0 ;
23461 int val2 ;
23462 int ecode2 = 0 ;
23463 PyObject * obj0 = 0 ;
23464 PyObject * obj1 = 0 ;
23465 char * kwnames[] = {
23466 (char *) "month",(char *) "flags", NULL
23467 };
23468
23469 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) SWIG_fail;
23470 ecode1 = SWIG_AsVal_int(obj0, &val1);
23471 if (!SWIG_IsOK(ecode1)) {
23472 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetMonthName" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
23473 }
23474 arg1 = static_cast< wxDateTime::Month >(val1);
23475 if (obj1) {
23476 ecode2 = SWIG_AsVal_int(obj1, &val2);
23477 if (!SWIG_IsOK(ecode2)) {
23478 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetMonthName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
23479 }
23480 arg2 = static_cast< wxDateTime::NameFlags >(val2);
23481 }
23482 {
23483 PyThreadState* __tstate = wxPyBeginAllowThreads();
23484 result = wxDateTime::GetMonthName(arg1,arg2);
23485 wxPyEndAllowThreads(__tstate);
23486 if (PyErr_Occurred()) SWIG_fail;
23487 }
23488 {
23489 #if wxUSE_UNICODE
23490 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23491 #else
23492 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23493 #endif
23494 }
23495 return resultobj;
23496 fail:
23497 return NULL;
23498 }
23499
23500
23501 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23502 PyObject *resultobj = 0;
23503 wxDateTime::WeekDay arg1 ;
23504 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
23505 wxString result;
23506 int val1 ;
23507 int ecode1 = 0 ;
23508 int val2 ;
23509 int ecode2 = 0 ;
23510 PyObject * obj0 = 0 ;
23511 PyObject * obj1 = 0 ;
23512 char * kwnames[] = {
23513 (char *) "weekday",(char *) "flags", NULL
23514 };
23515
23516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) SWIG_fail;
23517 ecode1 = SWIG_AsVal_int(obj0, &val1);
23518 if (!SWIG_IsOK(ecode1)) {
23519 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetWeekDayName" "', expected argument " "1"" of type '" "wxDateTime::WeekDay""'");
23520 }
23521 arg1 = static_cast< wxDateTime::WeekDay >(val1);
23522 if (obj1) {
23523 ecode2 = SWIG_AsVal_int(obj1, &val2);
23524 if (!SWIG_IsOK(ecode2)) {
23525 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
23526 }
23527 arg2 = static_cast< wxDateTime::NameFlags >(val2);
23528 }
23529 {
23530 PyThreadState* __tstate = wxPyBeginAllowThreads();
23531 result = wxDateTime::GetWeekDayName(arg1,arg2);
23532 wxPyEndAllowThreads(__tstate);
23533 if (PyErr_Occurred()) SWIG_fail;
23534 }
23535 {
23536 #if wxUSE_UNICODE
23537 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23538 #else
23539 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23540 #endif
23541 }
23542 return resultobj;
23543 fail:
23544 return NULL;
23545 }
23546
23547
23548 SWIGINTERN PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23549 PyObject *resultobj = 0;
23550 PyObject *result = 0 ;
23551
23552 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetAmPmStrings",0,0,0)) SWIG_fail;
23553 {
23554 PyThreadState* __tstate = wxPyBeginAllowThreads();
23555 result = (PyObject *)wxDateTime_GetAmPmStrings();
23556 wxPyEndAllowThreads(__tstate);
23557 if (PyErr_Occurred()) SWIG_fail;
23558 }
23559 resultobj = result;
23560 return resultobj;
23561 fail:
23562 return NULL;
23563 }
23564
23565
23566 SWIGINTERN PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23567 PyObject *resultobj = 0;
23568 int arg1 = (int) wxDateTime::Inv_Year ;
23569 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23570 bool result;
23571 int val1 ;
23572 int ecode1 = 0 ;
23573 int val2 ;
23574 int ecode2 = 0 ;
23575 PyObject * obj0 = 0 ;
23576 PyObject * obj1 = 0 ;
23577 char * kwnames[] = {
23578 (char *) "year",(char *) "country", NULL
23579 };
23580
23581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) SWIG_fail;
23582 if (obj0) {
23583 ecode1 = SWIG_AsVal_int(obj0, &val1);
23584 if (!SWIG_IsOK(ecode1)) {
23585 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "1"" of type '" "int""'");
23586 }
23587 arg1 = static_cast< int >(val1);
23588 }
23589 if (obj1) {
23590 ecode2 = SWIG_AsVal_int(obj1, &val2);
23591 if (!SWIG_IsOK(ecode2)) {
23592 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23593 }
23594 arg2 = static_cast< wxDateTime::Country >(val2);
23595 }
23596 {
23597 PyThreadState* __tstate = wxPyBeginAllowThreads();
23598 result = (bool)wxDateTime::IsDSTApplicable(arg1,arg2);
23599 wxPyEndAllowThreads(__tstate);
23600 if (PyErr_Occurred()) SWIG_fail;
23601 }
23602 {
23603 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23604 }
23605 return resultobj;
23606 fail:
23607 return NULL;
23608 }
23609
23610
23611 SWIGINTERN PyObject *_wrap_DateTime_GetBeginDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23612 PyObject *resultobj = 0;
23613 int arg1 = (int) wxDateTime::Inv_Year ;
23614 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23615 wxDateTime result;
23616 int val1 ;
23617 int ecode1 = 0 ;
23618 int val2 ;
23619 int ecode2 = 0 ;
23620 PyObject * obj0 = 0 ;
23621 PyObject * obj1 = 0 ;
23622 char * kwnames[] = {
23623 (char *) "year",(char *) "country", NULL
23624 };
23625
23626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) SWIG_fail;
23627 if (obj0) {
23628 ecode1 = SWIG_AsVal_int(obj0, &val1);
23629 if (!SWIG_IsOK(ecode1)) {
23630 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetBeginDST" "', expected argument " "1"" of type '" "int""'");
23631 }
23632 arg1 = static_cast< int >(val1);
23633 }
23634 if (obj1) {
23635 ecode2 = SWIG_AsVal_int(obj1, &val2);
23636 if (!SWIG_IsOK(ecode2)) {
23637 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetBeginDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23638 }
23639 arg2 = static_cast< wxDateTime::Country >(val2);
23640 }
23641 {
23642 PyThreadState* __tstate = wxPyBeginAllowThreads();
23643 result = wxDateTime::GetBeginDST(arg1,arg2);
23644 wxPyEndAllowThreads(__tstate);
23645 if (PyErr_Occurred()) SWIG_fail;
23646 }
23647 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23648 return resultobj;
23649 fail:
23650 return NULL;
23651 }
23652
23653
23654 SWIGINTERN PyObject *_wrap_DateTime_GetEndDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23655 PyObject *resultobj = 0;
23656 int arg1 = (int) wxDateTime::Inv_Year ;
23657 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23658 wxDateTime result;
23659 int val1 ;
23660 int ecode1 = 0 ;
23661 int val2 ;
23662 int ecode2 = 0 ;
23663 PyObject * obj0 = 0 ;
23664 PyObject * obj1 = 0 ;
23665 char * kwnames[] = {
23666 (char *) "year",(char *) "country", NULL
23667 };
23668
23669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) SWIG_fail;
23670 if (obj0) {
23671 ecode1 = SWIG_AsVal_int(obj0, &val1);
23672 if (!SWIG_IsOK(ecode1)) {
23673 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetEndDST" "', expected argument " "1"" of type '" "int""'");
23674 }
23675 arg1 = static_cast< int >(val1);
23676 }
23677 if (obj1) {
23678 ecode2 = SWIG_AsVal_int(obj1, &val2);
23679 if (!SWIG_IsOK(ecode2)) {
23680 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetEndDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23681 }
23682 arg2 = static_cast< wxDateTime::Country >(val2);
23683 }
23684 {
23685 PyThreadState* __tstate = wxPyBeginAllowThreads();
23686 result = wxDateTime::GetEndDST(arg1,arg2);
23687 wxPyEndAllowThreads(__tstate);
23688 if (PyErr_Occurred()) SWIG_fail;
23689 }
23690 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23691 return resultobj;
23692 fail:
23693 return NULL;
23694 }
23695
23696
23697 SWIGINTERN PyObject *_wrap_DateTime_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23698 PyObject *resultobj = 0;
23699 wxDateTime result;
23700
23701 if (!SWIG_Python_UnpackTuple(args,"DateTime_Now",0,0,0)) SWIG_fail;
23702 {
23703 PyThreadState* __tstate = wxPyBeginAllowThreads();
23704 result = wxDateTime::Now();
23705 wxPyEndAllowThreads(__tstate);
23706 if (PyErr_Occurred()) SWIG_fail;
23707 }
23708 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23709 return resultobj;
23710 fail:
23711 return NULL;
23712 }
23713
23714
23715 SWIGINTERN PyObject *_wrap_DateTime_UNow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23716 PyObject *resultobj = 0;
23717 wxDateTime result;
23718
23719 if (!SWIG_Python_UnpackTuple(args,"DateTime_UNow",0,0,0)) SWIG_fail;
23720 {
23721 PyThreadState* __tstate = wxPyBeginAllowThreads();
23722 result = wxDateTime::UNow();
23723 wxPyEndAllowThreads(__tstate);
23724 if (PyErr_Occurred()) SWIG_fail;
23725 }
23726 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23727 return resultobj;
23728 fail:
23729 return NULL;
23730 }
23731
23732
23733 SWIGINTERN PyObject *_wrap_DateTime_Today(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23734 PyObject *resultobj = 0;
23735 wxDateTime result;
23736
23737 if (!SWIG_Python_UnpackTuple(args,"DateTime_Today",0,0,0)) SWIG_fail;
23738 {
23739 PyThreadState* __tstate = wxPyBeginAllowThreads();
23740 result = wxDateTime::Today();
23741 wxPyEndAllowThreads(__tstate);
23742 if (PyErr_Occurred()) SWIG_fail;
23743 }
23744 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23745 return resultobj;
23746 fail:
23747 return NULL;
23748 }
23749
23750
23751 SWIGINTERN PyObject *_wrap_new_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23752 PyObject *resultobj = 0;
23753 wxDateTime *result = 0 ;
23754
23755 if (!SWIG_Python_UnpackTuple(args,"new_DateTime",0,0,0)) SWIG_fail;
23756 {
23757 PyThreadState* __tstate = wxPyBeginAllowThreads();
23758 result = (wxDateTime *)new wxDateTime();
23759 wxPyEndAllowThreads(__tstate);
23760 if (PyErr_Occurred()) SWIG_fail;
23761 }
23762 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_NEW | 0 );
23763 return resultobj;
23764 fail:
23765 return NULL;
23766 }
23767
23768
23769 SWIGINTERN PyObject *_wrap_new_DateTimeFromTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23770 PyObject *resultobj = 0;
23771 time_t arg1 ;
23772 wxDateTime *result = 0 ;
23773 unsigned int val1 ;
23774 int ecode1 = 0 ;
23775 PyObject * obj0 = 0 ;
23776 char * kwnames[] = {
23777 (char *) "timet", NULL
23778 };
23779
23780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) SWIG_fail;
23781 ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
23782 if (!SWIG_IsOK(ecode1)) {
23783 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromTimeT" "', expected argument " "1"" of type '" "time_t""'");
23784 }
23785 arg1 = static_cast< time_t >(val1);
23786 {
23787 PyThreadState* __tstate = wxPyBeginAllowThreads();
23788 result = (wxDateTime *)new wxDateTime(arg1);
23789 wxPyEndAllowThreads(__tstate);
23790 if (PyErr_Occurred()) SWIG_fail;
23791 }
23792 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23793 return resultobj;
23794 fail:
23795 return NULL;
23796 }
23797
23798
23799 SWIGINTERN PyObject *_wrap_new_DateTimeFromJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23800 PyObject *resultobj = 0;
23801 double arg1 ;
23802 wxDateTime *result = 0 ;
23803 double val1 ;
23804 int ecode1 = 0 ;
23805 PyObject * obj0 = 0 ;
23806 char * kwnames[] = {
23807 (char *) "jdn", NULL
23808 };
23809
23810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) SWIG_fail;
23811 ecode1 = SWIG_AsVal_double(obj0, &val1);
23812 if (!SWIG_IsOK(ecode1)) {
23813 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromJDN" "', expected argument " "1"" of type '" "double""'");
23814 }
23815 arg1 = static_cast< double >(val1);
23816 {
23817 PyThreadState* __tstate = wxPyBeginAllowThreads();
23818 result = (wxDateTime *)new wxDateTime(arg1);
23819 wxPyEndAllowThreads(__tstate);
23820 if (PyErr_Occurred()) SWIG_fail;
23821 }
23822 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23823 return resultobj;
23824 fail:
23825 return NULL;
23826 }
23827
23828
23829 SWIGINTERN PyObject *_wrap_new_DateTimeFromHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23830 PyObject *resultobj = 0;
23831 int arg1 ;
23832 int arg2 = (int) 0 ;
23833 int arg3 = (int) 0 ;
23834 int arg4 = (int) 0 ;
23835 wxDateTime *result = 0 ;
23836 int val1 ;
23837 int ecode1 = 0 ;
23838 int val2 ;
23839 int ecode2 = 0 ;
23840 int val3 ;
23841 int ecode3 = 0 ;
23842 int val4 ;
23843 int ecode4 = 0 ;
23844 PyObject * obj0 = 0 ;
23845 PyObject * obj1 = 0 ;
23846 PyObject * obj2 = 0 ;
23847 PyObject * obj3 = 0 ;
23848 char * kwnames[] = {
23849 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
23850 };
23851
23852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23853 ecode1 = SWIG_AsVal_int(obj0, &val1);
23854 if (!SWIG_IsOK(ecode1)) {
23855 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromHMS" "', expected argument " "1"" of type '" "int""'");
23856 }
23857 arg1 = static_cast< int >(val1);
23858 if (obj1) {
23859 ecode2 = SWIG_AsVal_int(obj1, &val2);
23860 if (!SWIG_IsOK(ecode2)) {
23861 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromHMS" "', expected argument " "2"" of type '" "int""'");
23862 }
23863 arg2 = static_cast< int >(val2);
23864 }
23865 if (obj2) {
23866 ecode3 = SWIG_AsVal_int(obj2, &val3);
23867 if (!SWIG_IsOK(ecode3)) {
23868 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromHMS" "', expected argument " "3"" of type '" "int""'");
23869 }
23870 arg3 = static_cast< int >(val3);
23871 }
23872 if (obj3) {
23873 ecode4 = SWIG_AsVal_int(obj3, &val4);
23874 if (!SWIG_IsOK(ecode4)) {
23875 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromHMS" "', expected argument " "4"" of type '" "int""'");
23876 }
23877 arg4 = static_cast< int >(val4);
23878 }
23879 {
23880 PyThreadState* __tstate = wxPyBeginAllowThreads();
23881 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
23882 wxPyEndAllowThreads(__tstate);
23883 if (PyErr_Occurred()) SWIG_fail;
23884 }
23885 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23886 return resultobj;
23887 fail:
23888 return NULL;
23889 }
23890
23891
23892 SWIGINTERN PyObject *_wrap_new_DateTimeFromDMY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23893 PyObject *resultobj = 0;
23894 int arg1 ;
23895 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23896 int arg3 = (int) wxDateTime::Inv_Year ;
23897 int arg4 = (int) 0 ;
23898 int arg5 = (int) 0 ;
23899 int arg6 = (int) 0 ;
23900 int arg7 = (int) 0 ;
23901 wxDateTime *result = 0 ;
23902 int val1 ;
23903 int ecode1 = 0 ;
23904 int val2 ;
23905 int ecode2 = 0 ;
23906 int val3 ;
23907 int ecode3 = 0 ;
23908 int val4 ;
23909 int ecode4 = 0 ;
23910 int val5 ;
23911 int ecode5 = 0 ;
23912 int val6 ;
23913 int ecode6 = 0 ;
23914 int val7 ;
23915 int ecode7 = 0 ;
23916 PyObject * obj0 = 0 ;
23917 PyObject * obj1 = 0 ;
23918 PyObject * obj2 = 0 ;
23919 PyObject * obj3 = 0 ;
23920 PyObject * obj4 = 0 ;
23921 PyObject * obj5 = 0 ;
23922 PyObject * obj6 = 0 ;
23923 char * kwnames[] = {
23924 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
23925 };
23926
23927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
23928 ecode1 = SWIG_AsVal_int(obj0, &val1);
23929 if (!SWIG_IsOK(ecode1)) {
23930 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromDMY" "', expected argument " "1"" of type '" "int""'");
23931 }
23932 arg1 = static_cast< int >(val1);
23933 if (obj1) {
23934 ecode2 = SWIG_AsVal_int(obj1, &val2);
23935 if (!SWIG_IsOK(ecode2)) {
23936 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromDMY" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
23937 }
23938 arg2 = static_cast< wxDateTime::Month >(val2);
23939 }
23940 if (obj2) {
23941 ecode3 = SWIG_AsVal_int(obj2, &val3);
23942 if (!SWIG_IsOK(ecode3)) {
23943 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromDMY" "', expected argument " "3"" of type '" "int""'");
23944 }
23945 arg3 = static_cast< int >(val3);
23946 }
23947 if (obj3) {
23948 ecode4 = SWIG_AsVal_int(obj3, &val4);
23949 if (!SWIG_IsOK(ecode4)) {
23950 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromDMY" "', expected argument " "4"" of type '" "int""'");
23951 }
23952 arg4 = static_cast< int >(val4);
23953 }
23954 if (obj4) {
23955 ecode5 = SWIG_AsVal_int(obj4, &val5);
23956 if (!SWIG_IsOK(ecode5)) {
23957 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DateTimeFromDMY" "', expected argument " "5"" of type '" "int""'");
23958 }
23959 arg5 = static_cast< int >(val5);
23960 }
23961 if (obj5) {
23962 ecode6 = SWIG_AsVal_int(obj5, &val6);
23963 if (!SWIG_IsOK(ecode6)) {
23964 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DateTimeFromDMY" "', expected argument " "6"" of type '" "int""'");
23965 }
23966 arg6 = static_cast< int >(val6);
23967 }
23968 if (obj6) {
23969 ecode7 = SWIG_AsVal_int(obj6, &val7);
23970 if (!SWIG_IsOK(ecode7)) {
23971 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_DateTimeFromDMY" "', expected argument " "7"" of type '" "int""'");
23972 }
23973 arg7 = static_cast< int >(val7);
23974 }
23975 {
23976 PyThreadState* __tstate = wxPyBeginAllowThreads();
23977 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
23978 wxPyEndAllowThreads(__tstate);
23979 if (PyErr_Occurred()) SWIG_fail;
23980 }
23981 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23982 return resultobj;
23983 fail:
23984 return NULL;
23985 }
23986
23987
23988 SWIGINTERN PyObject *_wrap_new_DateTimeFromDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23989 PyObject *resultobj = 0;
23990 wxDateTime *arg1 = 0 ;
23991 wxDateTime *result = 0 ;
23992 void *argp1 = 0 ;
23993 int res1 = 0 ;
23994 PyObject * obj0 = 0 ;
23995 char * kwnames[] = {
23996 (char *) "date", NULL
23997 };
23998
23999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromDateTime",kwnames,&obj0)) SWIG_fail;
24000 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDateTime, 0 | 0);
24001 if (!SWIG_IsOK(res1)) {
24002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
24003 }
24004 if (!argp1) {
24005 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
24006 }
24007 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24008 {
24009 PyThreadState* __tstate = wxPyBeginAllowThreads();
24010 result = (wxDateTime *)new wxDateTime((wxDateTime const &)*arg1);
24011 wxPyEndAllowThreads(__tstate);
24012 if (PyErr_Occurred()) SWIG_fail;
24013 }
24014 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24015 return resultobj;
24016 fail:
24017 return NULL;
24018 }
24019
24020
24021 SWIGINTERN PyObject *_wrap_delete_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24022 PyObject *resultobj = 0;
24023 wxDateTime *arg1 = (wxDateTime *) 0 ;
24024 void *argp1 = 0 ;
24025 int res1 = 0 ;
24026 PyObject *swig_obj[1] ;
24027
24028 if (!args) SWIG_fail;
24029 swig_obj[0] = args;
24030 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
24031 if (!SWIG_IsOK(res1)) {
24032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
24033 }
24034 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24035 {
24036 PyThreadState* __tstate = wxPyBeginAllowThreads();
24037 delete arg1;
24038
24039 wxPyEndAllowThreads(__tstate);
24040 if (PyErr_Occurred()) SWIG_fail;
24041 }
24042 resultobj = SWIG_Py_Void();
24043 return resultobj;
24044 fail:
24045 return NULL;
24046 }
24047
24048
24049 SWIGINTERN PyObject *_wrap_DateTime_SetToCurrent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24050 PyObject *resultobj = 0;
24051 wxDateTime *arg1 = (wxDateTime *) 0 ;
24052 wxDateTime *result = 0 ;
24053 void *argp1 = 0 ;
24054 int res1 = 0 ;
24055 PyObject *swig_obj[1] ;
24056
24057 if (!args) SWIG_fail;
24058 swig_obj[0] = args;
24059 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24060 if (!SWIG_IsOK(res1)) {
24061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToCurrent" "', expected argument " "1"" of type '" "wxDateTime *""'");
24062 }
24063 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24064 {
24065 PyThreadState* __tstate = wxPyBeginAllowThreads();
24066 {
24067 wxDateTime &_result_ref = (arg1)->SetToCurrent();
24068 result = (wxDateTime *) &_result_ref;
24069 }
24070 wxPyEndAllowThreads(__tstate);
24071 if (PyErr_Occurred()) SWIG_fail;
24072 }
24073 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24074 return resultobj;
24075 fail:
24076 return NULL;
24077 }
24078
24079
24080 SWIGINTERN PyObject *_wrap_DateTime_SetTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24081 PyObject *resultobj = 0;
24082 wxDateTime *arg1 = (wxDateTime *) 0 ;
24083 time_t arg2 ;
24084 wxDateTime *result = 0 ;
24085 void *argp1 = 0 ;
24086 int res1 = 0 ;
24087 unsigned int val2 ;
24088 int ecode2 = 0 ;
24089 PyObject * obj0 = 0 ;
24090 PyObject * obj1 = 0 ;
24091 char * kwnames[] = {
24092 (char *) "self",(char *) "timet", NULL
24093 };
24094
24095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) SWIG_fail;
24096 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24097 if (!SWIG_IsOK(res1)) {
24098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetTimeT" "', expected argument " "1"" of type '" "wxDateTime *""'");
24099 }
24100 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24101 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
24102 if (!SWIG_IsOK(ecode2)) {
24103 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetTimeT" "', expected argument " "2"" of type '" "time_t""'");
24104 }
24105 arg2 = static_cast< time_t >(val2);
24106 {
24107 PyThreadState* __tstate = wxPyBeginAllowThreads();
24108 {
24109 wxDateTime &_result_ref = (arg1)->Set(arg2);
24110 result = (wxDateTime *) &_result_ref;
24111 }
24112 wxPyEndAllowThreads(__tstate);
24113 if (PyErr_Occurred()) SWIG_fail;
24114 }
24115 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24116 return resultobj;
24117 fail:
24118 return NULL;
24119 }
24120
24121
24122 SWIGINTERN PyObject *_wrap_DateTime_SetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24123 PyObject *resultobj = 0;
24124 wxDateTime *arg1 = (wxDateTime *) 0 ;
24125 double arg2 ;
24126 wxDateTime *result = 0 ;
24127 void *argp1 = 0 ;
24128 int res1 = 0 ;
24129 double val2 ;
24130 int ecode2 = 0 ;
24131 PyObject * obj0 = 0 ;
24132 PyObject * obj1 = 0 ;
24133 char * kwnames[] = {
24134 (char *) "self",(char *) "jdn", NULL
24135 };
24136
24137 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) SWIG_fail;
24138 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24139 if (!SWIG_IsOK(res1)) {
24140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
24141 }
24142 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24143 ecode2 = SWIG_AsVal_double(obj1, &val2);
24144 if (!SWIG_IsOK(ecode2)) {
24145 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetJDN" "', expected argument " "2"" of type '" "double""'");
24146 }
24147 arg2 = static_cast< double >(val2);
24148 {
24149 PyThreadState* __tstate = wxPyBeginAllowThreads();
24150 {
24151 wxDateTime &_result_ref = (arg1)->Set(arg2);
24152 result = (wxDateTime *) &_result_ref;
24153 }
24154 wxPyEndAllowThreads(__tstate);
24155 if (PyErr_Occurred()) SWIG_fail;
24156 }
24157 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24158 return resultobj;
24159 fail:
24160 return NULL;
24161 }
24162
24163
24164 SWIGINTERN PyObject *_wrap_DateTime_SetHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24165 PyObject *resultobj = 0;
24166 wxDateTime *arg1 = (wxDateTime *) 0 ;
24167 int arg2 ;
24168 int arg3 = (int) 0 ;
24169 int arg4 = (int) 0 ;
24170 int arg5 = (int) 0 ;
24171 wxDateTime *result = 0 ;
24172 void *argp1 = 0 ;
24173 int res1 = 0 ;
24174 int val2 ;
24175 int ecode2 = 0 ;
24176 int val3 ;
24177 int ecode3 = 0 ;
24178 int val4 ;
24179 int ecode4 = 0 ;
24180 int val5 ;
24181 int ecode5 = 0 ;
24182 PyObject * obj0 = 0 ;
24183 PyObject * obj1 = 0 ;
24184 PyObject * obj2 = 0 ;
24185 PyObject * obj3 = 0 ;
24186 PyObject * obj4 = 0 ;
24187 char * kwnames[] = {
24188 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
24189 };
24190
24191 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
24192 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24193 if (!SWIG_IsOK(res1)) {
24194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHMS" "', expected argument " "1"" of type '" "wxDateTime *""'");
24195 }
24196 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24197 ecode2 = SWIG_AsVal_int(obj1, &val2);
24198 if (!SWIG_IsOK(ecode2)) {
24199 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHMS" "', expected argument " "2"" of type '" "int""'");
24200 }
24201 arg2 = static_cast< int >(val2);
24202 if (obj2) {
24203 ecode3 = SWIG_AsVal_int(obj2, &val3);
24204 if (!SWIG_IsOK(ecode3)) {
24205 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetHMS" "', expected argument " "3"" of type '" "int""'");
24206 }
24207 arg3 = static_cast< int >(val3);
24208 }
24209 if (obj3) {
24210 ecode4 = SWIG_AsVal_int(obj3, &val4);
24211 if (!SWIG_IsOK(ecode4)) {
24212 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetHMS" "', expected argument " "4"" of type '" "int""'");
24213 }
24214 arg4 = static_cast< int >(val4);
24215 }
24216 if (obj4) {
24217 ecode5 = SWIG_AsVal_int(obj4, &val5);
24218 if (!SWIG_IsOK(ecode5)) {
24219 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetHMS" "', expected argument " "5"" of type '" "int""'");
24220 }
24221 arg5 = static_cast< int >(val5);
24222 }
24223 {
24224 PyThreadState* __tstate = wxPyBeginAllowThreads();
24225 {
24226 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
24227 result = (wxDateTime *) &_result_ref;
24228 }
24229 wxPyEndAllowThreads(__tstate);
24230 if (PyErr_Occurred()) SWIG_fail;
24231 }
24232 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24233 return resultobj;
24234 fail:
24235 return NULL;
24236 }
24237
24238
24239 SWIGINTERN PyObject *_wrap_DateTime_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24240 PyObject *resultobj = 0;
24241 wxDateTime *arg1 = (wxDateTime *) 0 ;
24242 int arg2 ;
24243 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24244 int arg4 = (int) wxDateTime::Inv_Year ;
24245 int arg5 = (int) 0 ;
24246 int arg6 = (int) 0 ;
24247 int arg7 = (int) 0 ;
24248 int arg8 = (int) 0 ;
24249 wxDateTime *result = 0 ;
24250 void *argp1 = 0 ;
24251 int res1 = 0 ;
24252 int val2 ;
24253 int ecode2 = 0 ;
24254 int val3 ;
24255 int ecode3 = 0 ;
24256 int val4 ;
24257 int ecode4 = 0 ;
24258 int val5 ;
24259 int ecode5 = 0 ;
24260 int val6 ;
24261 int ecode6 = 0 ;
24262 int val7 ;
24263 int ecode7 = 0 ;
24264 int val8 ;
24265 int ecode8 = 0 ;
24266 PyObject * obj0 = 0 ;
24267 PyObject * obj1 = 0 ;
24268 PyObject * obj2 = 0 ;
24269 PyObject * obj3 = 0 ;
24270 PyObject * obj4 = 0 ;
24271 PyObject * obj5 = 0 ;
24272 PyObject * obj6 = 0 ;
24273 PyObject * obj7 = 0 ;
24274 char * kwnames[] = {
24275 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
24276 };
24277
24278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
24279 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24280 if (!SWIG_IsOK(res1)) {
24281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Set" "', expected argument " "1"" of type '" "wxDateTime *""'");
24282 }
24283 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24284 ecode2 = SWIG_AsVal_int(obj1, &val2);
24285 if (!SWIG_IsOK(ecode2)) {
24286 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_Set" "', expected argument " "2"" of type '" "int""'");
24287 }
24288 arg2 = static_cast< int >(val2);
24289 if (obj2) {
24290 ecode3 = SWIG_AsVal_int(obj2, &val3);
24291 if (!SWIG_IsOK(ecode3)) {
24292 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_Set" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
24293 }
24294 arg3 = static_cast< wxDateTime::Month >(val3);
24295 }
24296 if (obj3) {
24297 ecode4 = SWIG_AsVal_int(obj3, &val4);
24298 if (!SWIG_IsOK(ecode4)) {
24299 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_Set" "', expected argument " "4"" of type '" "int""'");
24300 }
24301 arg4 = static_cast< int >(val4);
24302 }
24303 if (obj4) {
24304 ecode5 = SWIG_AsVal_int(obj4, &val5);
24305 if (!SWIG_IsOK(ecode5)) {
24306 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_Set" "', expected argument " "5"" of type '" "int""'");
24307 }
24308 arg5 = static_cast< int >(val5);
24309 }
24310 if (obj5) {
24311 ecode6 = SWIG_AsVal_int(obj5, &val6);
24312 if (!SWIG_IsOK(ecode6)) {
24313 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DateTime_Set" "', expected argument " "6"" of type '" "int""'");
24314 }
24315 arg6 = static_cast< int >(val6);
24316 }
24317 if (obj6) {
24318 ecode7 = SWIG_AsVal_int(obj6, &val7);
24319 if (!SWIG_IsOK(ecode7)) {
24320 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "DateTime_Set" "', expected argument " "7"" of type '" "int""'");
24321 }
24322 arg7 = static_cast< int >(val7);
24323 }
24324 if (obj7) {
24325 ecode8 = SWIG_AsVal_int(obj7, &val8);
24326 if (!SWIG_IsOK(ecode8)) {
24327 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "DateTime_Set" "', expected argument " "8"" of type '" "int""'");
24328 }
24329 arg8 = static_cast< int >(val8);
24330 }
24331 {
24332 PyThreadState* __tstate = wxPyBeginAllowThreads();
24333 {
24334 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
24335 result = (wxDateTime *) &_result_ref;
24336 }
24337 wxPyEndAllowThreads(__tstate);
24338 if (PyErr_Occurred()) SWIG_fail;
24339 }
24340 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24341 return resultobj;
24342 fail:
24343 return NULL;
24344 }
24345
24346
24347 SWIGINTERN PyObject *_wrap_DateTime_ResetTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24348 PyObject *resultobj = 0;
24349 wxDateTime *arg1 = (wxDateTime *) 0 ;
24350 wxDateTime *result = 0 ;
24351 void *argp1 = 0 ;
24352 int res1 = 0 ;
24353 PyObject *swig_obj[1] ;
24354
24355 if (!args) SWIG_fail;
24356 swig_obj[0] = args;
24357 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24358 if (!SWIG_IsOK(res1)) {
24359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ResetTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
24360 }
24361 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24362 {
24363 PyThreadState* __tstate = wxPyBeginAllowThreads();
24364 {
24365 wxDateTime &_result_ref = (arg1)->ResetTime();
24366 result = (wxDateTime *) &_result_ref;
24367 }
24368 wxPyEndAllowThreads(__tstate);
24369 if (PyErr_Occurred()) SWIG_fail;
24370 }
24371 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24372 return resultobj;
24373 fail:
24374 return NULL;
24375 }
24376
24377
24378 SWIGINTERN PyObject *_wrap_DateTime_SetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24379 PyObject *resultobj = 0;
24380 wxDateTime *arg1 = (wxDateTime *) 0 ;
24381 int arg2 ;
24382 wxDateTime *result = 0 ;
24383 void *argp1 = 0 ;
24384 int res1 = 0 ;
24385 int val2 ;
24386 int ecode2 = 0 ;
24387 PyObject * obj0 = 0 ;
24388 PyObject * obj1 = 0 ;
24389 char * kwnames[] = {
24390 (char *) "self",(char *) "year", NULL
24391 };
24392
24393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) SWIG_fail;
24394 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24395 if (!SWIG_IsOK(res1)) {
24396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetYear" "', expected argument " "1"" of type '" "wxDateTime *""'");
24397 }
24398 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24399 ecode2 = SWIG_AsVal_int(obj1, &val2);
24400 if (!SWIG_IsOK(ecode2)) {
24401 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetYear" "', expected argument " "2"" of type '" "int""'");
24402 }
24403 arg2 = static_cast< int >(val2);
24404 {
24405 PyThreadState* __tstate = wxPyBeginAllowThreads();
24406 {
24407 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
24408 result = (wxDateTime *) &_result_ref;
24409 }
24410 wxPyEndAllowThreads(__tstate);
24411 if (PyErr_Occurred()) SWIG_fail;
24412 }
24413 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24414 return resultobj;
24415 fail:
24416 return NULL;
24417 }
24418
24419
24420 SWIGINTERN PyObject *_wrap_DateTime_SetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24421 PyObject *resultobj = 0;
24422 wxDateTime *arg1 = (wxDateTime *) 0 ;
24423 wxDateTime::Month arg2 ;
24424 wxDateTime *result = 0 ;
24425 void *argp1 = 0 ;
24426 int res1 = 0 ;
24427 int val2 ;
24428 int ecode2 = 0 ;
24429 PyObject * obj0 = 0 ;
24430 PyObject * obj1 = 0 ;
24431 char * kwnames[] = {
24432 (char *) "self",(char *) "month", NULL
24433 };
24434
24435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
24436 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24437 if (!SWIG_IsOK(res1)) {
24438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMonth" "', expected argument " "1"" of type '" "wxDateTime *""'");
24439 }
24440 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24441 ecode2 = SWIG_AsVal_int(obj1, &val2);
24442 if (!SWIG_IsOK(ecode2)) {
24443 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMonth" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24444 }
24445 arg2 = static_cast< wxDateTime::Month >(val2);
24446 {
24447 PyThreadState* __tstate = wxPyBeginAllowThreads();
24448 {
24449 wxDateTime &_result_ref = (arg1)->SetMonth(arg2);
24450 result = (wxDateTime *) &_result_ref;
24451 }
24452 wxPyEndAllowThreads(__tstate);
24453 if (PyErr_Occurred()) SWIG_fail;
24454 }
24455 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24456 return resultobj;
24457 fail:
24458 return NULL;
24459 }
24460
24461
24462 SWIGINTERN PyObject *_wrap_DateTime_SetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24463 PyObject *resultobj = 0;
24464 wxDateTime *arg1 = (wxDateTime *) 0 ;
24465 int arg2 ;
24466 wxDateTime *result = 0 ;
24467 void *argp1 = 0 ;
24468 int res1 = 0 ;
24469 int val2 ;
24470 int ecode2 = 0 ;
24471 PyObject * obj0 = 0 ;
24472 PyObject * obj1 = 0 ;
24473 char * kwnames[] = {
24474 (char *) "self",(char *) "day", NULL
24475 };
24476
24477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) SWIG_fail;
24478 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24479 if (!SWIG_IsOK(res1)) {
24480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24481 }
24482 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24483 ecode2 = SWIG_AsVal_int(obj1, &val2);
24484 if (!SWIG_IsOK(ecode2)) {
24485 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetDay" "', expected argument " "2"" of type '" "int""'");
24486 }
24487 arg2 = static_cast< int >(val2);
24488 {
24489 PyThreadState* __tstate = wxPyBeginAllowThreads();
24490 {
24491 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
24492 result = (wxDateTime *) &_result_ref;
24493 }
24494 wxPyEndAllowThreads(__tstate);
24495 if (PyErr_Occurred()) SWIG_fail;
24496 }
24497 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24498 return resultobj;
24499 fail:
24500 return NULL;
24501 }
24502
24503
24504 SWIGINTERN PyObject *_wrap_DateTime_SetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24505 PyObject *resultobj = 0;
24506 wxDateTime *arg1 = (wxDateTime *) 0 ;
24507 int arg2 ;
24508 wxDateTime *result = 0 ;
24509 void *argp1 = 0 ;
24510 int res1 = 0 ;
24511 int val2 ;
24512 int ecode2 = 0 ;
24513 PyObject * obj0 = 0 ;
24514 PyObject * obj1 = 0 ;
24515 char * kwnames[] = {
24516 (char *) "self",(char *) "hour", NULL
24517 };
24518
24519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) SWIG_fail;
24520 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24521 if (!SWIG_IsOK(res1)) {
24522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHour" "', expected argument " "1"" of type '" "wxDateTime *""'");
24523 }
24524 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24525 ecode2 = SWIG_AsVal_int(obj1, &val2);
24526 if (!SWIG_IsOK(ecode2)) {
24527 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHour" "', expected argument " "2"" of type '" "int""'");
24528 }
24529 arg2 = static_cast< int >(val2);
24530 {
24531 PyThreadState* __tstate = wxPyBeginAllowThreads();
24532 {
24533 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
24534 result = (wxDateTime *) &_result_ref;
24535 }
24536 wxPyEndAllowThreads(__tstate);
24537 if (PyErr_Occurred()) SWIG_fail;
24538 }
24539 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24540 return resultobj;
24541 fail:
24542 return NULL;
24543 }
24544
24545
24546 SWIGINTERN PyObject *_wrap_DateTime_SetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24547 PyObject *resultobj = 0;
24548 wxDateTime *arg1 = (wxDateTime *) 0 ;
24549 int arg2 ;
24550 wxDateTime *result = 0 ;
24551 void *argp1 = 0 ;
24552 int res1 = 0 ;
24553 int val2 ;
24554 int ecode2 = 0 ;
24555 PyObject * obj0 = 0 ;
24556 PyObject * obj1 = 0 ;
24557 char * kwnames[] = {
24558 (char *) "self",(char *) "minute", NULL
24559 };
24560
24561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
24562 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24563 if (!SWIG_IsOK(res1)) {
24564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMinute" "', expected argument " "1"" of type '" "wxDateTime *""'");
24565 }
24566 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24567 ecode2 = SWIG_AsVal_int(obj1, &val2);
24568 if (!SWIG_IsOK(ecode2)) {
24569 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMinute" "', expected argument " "2"" of type '" "int""'");
24570 }
24571 arg2 = static_cast< int >(val2);
24572 {
24573 PyThreadState* __tstate = wxPyBeginAllowThreads();
24574 {
24575 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
24576 result = (wxDateTime *) &_result_ref;
24577 }
24578 wxPyEndAllowThreads(__tstate);
24579 if (PyErr_Occurred()) SWIG_fail;
24580 }
24581 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24582 return resultobj;
24583 fail:
24584 return NULL;
24585 }
24586
24587
24588 SWIGINTERN PyObject *_wrap_DateTime_SetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24589 PyObject *resultobj = 0;
24590 wxDateTime *arg1 = (wxDateTime *) 0 ;
24591 int arg2 ;
24592 wxDateTime *result = 0 ;
24593 void *argp1 = 0 ;
24594 int res1 = 0 ;
24595 int val2 ;
24596 int ecode2 = 0 ;
24597 PyObject * obj0 = 0 ;
24598 PyObject * obj1 = 0 ;
24599 char * kwnames[] = {
24600 (char *) "self",(char *) "second", NULL
24601 };
24602
24603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
24604 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24605 if (!SWIG_IsOK(res1)) {
24606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetSecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
24607 }
24608 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24609 ecode2 = SWIG_AsVal_int(obj1, &val2);
24610 if (!SWIG_IsOK(ecode2)) {
24611 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetSecond" "', expected argument " "2"" of type '" "int""'");
24612 }
24613 arg2 = static_cast< int >(val2);
24614 {
24615 PyThreadState* __tstate = wxPyBeginAllowThreads();
24616 {
24617 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
24618 result = (wxDateTime *) &_result_ref;
24619 }
24620 wxPyEndAllowThreads(__tstate);
24621 if (PyErr_Occurred()) SWIG_fail;
24622 }
24623 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24624 return resultobj;
24625 fail:
24626 return NULL;
24627 }
24628
24629
24630 SWIGINTERN PyObject *_wrap_DateTime_SetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24631 PyObject *resultobj = 0;
24632 wxDateTime *arg1 = (wxDateTime *) 0 ;
24633 int arg2 ;
24634 wxDateTime *result = 0 ;
24635 void *argp1 = 0 ;
24636 int res1 = 0 ;
24637 int val2 ;
24638 int ecode2 = 0 ;
24639 PyObject * obj0 = 0 ;
24640 PyObject * obj1 = 0 ;
24641 char * kwnames[] = {
24642 (char *) "self",(char *) "millisecond", NULL
24643 };
24644
24645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
24646 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24647 if (!SWIG_IsOK(res1)) {
24648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMillisecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
24649 }
24650 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24651 ecode2 = SWIG_AsVal_int(obj1, &val2);
24652 if (!SWIG_IsOK(ecode2)) {
24653 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMillisecond" "', expected argument " "2"" of type '" "int""'");
24654 }
24655 arg2 = static_cast< int >(val2);
24656 {
24657 PyThreadState* __tstate = wxPyBeginAllowThreads();
24658 {
24659 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
24660 result = (wxDateTime *) &_result_ref;
24661 }
24662 wxPyEndAllowThreads(__tstate);
24663 if (PyErr_Occurred()) SWIG_fail;
24664 }
24665 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24666 return resultobj;
24667 fail:
24668 return NULL;
24669 }
24670
24671
24672 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24673 PyObject *resultobj = 0;
24674 wxDateTime *arg1 = (wxDateTime *) 0 ;
24675 wxDateTime::WeekDay arg2 ;
24676 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
24677 wxDateTime *result = 0 ;
24678 void *argp1 = 0 ;
24679 int res1 = 0 ;
24680 int val2 ;
24681 int ecode2 = 0 ;
24682 int val3 ;
24683 int ecode3 = 0 ;
24684 PyObject * obj0 = 0 ;
24685 PyObject * obj1 = 0 ;
24686 PyObject * obj2 = 0 ;
24687 char * kwnames[] = {
24688 (char *) "self",(char *) "weekday",(char *) "flags", NULL
24689 };
24690
24691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24693 if (!SWIG_IsOK(res1)) {
24694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
24695 }
24696 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24697 ecode2 = SWIG_AsVal_int(obj1, &val2);
24698 if (!SWIG_IsOK(ecode2)) {
24699 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24700 }
24701 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24702 if (obj2) {
24703 ecode3 = SWIG_AsVal_int(obj2, &val3);
24704 if (!SWIG_IsOK(ecode3)) {
24705 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
24706 }
24707 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
24708 }
24709 {
24710 PyThreadState* __tstate = wxPyBeginAllowThreads();
24711 {
24712 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek(arg2,arg3);
24713 result = (wxDateTime *) &_result_ref;
24714 }
24715 wxPyEndAllowThreads(__tstate);
24716 if (PyErr_Occurred()) SWIG_fail;
24717 }
24718 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24719 return resultobj;
24720 fail:
24721 return NULL;
24722 }
24723
24724
24725 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24726 PyObject *resultobj = 0;
24727 wxDateTime *arg1 = (wxDateTime *) 0 ;
24728 wxDateTime::WeekDay arg2 ;
24729 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
24730 wxDateTime result;
24731 void *argp1 = 0 ;
24732 int res1 = 0 ;
24733 int val2 ;
24734 int ecode2 = 0 ;
24735 int val3 ;
24736 int ecode3 = 0 ;
24737 PyObject * obj0 = 0 ;
24738 PyObject * obj1 = 0 ;
24739 PyObject * obj2 = 0 ;
24740 char * kwnames[] = {
24741 (char *) "self",(char *) "weekday",(char *) "flags", NULL
24742 };
24743
24744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) 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_GetWeekDayInSameWeek" "', 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_GetWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24753 }
24754 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24755 if (obj2) {
24756 ecode3 = SWIG_AsVal_int(obj2, &val3);
24757 if (!SWIG_IsOK(ecode3)) {
24758 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
24759 }
24760 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
24761 }
24762 {
24763 PyThreadState* __tstate = wxPyBeginAllowThreads();
24764 result = (arg1)->GetWeekDayInSameWeek(arg2,arg3);
24765 wxPyEndAllowThreads(__tstate);
24766 if (PyErr_Occurred()) SWIG_fail;
24767 }
24768 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24769 return resultobj;
24770 fail:
24771 return NULL;
24772 }
24773
24774
24775 SWIGINTERN PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24776 PyObject *resultobj = 0;
24777 wxDateTime *arg1 = (wxDateTime *) 0 ;
24778 wxDateTime::WeekDay arg2 ;
24779 wxDateTime *result = 0 ;
24780 void *argp1 = 0 ;
24781 int res1 = 0 ;
24782 int val2 ;
24783 int ecode2 = 0 ;
24784 PyObject * obj0 = 0 ;
24785 PyObject * obj1 = 0 ;
24786 char * kwnames[] = {
24787 (char *) "self",(char *) "weekday", NULL
24788 };
24789
24790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24792 if (!SWIG_IsOK(res1)) {
24793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24794 }
24795 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24796 ecode2 = SWIG_AsVal_int(obj1, &val2);
24797 if (!SWIG_IsOK(ecode2)) {
24798 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24799 }
24800 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24801 {
24802 PyThreadState* __tstate = wxPyBeginAllowThreads();
24803 {
24804 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay(arg2);
24805 result = (wxDateTime *) &_result_ref;
24806 }
24807 wxPyEndAllowThreads(__tstate);
24808 if (PyErr_Occurred()) SWIG_fail;
24809 }
24810 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24811 return resultobj;
24812 fail:
24813 return NULL;
24814 }
24815
24816
24817 SWIGINTERN PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24818 PyObject *resultobj = 0;
24819 wxDateTime *arg1 = (wxDateTime *) 0 ;
24820 wxDateTime::WeekDay arg2 ;
24821 wxDateTime result;
24822 void *argp1 = 0 ;
24823 int res1 = 0 ;
24824 int val2 ;
24825 int ecode2 = 0 ;
24826 PyObject * obj0 = 0 ;
24827 PyObject * obj1 = 0 ;
24828 char * kwnames[] = {
24829 (char *) "self",(char *) "weekday", NULL
24830 };
24831
24832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24834 if (!SWIG_IsOK(res1)) {
24835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24836 }
24837 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24838 ecode2 = SWIG_AsVal_int(obj1, &val2);
24839 if (!SWIG_IsOK(ecode2)) {
24840 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24841 }
24842 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24843 {
24844 PyThreadState* __tstate = wxPyBeginAllowThreads();
24845 result = (arg1)->GetNextWeekDay(arg2);
24846 wxPyEndAllowThreads(__tstate);
24847 if (PyErr_Occurred()) SWIG_fail;
24848 }
24849 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24850 return resultobj;
24851 fail:
24852 return NULL;
24853 }
24854
24855
24856 SWIGINTERN PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24857 PyObject *resultobj = 0;
24858 wxDateTime *arg1 = (wxDateTime *) 0 ;
24859 wxDateTime::WeekDay arg2 ;
24860 wxDateTime *result = 0 ;
24861 void *argp1 = 0 ;
24862 int res1 = 0 ;
24863 int val2 ;
24864 int ecode2 = 0 ;
24865 PyObject * obj0 = 0 ;
24866 PyObject * obj1 = 0 ;
24867 char * kwnames[] = {
24868 (char *) "self",(char *) "weekday", NULL
24869 };
24870
24871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24872 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24873 if (!SWIG_IsOK(res1)) {
24874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24875 }
24876 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24877 ecode2 = SWIG_AsVal_int(obj1, &val2);
24878 if (!SWIG_IsOK(ecode2)) {
24879 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24880 }
24881 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24882 {
24883 PyThreadState* __tstate = wxPyBeginAllowThreads();
24884 {
24885 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay(arg2);
24886 result = (wxDateTime *) &_result_ref;
24887 }
24888 wxPyEndAllowThreads(__tstate);
24889 if (PyErr_Occurred()) SWIG_fail;
24890 }
24891 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24892 return resultobj;
24893 fail:
24894 return NULL;
24895 }
24896
24897
24898 SWIGINTERN PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24899 PyObject *resultobj = 0;
24900 wxDateTime *arg1 = (wxDateTime *) 0 ;
24901 wxDateTime::WeekDay arg2 ;
24902 wxDateTime result;
24903 void *argp1 = 0 ;
24904 int res1 = 0 ;
24905 int val2 ;
24906 int ecode2 = 0 ;
24907 PyObject * obj0 = 0 ;
24908 PyObject * obj1 = 0 ;
24909 char * kwnames[] = {
24910 (char *) "self",(char *) "weekday", NULL
24911 };
24912
24913 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24914 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24915 if (!SWIG_IsOK(res1)) {
24916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24917 }
24918 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24919 ecode2 = SWIG_AsVal_int(obj1, &val2);
24920 if (!SWIG_IsOK(ecode2)) {
24921 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24922 }
24923 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24924 {
24925 PyThreadState* __tstate = wxPyBeginAllowThreads();
24926 result = (arg1)->GetPrevWeekDay(arg2);
24927 wxPyEndAllowThreads(__tstate);
24928 if (PyErr_Occurred()) SWIG_fail;
24929 }
24930 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24931 return resultobj;
24932 fail:
24933 return NULL;
24934 }
24935
24936
24937 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24938 PyObject *resultobj = 0;
24939 wxDateTime *arg1 = (wxDateTime *) 0 ;
24940 wxDateTime::WeekDay arg2 ;
24941 int arg3 = (int) 1 ;
24942 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24943 int arg5 = (int) wxDateTime::Inv_Year ;
24944 bool result;
24945 void *argp1 = 0 ;
24946 int res1 = 0 ;
24947 int val2 ;
24948 int ecode2 = 0 ;
24949 int val3 ;
24950 int ecode3 = 0 ;
24951 int val4 ;
24952 int ecode4 = 0 ;
24953 int val5 ;
24954 int ecode5 = 0 ;
24955 PyObject * obj0 = 0 ;
24956 PyObject * obj1 = 0 ;
24957 PyObject * obj2 = 0 ;
24958 PyObject * obj3 = 0 ;
24959 PyObject * obj4 = 0 ;
24960 char * kwnames[] = {
24961 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
24962 };
24963
24964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
24965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24966 if (!SWIG_IsOK(res1)) {
24967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24968 }
24969 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24970 ecode2 = SWIG_AsVal_int(obj1, &val2);
24971 if (!SWIG_IsOK(ecode2)) {
24972 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24973 }
24974 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24975 if (obj2) {
24976 ecode3 = SWIG_AsVal_int(obj2, &val3);
24977 if (!SWIG_IsOK(ecode3)) {
24978 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDay" "', expected argument " "3"" of type '" "int""'");
24979 }
24980 arg3 = static_cast< int >(val3);
24981 }
24982 if (obj3) {
24983 ecode4 = SWIG_AsVal_int(obj3, &val4);
24984 if (!SWIG_IsOK(ecode4)) {
24985 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToWeekDay" "', expected argument " "4"" of type '" "wxDateTime::Month""'");
24986 }
24987 arg4 = static_cast< wxDateTime::Month >(val4);
24988 }
24989 if (obj4) {
24990 ecode5 = SWIG_AsVal_int(obj4, &val5);
24991 if (!SWIG_IsOK(ecode5)) {
24992 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetToWeekDay" "', expected argument " "5"" of type '" "int""'");
24993 }
24994 arg5 = static_cast< int >(val5);
24995 }
24996 {
24997 PyThreadState* __tstate = wxPyBeginAllowThreads();
24998 result = (bool)(arg1)->SetToWeekDay(arg2,arg3,arg4,arg5);
24999 wxPyEndAllowThreads(__tstate);
25000 if (PyErr_Occurred()) SWIG_fail;
25001 }
25002 {
25003 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25004 }
25005 return resultobj;
25006 fail:
25007 return NULL;
25008 }
25009
25010
25011 SWIGINTERN PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25012 PyObject *resultobj = 0;
25013 wxDateTime *arg1 = (wxDateTime *) 0 ;
25014 wxDateTime::WeekDay arg2 ;
25015 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25016 int arg4 = (int) wxDateTime::Inv_Year ;
25017 bool result;
25018 void *argp1 = 0 ;
25019 int res1 = 0 ;
25020 int val2 ;
25021 int ecode2 = 0 ;
25022 int val3 ;
25023 int ecode3 = 0 ;
25024 int val4 ;
25025 int ecode4 = 0 ;
25026 PyObject * obj0 = 0 ;
25027 PyObject * obj1 = 0 ;
25028 PyObject * obj2 = 0 ;
25029 PyObject * obj3 = 0 ;
25030 char * kwnames[] = {
25031 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
25032 };
25033
25034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25035 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25036 if (!SWIG_IsOK(res1)) {
25037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25038 }
25039 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25040 ecode2 = SWIG_AsVal_int(obj1, &val2);
25041 if (!SWIG_IsOK(ecode2)) {
25042 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25043 }
25044 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25045 if (obj2) {
25046 ecode3 = SWIG_AsVal_int(obj2, &val3);
25047 if (!SWIG_IsOK(ecode3)) {
25048 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
25049 }
25050 arg3 = static_cast< wxDateTime::Month >(val3);
25051 }
25052 if (obj3) {
25053 ecode4 = SWIG_AsVal_int(obj3, &val4);
25054 if (!SWIG_IsOK(ecode4)) {
25055 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "4"" of type '" "int""'");
25056 }
25057 arg4 = static_cast< int >(val4);
25058 }
25059 {
25060 PyThreadState* __tstate = wxPyBeginAllowThreads();
25061 result = (bool)(arg1)->SetToLastWeekDay(arg2,arg3,arg4);
25062 wxPyEndAllowThreads(__tstate);
25063 if (PyErr_Occurred()) SWIG_fail;
25064 }
25065 {
25066 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25067 }
25068 return resultobj;
25069 fail:
25070 return NULL;
25071 }
25072
25073
25074 SWIGINTERN PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25075 PyObject *resultobj = 0;
25076 wxDateTime *arg1 = (wxDateTime *) 0 ;
25077 wxDateTime::WeekDay arg2 ;
25078 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25079 int arg4 = (int) wxDateTime::Inv_Year ;
25080 wxDateTime result;
25081 void *argp1 = 0 ;
25082 int res1 = 0 ;
25083 int val2 ;
25084 int ecode2 = 0 ;
25085 int val3 ;
25086 int ecode3 = 0 ;
25087 int val4 ;
25088 int ecode4 = 0 ;
25089 PyObject * obj0 = 0 ;
25090 PyObject * obj1 = 0 ;
25091 PyObject * obj2 = 0 ;
25092 PyObject * obj3 = 0 ;
25093 char * kwnames[] = {
25094 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
25095 };
25096
25097 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25098 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25099 if (!SWIG_IsOK(res1)) {
25100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25101 }
25102 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25103 ecode2 = SWIG_AsVal_int(obj1, &val2);
25104 if (!SWIG_IsOK(ecode2)) {
25105 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25106 }
25107 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25108 if (obj2) {
25109 ecode3 = SWIG_AsVal_int(obj2, &val3);
25110 if (!SWIG_IsOK(ecode3)) {
25111 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
25112 }
25113 arg3 = static_cast< wxDateTime::Month >(val3);
25114 }
25115 if (obj3) {
25116 ecode4 = SWIG_AsVal_int(obj3, &val4);
25117 if (!SWIG_IsOK(ecode4)) {
25118 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "4"" of type '" "int""'");
25119 }
25120 arg4 = static_cast< int >(val4);
25121 }
25122 {
25123 PyThreadState* __tstate = wxPyBeginAllowThreads();
25124 result = (arg1)->GetLastWeekDay(arg2,arg3,arg4);
25125 wxPyEndAllowThreads(__tstate);
25126 if (PyErr_Occurred()) SWIG_fail;
25127 }
25128 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25129 return resultobj;
25130 fail:
25131 return NULL;
25132 }
25133
25134
25135 SWIGINTERN PyObject *_wrap_DateTime_SetToTheWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25136 PyObject *resultobj = 0;
25137 wxDateTime *arg1 = (wxDateTime *) 0 ;
25138 int arg2 ;
25139 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
25140 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25141 bool result;
25142 void *argp1 = 0 ;
25143 int res1 = 0 ;
25144 int val2 ;
25145 int ecode2 = 0 ;
25146 int val3 ;
25147 int ecode3 = 0 ;
25148 int val4 ;
25149 int ecode4 = 0 ;
25150 PyObject * obj0 = 0 ;
25151 PyObject * obj1 = 0 ;
25152 PyObject * obj2 = 0 ;
25153 PyObject * obj3 = 0 ;
25154 char * kwnames[] = {
25155 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
25156 };
25157
25158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25160 if (!SWIG_IsOK(res1)) {
25161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToTheWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
25162 }
25163 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25164 ecode2 = SWIG_AsVal_int(obj1, &val2);
25165 if (!SWIG_IsOK(ecode2)) {
25166 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToTheWeek" "', expected argument " "2"" of type '" "int""'");
25167 }
25168 arg2 = static_cast< int >(val2);
25169 if (obj2) {
25170 ecode3 = SWIG_AsVal_int(obj2, &val3);
25171 if (!SWIG_IsOK(ecode3)) {
25172 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToTheWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
25173 }
25174 arg3 = static_cast< wxDateTime::WeekDay >(val3);
25175 }
25176 if (obj3) {
25177 ecode4 = SWIG_AsVal_int(obj3, &val4);
25178 if (!SWIG_IsOK(ecode4)) {
25179 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToTheWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
25180 }
25181 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
25182 }
25183 {
25184 PyThreadState* __tstate = wxPyBeginAllowThreads();
25185 result = (bool)(arg1)->SetToTheWeek(arg2,arg3,arg4);
25186 wxPyEndAllowThreads(__tstate);
25187 if (PyErr_Occurred()) SWIG_fail;
25188 }
25189 {
25190 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25191 }
25192 return resultobj;
25193 fail:
25194 return NULL;
25195 }
25196
25197
25198 SWIGINTERN PyObject *_wrap_DateTime_GetWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25199 PyObject *resultobj = 0;
25200 wxDateTime *arg1 = (wxDateTime *) 0 ;
25201 int arg2 ;
25202 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
25203 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25204 wxDateTime result;
25205 void *argp1 = 0 ;
25206 int res1 = 0 ;
25207 int val2 ;
25208 int ecode2 = 0 ;
25209 int val3 ;
25210 int ecode3 = 0 ;
25211 int val4 ;
25212 int ecode4 = 0 ;
25213 PyObject * obj0 = 0 ;
25214 PyObject * obj1 = 0 ;
25215 PyObject * obj2 = 0 ;
25216 PyObject * obj3 = 0 ;
25217 char * kwnames[] = {
25218 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
25219 };
25220
25221 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25222 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25223 if (!SWIG_IsOK(res1)) {
25224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
25225 }
25226 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25227 ecode2 = SWIG_AsVal_int(obj1, &val2);
25228 if (!SWIG_IsOK(ecode2)) {
25229 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeek" "', expected argument " "2"" of type '" "int""'");
25230 }
25231 arg2 = static_cast< int >(val2);
25232 if (obj2) {
25233 ecode3 = SWIG_AsVal_int(obj2, &val3);
25234 if (!SWIG_IsOK(ecode3)) {
25235 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
25236 }
25237 arg3 = static_cast< wxDateTime::WeekDay >(val3);
25238 }
25239 if (obj3) {
25240 ecode4 = SWIG_AsVal_int(obj3, &val4);
25241 if (!SWIG_IsOK(ecode4)) {
25242 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
25243 }
25244 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
25245 }
25246 {
25247 PyThreadState* __tstate = wxPyBeginAllowThreads();
25248 result = (arg1)->GetWeek(arg2,arg3,arg4);
25249 wxPyEndAllowThreads(__tstate);
25250 if (PyErr_Occurred()) SWIG_fail;
25251 }
25252 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25253 return resultobj;
25254 fail:
25255 return NULL;
25256 }
25257
25258
25259 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25260 PyObject *resultobj = 0;
25261 int arg1 ;
25262 int arg2 ;
25263 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
25264 wxDateTime result;
25265 int val1 ;
25266 int ecode1 = 0 ;
25267 int val2 ;
25268 int ecode2 = 0 ;
25269 int val3 ;
25270 int ecode3 = 0 ;
25271 PyObject * obj0 = 0 ;
25272 PyObject * obj1 = 0 ;
25273 PyObject * obj2 = 0 ;
25274 char * kwnames[] = {
25275 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
25276 };
25277
25278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25279 ecode1 = SWIG_AsVal_int(obj0, &val1);
25280 if (!SWIG_IsOK(ecode1)) {
25281 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "1"" of type '" "int""'");
25282 }
25283 arg1 = static_cast< int >(val1);
25284 ecode2 = SWIG_AsVal_int(obj1, &val2);
25285 if (!SWIG_IsOK(ecode2)) {
25286 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "2"" of type '" "int""'");
25287 }
25288 arg2 = static_cast< int >(val2);
25289 if (obj2) {
25290 ecode3 = SWIG_AsVal_int(obj2, &val3);
25291 if (!SWIG_IsOK(ecode3)) {
25292 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
25293 }
25294 arg3 = static_cast< wxDateTime::WeekDay >(val3);
25295 }
25296 {
25297 PyThreadState* __tstate = wxPyBeginAllowThreads();
25298 result = wxDateTime::SetToWeekOfYear(arg1,arg2,arg3);
25299 wxPyEndAllowThreads(__tstate);
25300 if (PyErr_Occurred()) SWIG_fail;
25301 }
25302 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25303 return resultobj;
25304 fail:
25305 return NULL;
25306 }
25307
25308
25309 SWIGINTERN PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25310 PyObject *resultobj = 0;
25311 wxDateTime *arg1 = (wxDateTime *) 0 ;
25312 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25313 int arg3 = (int) wxDateTime::Inv_Year ;
25314 wxDateTime *result = 0 ;
25315 void *argp1 = 0 ;
25316 int res1 = 0 ;
25317 int val2 ;
25318 int ecode2 = 0 ;
25319 int val3 ;
25320 int ecode3 = 0 ;
25321 PyObject * obj0 = 0 ;
25322 PyObject * obj1 = 0 ;
25323 PyObject * obj2 = 0 ;
25324 char * kwnames[] = {
25325 (char *) "self",(char *) "month",(char *) "year", NULL
25326 };
25327
25328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25330 if (!SWIG_IsOK(res1)) {
25331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25332 }
25333 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25334 if (obj1) {
25335 ecode2 = SWIG_AsVal_int(obj1, &val2);
25336 if (!SWIG_IsOK(ecode2)) {
25337 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
25338 }
25339 arg2 = static_cast< wxDateTime::Month >(val2);
25340 }
25341 if (obj2) {
25342 ecode3 = SWIG_AsVal_int(obj2, &val3);
25343 if (!SWIG_IsOK(ecode3)) {
25344 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "3"" of type '" "int""'");
25345 }
25346 arg3 = static_cast< int >(val3);
25347 }
25348 {
25349 PyThreadState* __tstate = wxPyBeginAllowThreads();
25350 {
25351 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay(arg2,arg3);
25352 result = (wxDateTime *) &_result_ref;
25353 }
25354 wxPyEndAllowThreads(__tstate);
25355 if (PyErr_Occurred()) SWIG_fail;
25356 }
25357 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25358 return resultobj;
25359 fail:
25360 return NULL;
25361 }
25362
25363
25364 SWIGINTERN PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25365 PyObject *resultobj = 0;
25366 wxDateTime *arg1 = (wxDateTime *) 0 ;
25367 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25368 int arg3 = (int) wxDateTime::Inv_Year ;
25369 wxDateTime result;
25370 void *argp1 = 0 ;
25371 int res1 = 0 ;
25372 int val2 ;
25373 int ecode2 = 0 ;
25374 int val3 ;
25375 int ecode3 = 0 ;
25376 PyObject * obj0 = 0 ;
25377 PyObject * obj1 = 0 ;
25378 PyObject * obj2 = 0 ;
25379 char * kwnames[] = {
25380 (char *) "self",(char *) "month",(char *) "year", NULL
25381 };
25382
25383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25384 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25385 if (!SWIG_IsOK(res1)) {
25386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25387 }
25388 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25389 if (obj1) {
25390 ecode2 = SWIG_AsVal_int(obj1, &val2);
25391 if (!SWIG_IsOK(ecode2)) {
25392 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
25393 }
25394 arg2 = static_cast< wxDateTime::Month >(val2);
25395 }
25396 if (obj2) {
25397 ecode3 = SWIG_AsVal_int(obj2, &val3);
25398 if (!SWIG_IsOK(ecode3)) {
25399 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "3"" of type '" "int""'");
25400 }
25401 arg3 = static_cast< int >(val3);
25402 }
25403 {
25404 PyThreadState* __tstate = wxPyBeginAllowThreads();
25405 result = (arg1)->GetLastMonthDay(arg2,arg3);
25406 wxPyEndAllowThreads(__tstate);
25407 if (PyErr_Occurred()) SWIG_fail;
25408 }
25409 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25410 return resultobj;
25411 fail:
25412 return NULL;
25413 }
25414
25415
25416 SWIGINTERN PyObject *_wrap_DateTime_SetToYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25417 PyObject *resultobj = 0;
25418 wxDateTime *arg1 = (wxDateTime *) 0 ;
25419 int arg2 ;
25420 wxDateTime *result = 0 ;
25421 void *argp1 = 0 ;
25422 int res1 = 0 ;
25423 int val2 ;
25424 int ecode2 = 0 ;
25425 PyObject * obj0 = 0 ;
25426 PyObject * obj1 = 0 ;
25427 char * kwnames[] = {
25428 (char *) "self",(char *) "yday", NULL
25429 };
25430
25431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
25432 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25433 if (!SWIG_IsOK(res1)) {
25434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25435 }
25436 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25437 ecode2 = SWIG_AsVal_int(obj1, &val2);
25438 if (!SWIG_IsOK(ecode2)) {
25439 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToYearDay" "', expected argument " "2"" of type '" "int""'");
25440 }
25441 arg2 = static_cast< int >(val2);
25442 {
25443 PyThreadState* __tstate = wxPyBeginAllowThreads();
25444 {
25445 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
25446 result = (wxDateTime *) &_result_ref;
25447 }
25448 wxPyEndAllowThreads(__tstate);
25449 if (PyErr_Occurred()) SWIG_fail;
25450 }
25451 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25452 return resultobj;
25453 fail:
25454 return NULL;
25455 }
25456
25457
25458 SWIGINTERN PyObject *_wrap_DateTime_GetYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25459 PyObject *resultobj = 0;
25460 wxDateTime *arg1 = (wxDateTime *) 0 ;
25461 int arg2 ;
25462 wxDateTime result;
25463 void *argp1 = 0 ;
25464 int res1 = 0 ;
25465 int val2 ;
25466 int ecode2 = 0 ;
25467 PyObject * obj0 = 0 ;
25468 PyObject * obj1 = 0 ;
25469 char * kwnames[] = {
25470 (char *) "self",(char *) "yday", NULL
25471 };
25472
25473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
25474 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25475 if (!SWIG_IsOK(res1)) {
25476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25477 }
25478 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25479 ecode2 = SWIG_AsVal_int(obj1, &val2);
25480 if (!SWIG_IsOK(ecode2)) {
25481 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetYearDay" "', expected argument " "2"" of type '" "int""'");
25482 }
25483 arg2 = static_cast< int >(val2);
25484 {
25485 PyThreadState* __tstate = wxPyBeginAllowThreads();
25486 result = (arg1)->GetYearDay(arg2);
25487 wxPyEndAllowThreads(__tstate);
25488 if (PyErr_Occurred()) SWIG_fail;
25489 }
25490 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25491 return resultobj;
25492 fail:
25493 return NULL;
25494 }
25495
25496
25497 SWIGINTERN PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25498 PyObject *resultobj = 0;
25499 wxDateTime *arg1 = (wxDateTime *) 0 ;
25500 double result;
25501 void *argp1 = 0 ;
25502 int res1 = 0 ;
25503 PyObject *swig_obj[1] ;
25504
25505 if (!args) SWIG_fail;
25506 swig_obj[0] = args;
25507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25508 if (!SWIG_IsOK(res1)) {
25509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime *""'");
25510 }
25511 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25512 {
25513 PyThreadState* __tstate = wxPyBeginAllowThreads();
25514 result = (double)(arg1)->GetJulianDayNumber();
25515 wxPyEndAllowThreads(__tstate);
25516 if (PyErr_Occurred()) SWIG_fail;
25517 }
25518 resultobj = SWIG_From_double(static_cast< double >(result));
25519 return resultobj;
25520 fail:
25521 return NULL;
25522 }
25523
25524
25525 SWIGINTERN PyObject *_wrap_DateTime_GetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25526 PyObject *resultobj = 0;
25527 wxDateTime *arg1 = (wxDateTime *) 0 ;
25528 double result;
25529 void *argp1 = 0 ;
25530 int res1 = 0 ;
25531 PyObject *swig_obj[1] ;
25532
25533 if (!args) SWIG_fail;
25534 swig_obj[0] = args;
25535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25536 if (!SWIG_IsOK(res1)) {
25537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
25538 }
25539 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25540 {
25541 PyThreadState* __tstate = wxPyBeginAllowThreads();
25542 result = (double)(arg1)->GetJDN();
25543 wxPyEndAllowThreads(__tstate);
25544 if (PyErr_Occurred()) SWIG_fail;
25545 }
25546 resultobj = SWIG_From_double(static_cast< double >(result));
25547 return resultobj;
25548 fail:
25549 return NULL;
25550 }
25551
25552
25553 SWIGINTERN PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25554 PyObject *resultobj = 0;
25555 wxDateTime *arg1 = (wxDateTime *) 0 ;
25556 double result;
25557 void *argp1 = 0 ;
25558 int res1 = 0 ;
25559 PyObject *swig_obj[1] ;
25560
25561 if (!args) SWIG_fail;
25562 swig_obj[0] = args;
25563 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25564 if (!SWIG_IsOK(res1)) {
25565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetModifiedJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25566 }
25567 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25568 {
25569 PyThreadState* __tstate = wxPyBeginAllowThreads();
25570 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
25571 wxPyEndAllowThreads(__tstate);
25572 if (PyErr_Occurred()) SWIG_fail;
25573 }
25574 resultobj = SWIG_From_double(static_cast< double >(result));
25575 return resultobj;
25576 fail:
25577 return NULL;
25578 }
25579
25580
25581 SWIGINTERN PyObject *_wrap_DateTime_GetMJD(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25582 PyObject *resultobj = 0;
25583 wxDateTime *arg1 = (wxDateTime *) 0 ;
25584 double result;
25585 void *argp1 = 0 ;
25586 int res1 = 0 ;
25587 PyObject *swig_obj[1] ;
25588
25589 if (!args) SWIG_fail;
25590 swig_obj[0] = args;
25591 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25592 if (!SWIG_IsOK(res1)) {
25593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMJD" "', expected argument " "1"" of type '" "wxDateTime *""'");
25594 }
25595 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25596 {
25597 PyThreadState* __tstate = wxPyBeginAllowThreads();
25598 result = (double)(arg1)->GetMJD();
25599 wxPyEndAllowThreads(__tstate);
25600 if (PyErr_Occurred()) SWIG_fail;
25601 }
25602 resultobj = SWIG_From_double(static_cast< double >(result));
25603 return resultobj;
25604 fail:
25605 return NULL;
25606 }
25607
25608
25609 SWIGINTERN PyObject *_wrap_DateTime_GetRataDie(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25610 PyObject *resultobj = 0;
25611 wxDateTime *arg1 = (wxDateTime *) 0 ;
25612 double result;
25613 void *argp1 = 0 ;
25614 int res1 = 0 ;
25615 PyObject *swig_obj[1] ;
25616
25617 if (!args) SWIG_fail;
25618 swig_obj[0] = args;
25619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25620 if (!SWIG_IsOK(res1)) {
25621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetRataDie" "', expected argument " "1"" of type '" "wxDateTime *""'");
25622 }
25623 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25624 {
25625 PyThreadState* __tstate = wxPyBeginAllowThreads();
25626 result = (double)(arg1)->GetRataDie();
25627 wxPyEndAllowThreads(__tstate);
25628 if (PyErr_Occurred()) SWIG_fail;
25629 }
25630 resultobj = SWIG_From_double(static_cast< double >(result));
25631 return resultobj;
25632 fail:
25633 return NULL;
25634 }
25635
25636
25637 SWIGINTERN PyObject *_wrap_DateTime_ToTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25638 PyObject *resultobj = 0;
25639 wxDateTime *arg1 = (wxDateTime *) 0 ;
25640 wxDateTime::TimeZone *arg2 = 0 ;
25641 bool arg3 = (bool) false ;
25642 wxDateTime result;
25643 void *argp1 = 0 ;
25644 int res1 = 0 ;
25645 bool temp2 = false ;
25646 bool val3 ;
25647 int ecode3 = 0 ;
25648 PyObject * obj0 = 0 ;
25649 PyObject * obj1 = 0 ;
25650 PyObject * obj2 = 0 ;
25651 char * kwnames[] = {
25652 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25653 };
25654
25655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25657 if (!SWIG_IsOK(res1)) {
25658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25659 }
25660 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25661 {
25662 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25663 temp2 = true;
25664 }
25665 if (obj2) {
25666 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25667 if (!SWIG_IsOK(ecode3)) {
25668 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_ToTimezone" "', expected argument " "3"" of type '" "bool""'");
25669 }
25670 arg3 = static_cast< bool >(val3);
25671 }
25672 {
25673 PyThreadState* __tstate = wxPyBeginAllowThreads();
25674 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25675 wxPyEndAllowThreads(__tstate);
25676 if (PyErr_Occurred()) SWIG_fail;
25677 }
25678 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25679 {
25680 if (temp2) delete arg2;
25681 }
25682 return resultobj;
25683 fail:
25684 {
25685 if (temp2) delete arg2;
25686 }
25687 return NULL;
25688 }
25689
25690
25691 SWIGINTERN PyObject *_wrap_DateTime_MakeTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25692 PyObject *resultobj = 0;
25693 wxDateTime *arg1 = (wxDateTime *) 0 ;
25694 wxDateTime::TimeZone *arg2 = 0 ;
25695 bool arg3 = (bool) false ;
25696 wxDateTime *result = 0 ;
25697 void *argp1 = 0 ;
25698 int res1 = 0 ;
25699 bool temp2 = false ;
25700 bool val3 ;
25701 int ecode3 = 0 ;
25702 PyObject * obj0 = 0 ;
25703 PyObject * obj1 = 0 ;
25704 PyObject * obj2 = 0 ;
25705 char * kwnames[] = {
25706 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25707 };
25708
25709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25710 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25711 if (!SWIG_IsOK(res1)) {
25712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25713 }
25714 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25715 {
25716 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25717 temp2 = true;
25718 }
25719 if (obj2) {
25720 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25721 if (!SWIG_IsOK(ecode3)) {
25722 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeTimezone" "', expected argument " "3"" of type '" "bool""'");
25723 }
25724 arg3 = static_cast< bool >(val3);
25725 }
25726 {
25727 PyThreadState* __tstate = wxPyBeginAllowThreads();
25728 {
25729 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25730 result = (wxDateTime *) &_result_ref;
25731 }
25732 wxPyEndAllowThreads(__tstate);
25733 if (PyErr_Occurred()) SWIG_fail;
25734 }
25735 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25736 {
25737 if (temp2) delete arg2;
25738 }
25739 return resultobj;
25740 fail:
25741 {
25742 if (temp2) delete arg2;
25743 }
25744 return NULL;
25745 }
25746
25747
25748 SWIGINTERN PyObject *_wrap_DateTime_FromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25749 PyObject *resultobj = 0;
25750 wxDateTime *arg1 = (wxDateTime *) 0 ;
25751 wxDateTime::TimeZone *arg2 = 0 ;
25752 bool arg3 = (bool) false ;
25753 wxDateTime result;
25754 void *argp1 = 0 ;
25755 int res1 = 0 ;
25756 bool temp2 = false ;
25757 bool val3 ;
25758 int ecode3 = 0 ;
25759 PyObject * obj0 = 0 ;
25760 PyObject * obj1 = 0 ;
25761 PyObject * obj2 = 0 ;
25762 char * kwnames[] = {
25763 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25764 };
25765
25766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_FromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25768 if (!SWIG_IsOK(res1)) {
25769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromTimezone" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25770 }
25771 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25772 {
25773 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25774 temp2 = true;
25775 }
25776 if (obj2) {
25777 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25778 if (!SWIG_IsOK(ecode3)) {
25779 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_FromTimezone" "', expected argument " "3"" of type '" "bool""'");
25780 }
25781 arg3 = static_cast< bool >(val3);
25782 }
25783 {
25784 PyThreadState* __tstate = wxPyBeginAllowThreads();
25785 result = ((wxDateTime const *)arg1)->FromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25786 wxPyEndAllowThreads(__tstate);
25787 if (PyErr_Occurred()) SWIG_fail;
25788 }
25789 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25790 {
25791 if (temp2) delete arg2;
25792 }
25793 return resultobj;
25794 fail:
25795 {
25796 if (temp2) delete arg2;
25797 }
25798 return NULL;
25799 }
25800
25801
25802 SWIGINTERN PyObject *_wrap_DateTime_MakeFromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25803 PyObject *resultobj = 0;
25804 wxDateTime *arg1 = (wxDateTime *) 0 ;
25805 wxDateTime::TimeZone *arg2 = 0 ;
25806 bool arg3 = (bool) false ;
25807 wxDateTime *result = 0 ;
25808 void *argp1 = 0 ;
25809 int res1 = 0 ;
25810 bool temp2 = false ;
25811 bool val3 ;
25812 int ecode3 = 0 ;
25813 PyObject * obj0 = 0 ;
25814 PyObject * obj1 = 0 ;
25815 PyObject * obj2 = 0 ;
25816 char * kwnames[] = {
25817 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25818 };
25819
25820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeFromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25822 if (!SWIG_IsOK(res1)) {
25823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25824 }
25825 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25826 {
25827 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25828 temp2 = true;
25829 }
25830 if (obj2) {
25831 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25832 if (!SWIG_IsOK(ecode3)) {
25833 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "3"" of type '" "bool""'");
25834 }
25835 arg3 = static_cast< bool >(val3);
25836 }
25837 {
25838 PyThreadState* __tstate = wxPyBeginAllowThreads();
25839 {
25840 wxDateTime &_result_ref = (arg1)->MakeFromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25841 result = (wxDateTime *) &_result_ref;
25842 }
25843 wxPyEndAllowThreads(__tstate);
25844 if (PyErr_Occurred()) SWIG_fail;
25845 }
25846 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25847 {
25848 if (temp2) delete arg2;
25849 }
25850 return resultobj;
25851 fail:
25852 {
25853 if (temp2) delete arg2;
25854 }
25855 return NULL;
25856 }
25857
25858
25859 SWIGINTERN PyObject *_wrap_DateTime_ToUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25860 PyObject *resultobj = 0;
25861 wxDateTime *arg1 = (wxDateTime *) 0 ;
25862 bool arg2 = (bool) false ;
25863 wxDateTime result;
25864 void *argp1 = 0 ;
25865 int res1 = 0 ;
25866 bool val2 ;
25867 int ecode2 = 0 ;
25868 PyObject * obj0 = 0 ;
25869 PyObject * obj1 = 0 ;
25870 char * kwnames[] = {
25871 (char *) "self",(char *) "noDST", NULL
25872 };
25873
25874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToUTC",kwnames,&obj0,&obj1)) SWIG_fail;
25875 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25876 if (!SWIG_IsOK(res1)) {
25877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25878 }
25879 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25880 if (obj1) {
25881 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25882 if (!SWIG_IsOK(ecode2)) {
25883 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToUTC" "', expected argument " "2"" of type '" "bool""'");
25884 }
25885 arg2 = static_cast< bool >(val2);
25886 }
25887 {
25888 PyThreadState* __tstate = wxPyBeginAllowThreads();
25889 result = ((wxDateTime const *)arg1)->ToUTC(arg2);
25890 wxPyEndAllowThreads(__tstate);
25891 if (PyErr_Occurred()) SWIG_fail;
25892 }
25893 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25894 return resultobj;
25895 fail:
25896 return NULL;
25897 }
25898
25899
25900 SWIGINTERN PyObject *_wrap_DateTime_MakeUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25901 PyObject *resultobj = 0;
25902 wxDateTime *arg1 = (wxDateTime *) 0 ;
25903 bool arg2 = (bool) false ;
25904 wxDateTime *result = 0 ;
25905 void *argp1 = 0 ;
25906 int res1 = 0 ;
25907 bool val2 ;
25908 int ecode2 = 0 ;
25909 PyObject * obj0 = 0 ;
25910 PyObject * obj1 = 0 ;
25911 char * kwnames[] = {
25912 (char *) "self",(char *) "noDST", NULL
25913 };
25914
25915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeUTC",kwnames,&obj0,&obj1)) SWIG_fail;
25916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25917 if (!SWIG_IsOK(res1)) {
25918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
25919 }
25920 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25921 if (obj1) {
25922 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25923 if (!SWIG_IsOK(ecode2)) {
25924 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeUTC" "', expected argument " "2"" of type '" "bool""'");
25925 }
25926 arg2 = static_cast< bool >(val2);
25927 }
25928 {
25929 PyThreadState* __tstate = wxPyBeginAllowThreads();
25930 {
25931 wxDateTime &_result_ref = (arg1)->MakeUTC(arg2);
25932 result = (wxDateTime *) &_result_ref;
25933 }
25934 wxPyEndAllowThreads(__tstate);
25935 if (PyErr_Occurred()) SWIG_fail;
25936 }
25937 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25938 return resultobj;
25939 fail:
25940 return NULL;
25941 }
25942
25943
25944 SWIGINTERN PyObject *_wrap_DateTime_ToGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25945 PyObject *resultobj = 0;
25946 wxDateTime *arg1 = (wxDateTime *) 0 ;
25947 bool arg2 = (bool) false ;
25948 wxDateTime result;
25949 void *argp1 = 0 ;
25950 int res1 = 0 ;
25951 bool val2 ;
25952 int ecode2 = 0 ;
25953 PyObject * obj0 = 0 ;
25954 PyObject * obj1 = 0 ;
25955 char * kwnames[] = {
25956 (char *) "self",(char *) "noDST", NULL
25957 };
25958
25959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) SWIG_fail;
25960 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25961 if (!SWIG_IsOK(res1)) {
25962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToGMT" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25963 }
25964 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25965 if (obj1) {
25966 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25967 if (!SWIG_IsOK(ecode2)) {
25968 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToGMT" "', expected argument " "2"" of type '" "bool""'");
25969 }
25970 arg2 = static_cast< bool >(val2);
25971 }
25972 {
25973 PyThreadState* __tstate = wxPyBeginAllowThreads();
25974 result = ((wxDateTime const *)arg1)->ToGMT(arg2);
25975 wxPyEndAllowThreads(__tstate);
25976 if (PyErr_Occurred()) SWIG_fail;
25977 }
25978 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25979 return resultobj;
25980 fail:
25981 return NULL;
25982 }
25983
25984
25985 SWIGINTERN PyObject *_wrap_DateTime_MakeGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25986 PyObject *resultobj = 0;
25987 wxDateTime *arg1 = (wxDateTime *) 0 ;
25988 bool arg2 = (bool) false ;
25989 wxDateTime *result = 0 ;
25990 void *argp1 = 0 ;
25991 int res1 = 0 ;
25992 bool val2 ;
25993 int ecode2 = 0 ;
25994 PyObject * obj0 = 0 ;
25995 PyObject * obj1 = 0 ;
25996 char * kwnames[] = {
25997 (char *) "self",(char *) "noDST", NULL
25998 };
25999
26000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) SWIG_fail;
26001 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26002 if (!SWIG_IsOK(res1)) {
26003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeGMT" "', expected argument " "1"" of type '" "wxDateTime *""'");
26004 }
26005 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26006 if (obj1) {
26007 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26008 if (!SWIG_IsOK(ecode2)) {
26009 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeGMT" "', expected argument " "2"" of type '" "bool""'");
26010 }
26011 arg2 = static_cast< bool >(val2);
26012 }
26013 {
26014 PyThreadState* __tstate = wxPyBeginAllowThreads();
26015 {
26016 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
26017 result = (wxDateTime *) &_result_ref;
26018 }
26019 wxPyEndAllowThreads(__tstate);
26020 if (PyErr_Occurred()) SWIG_fail;
26021 }
26022 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26023 return resultobj;
26024 fail:
26025 return NULL;
26026 }
26027
26028
26029 SWIGINTERN PyObject *_wrap_DateTime_FromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26030 PyObject *resultobj = 0;
26031 wxDateTime *arg1 = (wxDateTime *) 0 ;
26032 bool arg2 = (bool) false ;
26033 wxDateTime result;
26034 void *argp1 = 0 ;
26035 int res1 = 0 ;
26036 bool val2 ;
26037 int ecode2 = 0 ;
26038 PyObject * obj0 = 0 ;
26039 PyObject * obj1 = 0 ;
26040 char * kwnames[] = {
26041 (char *) "self",(char *) "noDST", NULL
26042 };
26043
26044 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_FromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
26045 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26046 if (!SWIG_IsOK(res1)) {
26047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26048 }
26049 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26050 if (obj1) {
26051 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26052 if (!SWIG_IsOK(ecode2)) {
26053 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_FromUTC" "', expected argument " "2"" of type '" "bool""'");
26054 }
26055 arg2 = static_cast< bool >(val2);
26056 }
26057 {
26058 PyThreadState* __tstate = wxPyBeginAllowThreads();
26059 result = ((wxDateTime const *)arg1)->FromUTC(arg2);
26060 wxPyEndAllowThreads(__tstate);
26061 if (PyErr_Occurred()) SWIG_fail;
26062 }
26063 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26064 return resultobj;
26065 fail:
26066 return NULL;
26067 }
26068
26069
26070 SWIGINTERN PyObject *_wrap_DateTime_MakeFromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26071 PyObject *resultobj = 0;
26072 wxDateTime *arg1 = (wxDateTime *) 0 ;
26073 bool arg2 = (bool) false ;
26074 wxDateTime *result = 0 ;
26075 void *argp1 = 0 ;
26076 int res1 = 0 ;
26077 bool val2 ;
26078 int ecode2 = 0 ;
26079 PyObject * obj0 = 0 ;
26080 PyObject * obj1 = 0 ;
26081 char * kwnames[] = {
26082 (char *) "self",(char *) "noDST", NULL
26083 };
26084
26085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeFromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
26086 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26087 if (!SWIG_IsOK(res1)) {
26088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
26089 }
26090 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26091 if (obj1) {
26092 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26093 if (!SWIG_IsOK(ecode2)) {
26094 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeFromUTC" "', expected argument " "2"" of type '" "bool""'");
26095 }
26096 arg2 = static_cast< bool >(val2);
26097 }
26098 {
26099 PyThreadState* __tstate = wxPyBeginAllowThreads();
26100 {
26101 wxDateTime &_result_ref = (arg1)->MakeFromUTC(arg2);
26102 result = (wxDateTime *) &_result_ref;
26103 }
26104 wxPyEndAllowThreads(__tstate);
26105 if (PyErr_Occurred()) SWIG_fail;
26106 }
26107 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26108 return resultobj;
26109 fail:
26110 return NULL;
26111 }
26112
26113
26114 SWIGINTERN PyObject *_wrap_DateTime_IsDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26115 PyObject *resultobj = 0;
26116 wxDateTime *arg1 = (wxDateTime *) 0 ;
26117 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
26118 int result;
26119 void *argp1 = 0 ;
26120 int res1 = 0 ;
26121 int val2 ;
26122 int ecode2 = 0 ;
26123 PyObject * obj0 = 0 ;
26124 PyObject * obj1 = 0 ;
26125 char * kwnames[] = {
26126 (char *) "self",(char *) "country", NULL
26127 };
26128
26129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) SWIG_fail;
26130 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26131 if (!SWIG_IsOK(res1)) {
26132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsDST" "', expected argument " "1"" of type '" "wxDateTime *""'");
26133 }
26134 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26135 if (obj1) {
26136 ecode2 = SWIG_AsVal_int(obj1, &val2);
26137 if (!SWIG_IsOK(ecode2)) {
26138 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
26139 }
26140 arg2 = static_cast< wxDateTime::Country >(val2);
26141 }
26142 {
26143 PyThreadState* __tstate = wxPyBeginAllowThreads();
26144 result = (int)(arg1)->IsDST(arg2);
26145 wxPyEndAllowThreads(__tstate);
26146 if (PyErr_Occurred()) SWIG_fail;
26147 }
26148 resultobj = SWIG_From_int(static_cast< int >(result));
26149 return resultobj;
26150 fail:
26151 return NULL;
26152 }
26153
26154
26155 SWIGINTERN PyObject *_wrap_DateTime_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26156 PyObject *resultobj = 0;
26157 wxDateTime *arg1 = (wxDateTime *) 0 ;
26158 bool result;
26159 void *argp1 = 0 ;
26160 int res1 = 0 ;
26161 PyObject *swig_obj[1] ;
26162
26163 if (!args) SWIG_fail;
26164 swig_obj[0] = args;
26165 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26166 if (!SWIG_IsOK(res1)) {
26167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsValid" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26168 }
26169 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26170 {
26171 PyThreadState* __tstate = wxPyBeginAllowThreads();
26172 result = (bool)((wxDateTime const *)arg1)->IsValid();
26173 wxPyEndAllowThreads(__tstate);
26174 if (PyErr_Occurred()) SWIG_fail;
26175 }
26176 {
26177 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26178 }
26179 return resultobj;
26180 fail:
26181 return NULL;
26182 }
26183
26184
26185 SWIGINTERN PyObject *_wrap_DateTime_GetTicks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26186 PyObject *resultobj = 0;
26187 wxDateTime *arg1 = (wxDateTime *) 0 ;
26188 time_t result;
26189 void *argp1 = 0 ;
26190 int res1 = 0 ;
26191 PyObject *swig_obj[1] ;
26192
26193 if (!args) SWIG_fail;
26194 swig_obj[0] = args;
26195 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26196 if (!SWIG_IsOK(res1)) {
26197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetTicks" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26198 }
26199 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26200 {
26201 PyThreadState* __tstate = wxPyBeginAllowThreads();
26202 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
26203 wxPyEndAllowThreads(__tstate);
26204 if (PyErr_Occurred()) SWIG_fail;
26205 }
26206 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
26207 return resultobj;
26208 fail:
26209 return NULL;
26210 }
26211
26212
26213 SWIGINTERN PyObject *_wrap_DateTime_GetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26214 PyObject *resultobj = 0;
26215 wxDateTime *arg1 = (wxDateTime *) 0 ;
26216 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26217 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26218 int result;
26219 void *argp1 = 0 ;
26220 int res1 = 0 ;
26221 bool temp2 = false ;
26222 PyObject * obj0 = 0 ;
26223 PyObject * obj1 = 0 ;
26224 char * kwnames[] = {
26225 (char *) "self",(char *) "tz", NULL
26226 };
26227
26228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) SWIG_fail;
26229 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26230 if (!SWIG_IsOK(res1)) {
26231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26232 }
26233 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26234 if (obj1) {
26235 {
26236 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26237 temp2 = true;
26238 }
26239 }
26240 {
26241 PyThreadState* __tstate = wxPyBeginAllowThreads();
26242 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
26243 wxPyEndAllowThreads(__tstate);
26244 if (PyErr_Occurred()) SWIG_fail;
26245 }
26246 resultobj = SWIG_From_int(static_cast< int >(result));
26247 {
26248 if (temp2) delete arg2;
26249 }
26250 return resultobj;
26251 fail:
26252 {
26253 if (temp2) delete arg2;
26254 }
26255 return NULL;
26256 }
26257
26258
26259 SWIGINTERN PyObject *_wrap_DateTime_GetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26260 PyObject *resultobj = 0;
26261 wxDateTime *arg1 = (wxDateTime *) 0 ;
26262 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26263 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26264 wxDateTime::Month result;
26265 void *argp1 = 0 ;
26266 int res1 = 0 ;
26267 bool temp2 = false ;
26268 PyObject * obj0 = 0 ;
26269 PyObject * obj1 = 0 ;
26270 char * kwnames[] = {
26271 (char *) "self",(char *) "tz", NULL
26272 };
26273
26274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
26275 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26276 if (!SWIG_IsOK(res1)) {
26277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26278 }
26279 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26280 if (obj1) {
26281 {
26282 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26283 temp2 = true;
26284 }
26285 }
26286 {
26287 PyThreadState* __tstate = wxPyBeginAllowThreads();
26288 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
26289 wxPyEndAllowThreads(__tstate);
26290 if (PyErr_Occurred()) SWIG_fail;
26291 }
26292 resultobj = SWIG_From_int(static_cast< int >(result));
26293 {
26294 if (temp2) delete arg2;
26295 }
26296 return resultobj;
26297 fail:
26298 {
26299 if (temp2) delete arg2;
26300 }
26301 return NULL;
26302 }
26303
26304
26305 SWIGINTERN PyObject *_wrap_DateTime_GetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26306 PyObject *resultobj = 0;
26307 wxDateTime *arg1 = (wxDateTime *) 0 ;
26308 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26309 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26310 int result;
26311 void *argp1 = 0 ;
26312 int res1 = 0 ;
26313 bool temp2 = false ;
26314 PyObject * obj0 = 0 ;
26315 PyObject * obj1 = 0 ;
26316 char * kwnames[] = {
26317 (char *) "self",(char *) "tz", NULL
26318 };
26319
26320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) SWIG_fail;
26321 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26322 if (!SWIG_IsOK(res1)) {
26323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26324 }
26325 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26326 if (obj1) {
26327 {
26328 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26329 temp2 = true;
26330 }
26331 }
26332 {
26333 PyThreadState* __tstate = wxPyBeginAllowThreads();
26334 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
26335 wxPyEndAllowThreads(__tstate);
26336 if (PyErr_Occurred()) SWIG_fail;
26337 }
26338 resultobj = SWIG_From_int(static_cast< int >(result));
26339 {
26340 if (temp2) delete arg2;
26341 }
26342 return resultobj;
26343 fail:
26344 {
26345 if (temp2) delete arg2;
26346 }
26347 return NULL;
26348 }
26349
26350
26351 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26352 PyObject *resultobj = 0;
26353 wxDateTime *arg1 = (wxDateTime *) 0 ;
26354 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26355 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26356 wxDateTime::WeekDay result;
26357 void *argp1 = 0 ;
26358 int res1 = 0 ;
26359 bool temp2 = false ;
26360 PyObject * obj0 = 0 ;
26361 PyObject * obj1 = 0 ;
26362 char * kwnames[] = {
26363 (char *) "self",(char *) "tz", NULL
26364 };
26365
26366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
26367 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26368 if (!SWIG_IsOK(res1)) {
26369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26370 }
26371 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26372 if (obj1) {
26373 {
26374 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26375 temp2 = true;
26376 }
26377 }
26378 {
26379 PyThreadState* __tstate = wxPyBeginAllowThreads();
26380 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
26381 wxPyEndAllowThreads(__tstate);
26382 if (PyErr_Occurred()) SWIG_fail;
26383 }
26384 resultobj = SWIG_From_int(static_cast< int >(result));
26385 {
26386 if (temp2) delete arg2;
26387 }
26388 return resultobj;
26389 fail:
26390 {
26391 if (temp2) delete arg2;
26392 }
26393 return NULL;
26394 }
26395
26396
26397 SWIGINTERN PyObject *_wrap_DateTime_GetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26398 PyObject *resultobj = 0;
26399 wxDateTime *arg1 = (wxDateTime *) 0 ;
26400 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26401 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26402 int result;
26403 void *argp1 = 0 ;
26404 int res1 = 0 ;
26405 bool temp2 = false ;
26406 PyObject * obj0 = 0 ;
26407 PyObject * obj1 = 0 ;
26408 char * kwnames[] = {
26409 (char *) "self",(char *) "tz", NULL
26410 };
26411
26412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) SWIG_fail;
26413 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26414 if (!SWIG_IsOK(res1)) {
26415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetHour" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26416 }
26417 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26418 if (obj1) {
26419 {
26420 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26421 temp2 = true;
26422 }
26423 }
26424 {
26425 PyThreadState* __tstate = wxPyBeginAllowThreads();
26426 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
26427 wxPyEndAllowThreads(__tstate);
26428 if (PyErr_Occurred()) SWIG_fail;
26429 }
26430 resultobj = SWIG_From_int(static_cast< int >(result));
26431 {
26432 if (temp2) delete arg2;
26433 }
26434 return resultobj;
26435 fail:
26436 {
26437 if (temp2) delete arg2;
26438 }
26439 return NULL;
26440 }
26441
26442
26443 SWIGINTERN PyObject *_wrap_DateTime_GetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26444 PyObject *resultobj = 0;
26445 wxDateTime *arg1 = (wxDateTime *) 0 ;
26446 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26447 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26448 int result;
26449 void *argp1 = 0 ;
26450 int res1 = 0 ;
26451 bool temp2 = false ;
26452 PyObject * obj0 = 0 ;
26453 PyObject * obj1 = 0 ;
26454 char * kwnames[] = {
26455 (char *) "self",(char *) "tz", NULL
26456 };
26457
26458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
26459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26460 if (!SWIG_IsOK(res1)) {
26461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMinute" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26462 }
26463 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26464 if (obj1) {
26465 {
26466 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26467 temp2 = true;
26468 }
26469 }
26470 {
26471 PyThreadState* __tstate = wxPyBeginAllowThreads();
26472 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
26473 wxPyEndAllowThreads(__tstate);
26474 if (PyErr_Occurred()) SWIG_fail;
26475 }
26476 resultobj = SWIG_From_int(static_cast< int >(result));
26477 {
26478 if (temp2) delete arg2;
26479 }
26480 return resultobj;
26481 fail:
26482 {
26483 if (temp2) delete arg2;
26484 }
26485 return NULL;
26486 }
26487
26488
26489 SWIGINTERN PyObject *_wrap_DateTime_GetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26490 PyObject *resultobj = 0;
26491 wxDateTime *arg1 = (wxDateTime *) 0 ;
26492 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26493 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26494 int result;
26495 void *argp1 = 0 ;
26496 int res1 = 0 ;
26497 bool temp2 = false ;
26498 PyObject * obj0 = 0 ;
26499 PyObject * obj1 = 0 ;
26500 char * kwnames[] = {
26501 (char *) "self",(char *) "tz", NULL
26502 };
26503
26504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
26505 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26506 if (!SWIG_IsOK(res1)) {
26507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetSecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26508 }
26509 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26510 if (obj1) {
26511 {
26512 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26513 temp2 = true;
26514 }
26515 }
26516 {
26517 PyThreadState* __tstate = wxPyBeginAllowThreads();
26518 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
26519 wxPyEndAllowThreads(__tstate);
26520 if (PyErr_Occurred()) SWIG_fail;
26521 }
26522 resultobj = SWIG_From_int(static_cast< int >(result));
26523 {
26524 if (temp2) delete arg2;
26525 }
26526 return resultobj;
26527 fail:
26528 {
26529 if (temp2) delete arg2;
26530 }
26531 return NULL;
26532 }
26533
26534
26535 SWIGINTERN PyObject *_wrap_DateTime_GetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26536 PyObject *resultobj = 0;
26537 wxDateTime *arg1 = (wxDateTime *) 0 ;
26538 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26539 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26540 int result;
26541 void *argp1 = 0 ;
26542 int res1 = 0 ;
26543 bool temp2 = false ;
26544 PyObject * obj0 = 0 ;
26545 PyObject * obj1 = 0 ;
26546 char * kwnames[] = {
26547 (char *) "self",(char *) "tz", NULL
26548 };
26549
26550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
26551 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26552 if (!SWIG_IsOK(res1)) {
26553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMillisecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26554 }
26555 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26556 if (obj1) {
26557 {
26558 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26559 temp2 = true;
26560 }
26561 }
26562 {
26563 PyThreadState* __tstate = wxPyBeginAllowThreads();
26564 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
26565 wxPyEndAllowThreads(__tstate);
26566 if (PyErr_Occurred()) SWIG_fail;
26567 }
26568 resultobj = SWIG_From_int(static_cast< int >(result));
26569 {
26570 if (temp2) delete arg2;
26571 }
26572 return resultobj;
26573 fail:
26574 {
26575 if (temp2) delete arg2;
26576 }
26577 return NULL;
26578 }
26579
26580
26581 SWIGINTERN PyObject *_wrap_DateTime_GetDayOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26582 PyObject *resultobj = 0;
26583 wxDateTime *arg1 = (wxDateTime *) 0 ;
26584 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26585 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26586 int result;
26587 void *argp1 = 0 ;
26588 int res1 = 0 ;
26589 bool temp2 = false ;
26590 PyObject * obj0 = 0 ;
26591 PyObject * obj1 = 0 ;
26592 char * kwnames[] = {
26593 (char *) "self",(char *) "tz", NULL
26594 };
26595
26596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) SWIG_fail;
26597 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26598 if (!SWIG_IsOK(res1)) {
26599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDayOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26600 }
26601 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26602 if (obj1) {
26603 {
26604 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26605 temp2 = true;
26606 }
26607 }
26608 {
26609 PyThreadState* __tstate = wxPyBeginAllowThreads();
26610 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
26611 wxPyEndAllowThreads(__tstate);
26612 if (PyErr_Occurred()) SWIG_fail;
26613 }
26614 resultobj = SWIG_From_int(static_cast< int >(result));
26615 {
26616 if (temp2) delete arg2;
26617 }
26618 return resultobj;
26619 fail:
26620 {
26621 if (temp2) delete arg2;
26622 }
26623 return NULL;
26624 }
26625
26626
26627 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26628 PyObject *resultobj = 0;
26629 wxDateTime *arg1 = (wxDateTime *) 0 ;
26630 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
26631 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
26632 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
26633 int result;
26634 void *argp1 = 0 ;
26635 int res1 = 0 ;
26636 int val2 ;
26637 int ecode2 = 0 ;
26638 bool temp3 = false ;
26639 PyObject * obj0 = 0 ;
26640 PyObject * obj1 = 0 ;
26641 PyObject * obj2 = 0 ;
26642 char * kwnames[] = {
26643 (char *) "self",(char *) "flags",(char *) "tz", NULL
26644 };
26645
26646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26648 if (!SWIG_IsOK(res1)) {
26649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26650 }
26651 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26652 if (obj1) {
26653 ecode2 = SWIG_AsVal_int(obj1, &val2);
26654 if (!SWIG_IsOK(ecode2)) {
26655 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
26656 }
26657 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
26658 }
26659 if (obj2) {
26660 {
26661 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
26662 temp3 = true;
26663 }
26664 }
26665 {
26666 PyThreadState* __tstate = wxPyBeginAllowThreads();
26667 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear(arg2,(wxDateTime::TimeZone const &)*arg3);
26668 wxPyEndAllowThreads(__tstate);
26669 if (PyErr_Occurred()) SWIG_fail;
26670 }
26671 resultobj = SWIG_From_int(static_cast< int >(result));
26672 {
26673 if (temp3) delete arg3;
26674 }
26675 return resultobj;
26676 fail:
26677 {
26678 if (temp3) delete arg3;
26679 }
26680 return NULL;
26681 }
26682
26683
26684 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26685 PyObject *resultobj = 0;
26686 wxDateTime *arg1 = (wxDateTime *) 0 ;
26687 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
26688 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
26689 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
26690 int result;
26691 void *argp1 = 0 ;
26692 int res1 = 0 ;
26693 int val2 ;
26694 int ecode2 = 0 ;
26695 bool temp3 = false ;
26696 PyObject * obj0 = 0 ;
26697 PyObject * obj1 = 0 ;
26698 PyObject * obj2 = 0 ;
26699 char * kwnames[] = {
26700 (char *) "self",(char *) "flags",(char *) "tz", NULL
26701 };
26702
26703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26705 if (!SWIG_IsOK(res1)) {
26706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26707 }
26708 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26709 if (obj1) {
26710 ecode2 = SWIG_AsVal_int(obj1, &val2);
26711 if (!SWIG_IsOK(ecode2)) {
26712 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
26713 }
26714 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
26715 }
26716 if (obj2) {
26717 {
26718 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
26719 temp3 = true;
26720 }
26721 }
26722 {
26723 PyThreadState* __tstate = wxPyBeginAllowThreads();
26724 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth(arg2,(wxDateTime::TimeZone const &)*arg3);
26725 wxPyEndAllowThreads(__tstate);
26726 if (PyErr_Occurred()) SWIG_fail;
26727 }
26728 resultobj = SWIG_From_int(static_cast< int >(result));
26729 {
26730 if (temp3) delete arg3;
26731 }
26732 return resultobj;
26733 fail:
26734 {
26735 if (temp3) delete arg3;
26736 }
26737 return NULL;
26738 }
26739
26740
26741 SWIGINTERN PyObject *_wrap_DateTime_IsWorkDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26742 PyObject *resultobj = 0;
26743 wxDateTime *arg1 = (wxDateTime *) 0 ;
26744 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
26745 bool result;
26746 void *argp1 = 0 ;
26747 int res1 = 0 ;
26748 int val2 ;
26749 int ecode2 = 0 ;
26750 PyObject * obj0 = 0 ;
26751 PyObject * obj1 = 0 ;
26752 char * kwnames[] = {
26753 (char *) "self",(char *) "country", NULL
26754 };
26755
26756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) SWIG_fail;
26757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26758 if (!SWIG_IsOK(res1)) {
26759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsWorkDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26760 }
26761 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26762 if (obj1) {
26763 ecode2 = SWIG_AsVal_int(obj1, &val2);
26764 if (!SWIG_IsOK(ecode2)) {
26765 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsWorkDay" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
26766 }
26767 arg2 = static_cast< wxDateTime::Country >(val2);
26768 }
26769 {
26770 PyThreadState* __tstate = wxPyBeginAllowThreads();
26771 result = (bool)((wxDateTime const *)arg1)->IsWorkDay(arg2);
26772 wxPyEndAllowThreads(__tstate);
26773 if (PyErr_Occurred()) SWIG_fail;
26774 }
26775 {
26776 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26777 }
26778 return resultobj;
26779 fail:
26780 return NULL;
26781 }
26782
26783
26784 SWIGINTERN PyObject *_wrap_DateTime_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26785 PyObject *resultobj = 0;
26786 wxDateTime *arg1 = (wxDateTime *) 0 ;
26787 wxDateTime *arg2 = 0 ;
26788 bool result;
26789 void *argp1 = 0 ;
26790 int res1 = 0 ;
26791 void *argp2 = 0 ;
26792 int res2 = 0 ;
26793 PyObject * obj0 = 0 ;
26794 PyObject * obj1 = 0 ;
26795 char * kwnames[] = {
26796 (char *) "self",(char *) "datetime", NULL
26797 };
26798
26799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
26800 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26801 if (!SWIG_IsOK(res1)) {
26802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26803 }
26804 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26805 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26806 if (!SWIG_IsOK(res2)) {
26807 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26808 }
26809 if (!argp2) {
26810 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26811 }
26812 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26813 {
26814 PyThreadState* __tstate = wxPyBeginAllowThreads();
26815 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
26816 wxPyEndAllowThreads(__tstate);
26817 if (PyErr_Occurred()) SWIG_fail;
26818 }
26819 {
26820 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26821 }
26822 return resultobj;
26823 fail:
26824 return NULL;
26825 }
26826
26827
26828 SWIGINTERN PyObject *_wrap_DateTime_IsEarlierThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26829 PyObject *resultobj = 0;
26830 wxDateTime *arg1 = (wxDateTime *) 0 ;
26831 wxDateTime *arg2 = 0 ;
26832 bool result;
26833 void *argp1 = 0 ;
26834 int res1 = 0 ;
26835 void *argp2 = 0 ;
26836 int res2 = 0 ;
26837 PyObject * obj0 = 0 ;
26838 PyObject * obj1 = 0 ;
26839 char * kwnames[] = {
26840 (char *) "self",(char *) "datetime", NULL
26841 };
26842
26843 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) SWIG_fail;
26844 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26845 if (!SWIG_IsOK(res1)) {
26846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEarlierThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26847 }
26848 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26849 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26850 if (!SWIG_IsOK(res2)) {
26851 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26852 }
26853 if (!argp2) {
26854 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26855 }
26856 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26857 {
26858 PyThreadState* __tstate = wxPyBeginAllowThreads();
26859 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
26860 wxPyEndAllowThreads(__tstate);
26861 if (PyErr_Occurred()) SWIG_fail;
26862 }
26863 {
26864 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26865 }
26866 return resultobj;
26867 fail:
26868 return NULL;
26869 }
26870
26871
26872 SWIGINTERN PyObject *_wrap_DateTime_IsLaterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26873 PyObject *resultobj = 0;
26874 wxDateTime *arg1 = (wxDateTime *) 0 ;
26875 wxDateTime *arg2 = 0 ;
26876 bool result;
26877 void *argp1 = 0 ;
26878 int res1 = 0 ;
26879 void *argp2 = 0 ;
26880 int res2 = 0 ;
26881 PyObject * obj0 = 0 ;
26882 PyObject * obj1 = 0 ;
26883 char * kwnames[] = {
26884 (char *) "self",(char *) "datetime", NULL
26885 };
26886
26887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) SWIG_fail;
26888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26889 if (!SWIG_IsOK(res1)) {
26890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsLaterThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26891 }
26892 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26893 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26894 if (!SWIG_IsOK(res2)) {
26895 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26896 }
26897 if (!argp2) {
26898 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26899 }
26900 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26901 {
26902 PyThreadState* __tstate = wxPyBeginAllowThreads();
26903 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
26904 wxPyEndAllowThreads(__tstate);
26905 if (PyErr_Occurred()) SWIG_fail;
26906 }
26907 {
26908 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26909 }
26910 return resultobj;
26911 fail:
26912 return NULL;
26913 }
26914
26915
26916 SWIGINTERN PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26917 PyObject *resultobj = 0;
26918 wxDateTime *arg1 = (wxDateTime *) 0 ;
26919 wxDateTime *arg2 = 0 ;
26920 wxDateTime *arg3 = 0 ;
26921 bool result;
26922 void *argp1 = 0 ;
26923 int res1 = 0 ;
26924 void *argp2 = 0 ;
26925 int res2 = 0 ;
26926 void *argp3 = 0 ;
26927 int res3 = 0 ;
26928 PyObject * obj0 = 0 ;
26929 PyObject * obj1 = 0 ;
26930 PyObject * obj2 = 0 ;
26931 char * kwnames[] = {
26932 (char *) "self",(char *) "t1",(char *) "t2", NULL
26933 };
26934
26935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26937 if (!SWIG_IsOK(res1)) {
26938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26939 }
26940 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26941 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26942 if (!SWIG_IsOK(res2)) {
26943 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26944 }
26945 if (!argp2) {
26946 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26947 }
26948 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26949 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
26950 if (!SWIG_IsOK(res3)) {
26951 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
26952 }
26953 if (!argp3) {
26954 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
26955 }
26956 arg3 = reinterpret_cast< wxDateTime * >(argp3);
26957 {
26958 PyThreadState* __tstate = wxPyBeginAllowThreads();
26959 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
26960 wxPyEndAllowThreads(__tstate);
26961 if (PyErr_Occurred()) SWIG_fail;
26962 }
26963 {
26964 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26965 }
26966 return resultobj;
26967 fail:
26968 return NULL;
26969 }
26970
26971
26972 SWIGINTERN PyObject *_wrap_DateTime_IsBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26973 PyObject *resultobj = 0;
26974 wxDateTime *arg1 = (wxDateTime *) 0 ;
26975 wxDateTime *arg2 = 0 ;
26976 wxDateTime *arg3 = 0 ;
26977 bool result;
26978 void *argp1 = 0 ;
26979 int res1 = 0 ;
26980 void *argp2 = 0 ;
26981 int res2 = 0 ;
26982 void *argp3 = 0 ;
26983 int res3 = 0 ;
26984 PyObject * obj0 = 0 ;
26985 PyObject * obj1 = 0 ;
26986 PyObject * obj2 = 0 ;
26987 char * kwnames[] = {
26988 (char *) "self",(char *) "t1",(char *) "t2", NULL
26989 };
26990
26991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26993 if (!SWIG_IsOK(res1)) {
26994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26995 }
26996 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26997 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26998 if (!SWIG_IsOK(res2)) {
26999 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27000 }
27001 if (!argp2) {
27002 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27003 }
27004 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27005 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
27006 if (!SWIG_IsOK(res3)) {
27007 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
27008 }
27009 if (!argp3) {
27010 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
27011 }
27012 arg3 = reinterpret_cast< wxDateTime * >(argp3);
27013 {
27014 PyThreadState* __tstate = wxPyBeginAllowThreads();
27015 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
27016 wxPyEndAllowThreads(__tstate);
27017 if (PyErr_Occurred()) SWIG_fail;
27018 }
27019 {
27020 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27021 }
27022 return resultobj;
27023 fail:
27024 return NULL;
27025 }
27026
27027
27028 SWIGINTERN PyObject *_wrap_DateTime_IsSameDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27029 PyObject *resultobj = 0;
27030 wxDateTime *arg1 = (wxDateTime *) 0 ;
27031 wxDateTime *arg2 = 0 ;
27032 bool result;
27033 void *argp1 = 0 ;
27034 int res1 = 0 ;
27035 void *argp2 = 0 ;
27036 int res2 = 0 ;
27037 PyObject * obj0 = 0 ;
27038 PyObject * obj1 = 0 ;
27039 char * kwnames[] = {
27040 (char *) "self",(char *) "dt", NULL
27041 };
27042
27043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) SWIG_fail;
27044 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27045 if (!SWIG_IsOK(res1)) {
27046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27047 }
27048 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27049 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27050 if (!SWIG_IsOK(res2)) {
27051 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27052 }
27053 if (!argp2) {
27054 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27055 }
27056 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27057 {
27058 PyThreadState* __tstate = wxPyBeginAllowThreads();
27059 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
27060 wxPyEndAllowThreads(__tstate);
27061 if (PyErr_Occurred()) SWIG_fail;
27062 }
27063 {
27064 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27065 }
27066 return resultobj;
27067 fail:
27068 return NULL;
27069 }
27070
27071
27072 SWIGINTERN PyObject *_wrap_DateTime_IsSameTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27073 PyObject *resultobj = 0;
27074 wxDateTime *arg1 = (wxDateTime *) 0 ;
27075 wxDateTime *arg2 = 0 ;
27076 bool result;
27077 void *argp1 = 0 ;
27078 int res1 = 0 ;
27079 void *argp2 = 0 ;
27080 int res2 = 0 ;
27081 PyObject * obj0 = 0 ;
27082 PyObject * obj1 = 0 ;
27083 char * kwnames[] = {
27084 (char *) "self",(char *) "dt", NULL
27085 };
27086
27087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) SWIG_fail;
27088 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27089 if (!SWIG_IsOK(res1)) {
27090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27091 }
27092 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27093 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27094 if (!SWIG_IsOK(res2)) {
27095 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27096 }
27097 if (!argp2) {
27098 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27099 }
27100 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27101 {
27102 PyThreadState* __tstate = wxPyBeginAllowThreads();
27103 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
27104 wxPyEndAllowThreads(__tstate);
27105 if (PyErr_Occurred()) SWIG_fail;
27106 }
27107 {
27108 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27109 }
27110 return resultobj;
27111 fail:
27112 return NULL;
27113 }
27114
27115
27116 SWIGINTERN PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27117 PyObject *resultobj = 0;
27118 wxDateTime *arg1 = (wxDateTime *) 0 ;
27119 wxDateTime *arg2 = 0 ;
27120 wxTimeSpan *arg3 = 0 ;
27121 bool result;
27122 void *argp1 = 0 ;
27123 int res1 = 0 ;
27124 void *argp2 = 0 ;
27125 int res2 = 0 ;
27126 void *argp3 = 0 ;
27127 int res3 = 0 ;
27128 PyObject * obj0 = 0 ;
27129 PyObject * obj1 = 0 ;
27130 PyObject * obj2 = 0 ;
27131 char * kwnames[] = {
27132 (char *) "self",(char *) "dt",(char *) "ts", NULL
27133 };
27134
27135 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27136 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27137 if (!SWIG_IsOK(res1)) {
27138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27139 }
27140 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27141 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27142 if (!SWIG_IsOK(res2)) {
27143 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27144 }
27145 if (!argp2) {
27146 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27147 }
27148 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27149 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27150 if (!SWIG_IsOK(res3)) {
27151 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
27152 }
27153 if (!argp3) {
27154 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
27155 }
27156 arg3 = reinterpret_cast< wxTimeSpan * >(argp3);
27157 {
27158 PyThreadState* __tstate = wxPyBeginAllowThreads();
27159 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
27160 wxPyEndAllowThreads(__tstate);
27161 if (PyErr_Occurred()) SWIG_fail;
27162 }
27163 {
27164 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27165 }
27166 return resultobj;
27167 fail:
27168 return NULL;
27169 }
27170
27171
27172 SWIGINTERN PyObject *_wrap_DateTime_AddTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27173 PyObject *resultobj = 0;
27174 wxDateTime *arg1 = (wxDateTime *) 0 ;
27175 wxTimeSpan *arg2 = 0 ;
27176 wxDateTime *result = 0 ;
27177 void *argp1 = 0 ;
27178 int res1 = 0 ;
27179 void *argp2 = 0 ;
27180 int res2 = 0 ;
27181 PyObject * obj0 = 0 ;
27182 PyObject * obj1 = 0 ;
27183 char * kwnames[] = {
27184 (char *) "self",(char *) "diff", NULL
27185 };
27186
27187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) SWIG_fail;
27188 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27189 if (!SWIG_IsOK(res1)) {
27190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27191 }
27192 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27193 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27194 if (!SWIG_IsOK(res2)) {
27195 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27196 }
27197 if (!argp2) {
27198 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27199 }
27200 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27201 {
27202 PyThreadState* __tstate = wxPyBeginAllowThreads();
27203 {
27204 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
27205 result = (wxDateTime *) &_result_ref;
27206 }
27207 wxPyEndAllowThreads(__tstate);
27208 if (PyErr_Occurred()) SWIG_fail;
27209 }
27210 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27211 return resultobj;
27212 fail:
27213 return NULL;
27214 }
27215
27216
27217 SWIGINTERN PyObject *_wrap_DateTime_AddDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27218 PyObject *resultobj = 0;
27219 wxDateTime *arg1 = (wxDateTime *) 0 ;
27220 wxDateSpan *arg2 = 0 ;
27221 wxDateTime *result = 0 ;
27222 void *argp1 = 0 ;
27223 int res1 = 0 ;
27224 void *argp2 = 0 ;
27225 int res2 = 0 ;
27226 PyObject * obj0 = 0 ;
27227 PyObject * obj1 = 0 ;
27228 char * kwnames[] = {
27229 (char *) "self",(char *) "diff", NULL
27230 };
27231
27232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) SWIG_fail;
27233 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27234 if (!SWIG_IsOK(res1)) {
27235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27236 }
27237 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27238 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27239 if (!SWIG_IsOK(res2)) {
27240 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27241 }
27242 if (!argp2) {
27243 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27244 }
27245 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27246 {
27247 PyThreadState* __tstate = wxPyBeginAllowThreads();
27248 {
27249 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
27250 result = (wxDateTime *) &_result_ref;
27251 }
27252 wxPyEndAllowThreads(__tstate);
27253 if (PyErr_Occurred()) SWIG_fail;
27254 }
27255 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27256 return resultobj;
27257 fail:
27258 return NULL;
27259 }
27260
27261
27262 SWIGINTERN PyObject *_wrap_DateTime_SubtractTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27263 PyObject *resultobj = 0;
27264 wxDateTime *arg1 = (wxDateTime *) 0 ;
27265 wxTimeSpan *arg2 = 0 ;
27266 wxDateTime *result = 0 ;
27267 void *argp1 = 0 ;
27268 int res1 = 0 ;
27269 void *argp2 = 0 ;
27270 int res2 = 0 ;
27271 PyObject * obj0 = 0 ;
27272 PyObject * obj1 = 0 ;
27273 char * kwnames[] = {
27274 (char *) "self",(char *) "diff", NULL
27275 };
27276
27277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) SWIG_fail;
27278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27279 if (!SWIG_IsOK(res1)) {
27280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27281 }
27282 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27283 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27284 if (!SWIG_IsOK(res2)) {
27285 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27286 }
27287 if (!argp2) {
27288 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27289 }
27290 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27291 {
27292 PyThreadState* __tstate = wxPyBeginAllowThreads();
27293 {
27294 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
27295 result = (wxDateTime *) &_result_ref;
27296 }
27297 wxPyEndAllowThreads(__tstate);
27298 if (PyErr_Occurred()) SWIG_fail;
27299 }
27300 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27301 return resultobj;
27302 fail:
27303 return NULL;
27304 }
27305
27306
27307 SWIGINTERN PyObject *_wrap_DateTime_SubtractDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27308 PyObject *resultobj = 0;
27309 wxDateTime *arg1 = (wxDateTime *) 0 ;
27310 wxDateSpan *arg2 = 0 ;
27311 wxDateTime *result = 0 ;
27312 void *argp1 = 0 ;
27313 int res1 = 0 ;
27314 void *argp2 = 0 ;
27315 int res2 = 0 ;
27316 PyObject * obj0 = 0 ;
27317 PyObject * obj1 = 0 ;
27318 char * kwnames[] = {
27319 (char *) "self",(char *) "diff", NULL
27320 };
27321
27322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) SWIG_fail;
27323 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27324 if (!SWIG_IsOK(res1)) {
27325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27326 }
27327 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27328 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27329 if (!SWIG_IsOK(res2)) {
27330 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27331 }
27332 if (!argp2) {
27333 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27334 }
27335 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27336 {
27337 PyThreadState* __tstate = wxPyBeginAllowThreads();
27338 {
27339 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
27340 result = (wxDateTime *) &_result_ref;
27341 }
27342 wxPyEndAllowThreads(__tstate);
27343 if (PyErr_Occurred()) SWIG_fail;
27344 }
27345 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27346 return resultobj;
27347 fail:
27348 return NULL;
27349 }
27350
27351
27352 SWIGINTERN PyObject *_wrap_DateTime_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27353 PyObject *resultobj = 0;
27354 wxDateTime *arg1 = (wxDateTime *) 0 ;
27355 wxDateTime *arg2 = 0 ;
27356 wxTimeSpan result;
27357 void *argp1 = 0 ;
27358 int res1 = 0 ;
27359 void *argp2 = 0 ;
27360 int res2 = 0 ;
27361 PyObject * obj0 = 0 ;
27362 PyObject * obj1 = 0 ;
27363 char * kwnames[] = {
27364 (char *) "self",(char *) "dt", NULL
27365 };
27366
27367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
27368 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27369 if (!SWIG_IsOK(res1)) {
27370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Subtract" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27371 }
27372 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27373 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27374 if (!SWIG_IsOK(res2)) {
27375 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27376 }
27377 if (!argp2) {
27378 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27379 }
27380 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27381 {
27382 PyThreadState* __tstate = wxPyBeginAllowThreads();
27383 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
27384 wxPyEndAllowThreads(__tstate);
27385 if (PyErr_Occurred()) SWIG_fail;
27386 }
27387 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27388 return resultobj;
27389 fail:
27390 return NULL;
27391 }
27392
27393
27394 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27395 PyObject *resultobj = 0;
27396 wxDateTime *arg1 = (wxDateTime *) 0 ;
27397 wxTimeSpan *arg2 = 0 ;
27398 wxDateTime *result = 0 ;
27399 void *argp1 = 0 ;
27400 int res1 = 0 ;
27401 void *argp2 = 0 ;
27402 int res2 = 0 ;
27403
27404 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27406 if (!SWIG_IsOK(res1)) {
27407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27408 }
27409 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27410 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27411 if (!SWIG_IsOK(res2)) {
27412 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27413 }
27414 if (!argp2) {
27415 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27416 }
27417 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27418 {
27419 PyThreadState* __tstate = wxPyBeginAllowThreads();
27420 {
27421 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
27422 result = (wxDateTime *) &_result_ref;
27423 }
27424 wxPyEndAllowThreads(__tstate);
27425 if (PyErr_Occurred()) SWIG_fail;
27426 }
27427 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27428 return resultobj;
27429 fail:
27430 return NULL;
27431 }
27432
27433
27434 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27435 PyObject *resultobj = 0;
27436 wxDateTime *arg1 = (wxDateTime *) 0 ;
27437 wxDateSpan *arg2 = 0 ;
27438 wxDateTime *result = 0 ;
27439 void *argp1 = 0 ;
27440 int res1 = 0 ;
27441 void *argp2 = 0 ;
27442 int res2 = 0 ;
27443
27444 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27446 if (!SWIG_IsOK(res1)) {
27447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27448 }
27449 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27450 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27451 if (!SWIG_IsOK(res2)) {
27452 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27453 }
27454 if (!argp2) {
27455 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27456 }
27457 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27458 {
27459 PyThreadState* __tstate = wxPyBeginAllowThreads();
27460 {
27461 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
27462 result = (wxDateTime *) &_result_ref;
27463 }
27464 wxPyEndAllowThreads(__tstate);
27465 if (PyErr_Occurred()) SWIG_fail;
27466 }
27467 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27468 return resultobj;
27469 fail:
27470 return NULL;
27471 }
27472
27473
27474 SWIGINTERN PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
27475 int argc;
27476 PyObject *argv[3];
27477
27478 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___iadd__",0,2,argv))) SWIG_fail;
27479 --argc;
27480 if (argc == 2) {
27481 int _v = 0;
27482 {
27483 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27484 _v = SWIG_CheckState(res);
27485 }
27486 if (!_v) goto check_1;
27487 return _wrap_DateTime___iadd____SWIG_0(self, argc, argv);
27488 }
27489 check_1:
27490
27491 if (argc == 2) {
27492 return _wrap_DateTime___iadd____SWIG_1(self, argc, argv);
27493 }
27494
27495 fail:
27496 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
27497 return NULL;
27498 }
27499
27500
27501 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27502 PyObject *resultobj = 0;
27503 wxDateTime *arg1 = (wxDateTime *) 0 ;
27504 wxTimeSpan *arg2 = 0 ;
27505 wxDateTime *result = 0 ;
27506 void *argp1 = 0 ;
27507 int res1 = 0 ;
27508 void *argp2 = 0 ;
27509 int res2 = 0 ;
27510
27511 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27512 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27513 if (!SWIG_IsOK(res1)) {
27514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27515 }
27516 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27517 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27518 if (!SWIG_IsOK(res2)) {
27519 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27520 }
27521 if (!argp2) {
27522 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27523 }
27524 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27525 {
27526 PyThreadState* __tstate = wxPyBeginAllowThreads();
27527 {
27528 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
27529 result = (wxDateTime *) &_result_ref;
27530 }
27531 wxPyEndAllowThreads(__tstate);
27532 if (PyErr_Occurred()) SWIG_fail;
27533 }
27534 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27535 return resultobj;
27536 fail:
27537 return NULL;
27538 }
27539
27540
27541 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27542 PyObject *resultobj = 0;
27543 wxDateTime *arg1 = (wxDateTime *) 0 ;
27544 wxDateSpan *arg2 = 0 ;
27545 wxDateTime *result = 0 ;
27546 void *argp1 = 0 ;
27547 int res1 = 0 ;
27548 void *argp2 = 0 ;
27549 int res2 = 0 ;
27550
27551 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27553 if (!SWIG_IsOK(res1)) {
27554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27555 }
27556 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27557 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27558 if (!SWIG_IsOK(res2)) {
27559 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27560 }
27561 if (!argp2) {
27562 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27563 }
27564 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27565 {
27566 PyThreadState* __tstate = wxPyBeginAllowThreads();
27567 {
27568 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
27569 result = (wxDateTime *) &_result_ref;
27570 }
27571 wxPyEndAllowThreads(__tstate);
27572 if (PyErr_Occurred()) SWIG_fail;
27573 }
27574 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27575 return resultobj;
27576 fail:
27577 return NULL;
27578 }
27579
27580
27581 SWIGINTERN PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
27582 int argc;
27583 PyObject *argv[3];
27584
27585 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___isub__",0,2,argv))) SWIG_fail;
27586 --argc;
27587 if (argc == 2) {
27588 int _v = 0;
27589 {
27590 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27591 _v = SWIG_CheckState(res);
27592 }
27593 if (!_v) goto check_1;
27594 return _wrap_DateTime___isub____SWIG_0(self, argc, argv);
27595 }
27596 check_1:
27597
27598 if (argc == 2) {
27599 return _wrap_DateTime___isub____SWIG_1(self, argc, argv);
27600 }
27601
27602 fail:
27603 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
27604 return NULL;
27605 }
27606
27607
27608 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27609 PyObject *resultobj = 0;
27610 wxDateTime *arg1 = (wxDateTime *) 0 ;
27611 wxTimeSpan *arg2 = 0 ;
27612 wxDateTime result;
27613 void *argp1 = 0 ;
27614 int res1 = 0 ;
27615 void *argp2 = 0 ;
27616 int res2 = 0 ;
27617
27618 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27620 if (!SWIG_IsOK(res1)) {
27621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27622 }
27623 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27624 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27625 if (!SWIG_IsOK(res2)) {
27626 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27627 }
27628 if (!argp2) {
27629 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27630 }
27631 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27632 {
27633 PyThreadState* __tstate = wxPyBeginAllowThreads();
27634 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
27635 wxPyEndAllowThreads(__tstate);
27636 if (PyErr_Occurred()) SWIG_fail;
27637 }
27638 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27639 return resultobj;
27640 fail:
27641 return NULL;
27642 }
27643
27644
27645 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27646 PyObject *resultobj = 0;
27647 wxDateTime *arg1 = (wxDateTime *) 0 ;
27648 wxDateSpan *arg2 = 0 ;
27649 wxDateTime result;
27650 void *argp1 = 0 ;
27651 int res1 = 0 ;
27652 void *argp2 = 0 ;
27653 int res2 = 0 ;
27654
27655 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27657 if (!SWIG_IsOK(res1)) {
27658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27659 }
27660 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27661 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27662 if (!SWIG_IsOK(res2)) {
27663 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27664 }
27665 if (!argp2) {
27666 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27667 }
27668 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27669 {
27670 PyThreadState* __tstate = wxPyBeginAllowThreads();
27671 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
27672 wxPyEndAllowThreads(__tstate);
27673 if (PyErr_Occurred()) SWIG_fail;
27674 }
27675 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27676 return resultobj;
27677 fail:
27678 return NULL;
27679 }
27680
27681
27682 SWIGINTERN PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
27683 int argc;
27684 PyObject *argv[3];
27685
27686 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___add__",0,2,argv))) SWIG_fail;
27687 --argc;
27688 if (argc == 2) {
27689 int _v = 0;
27690 {
27691 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27692 _v = SWIG_CheckState(res);
27693 }
27694 if (!_v) goto check_1;
27695 return _wrap_DateTime___add____SWIG_0(self, argc, argv);
27696 }
27697 check_1:
27698
27699 if (argc == 2) {
27700 return _wrap_DateTime___add____SWIG_1(self, argc, argv);
27701 }
27702
27703 fail:
27704 Py_INCREF(Py_NotImplemented);
27705 return Py_NotImplemented;
27706 }
27707
27708
27709 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27710 PyObject *resultobj = 0;
27711 wxDateTime *arg1 = (wxDateTime *) 0 ;
27712 wxDateTime *arg2 = 0 ;
27713 wxTimeSpan result;
27714 void *argp1 = 0 ;
27715 int res1 = 0 ;
27716 void *argp2 = 0 ;
27717 int res2 = 0 ;
27718
27719 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27721 if (!SWIG_IsOK(res1)) {
27722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27723 }
27724 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27725 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27726 if (!SWIG_IsOK(res2)) {
27727 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27728 }
27729 if (!argp2) {
27730 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27731 }
27732 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27733 {
27734 PyThreadState* __tstate = wxPyBeginAllowThreads();
27735 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
27736 wxPyEndAllowThreads(__tstate);
27737 if (PyErr_Occurred()) SWIG_fail;
27738 }
27739 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27740 return resultobj;
27741 fail:
27742 return NULL;
27743 }
27744
27745
27746 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27747 PyObject *resultobj = 0;
27748 wxDateTime *arg1 = (wxDateTime *) 0 ;
27749 wxTimeSpan *arg2 = 0 ;
27750 wxDateTime result;
27751 void *argp1 = 0 ;
27752 int res1 = 0 ;
27753 void *argp2 = 0 ;
27754 int res2 = 0 ;
27755
27756 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27757 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27758 if (!SWIG_IsOK(res1)) {
27759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27760 }
27761 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27762 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27763 if (!SWIG_IsOK(res2)) {
27764 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27765 }
27766 if (!argp2) {
27767 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27768 }
27769 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27770 {
27771 PyThreadState* __tstate = wxPyBeginAllowThreads();
27772 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
27773 wxPyEndAllowThreads(__tstate);
27774 if (PyErr_Occurred()) SWIG_fail;
27775 }
27776 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27777 return resultobj;
27778 fail:
27779 return NULL;
27780 }
27781
27782
27783 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27784 PyObject *resultobj = 0;
27785 wxDateTime *arg1 = (wxDateTime *) 0 ;
27786 wxDateSpan *arg2 = 0 ;
27787 wxDateTime result;
27788 void *argp1 = 0 ;
27789 int res1 = 0 ;
27790 void *argp2 = 0 ;
27791 int res2 = 0 ;
27792
27793 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27795 if (!SWIG_IsOK(res1)) {
27796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27797 }
27798 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27799 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27800 if (!SWIG_IsOK(res2)) {
27801 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27802 }
27803 if (!argp2) {
27804 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27805 }
27806 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27807 {
27808 PyThreadState* __tstate = wxPyBeginAllowThreads();
27809 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
27810 wxPyEndAllowThreads(__tstate);
27811 if (PyErr_Occurred()) SWIG_fail;
27812 }
27813 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27814 return resultobj;
27815 fail:
27816 return NULL;
27817 }
27818
27819
27820 SWIGINTERN PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
27821 int argc;
27822 PyObject *argv[3];
27823
27824 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___sub__",0,2,argv))) SWIG_fail;
27825 --argc;
27826 if (argc == 2) {
27827 int _v = 0;
27828 {
27829 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDateTime, 0);
27830 _v = SWIG_CheckState(res);
27831 }
27832 if (!_v) goto check_1;
27833 return _wrap_DateTime___sub____SWIG_0(self, argc, argv);
27834 }
27835 check_1:
27836
27837 if (argc == 2) {
27838 int _v = 0;
27839 {
27840 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27841 _v = SWIG_CheckState(res);
27842 }
27843 if (!_v) goto check_2;
27844 return _wrap_DateTime___sub____SWIG_1(self, argc, argv);
27845 }
27846 check_2:
27847
27848 if (argc == 2) {
27849 return _wrap_DateTime___sub____SWIG_2(self, argc, argv);
27850 }
27851
27852 fail:
27853 Py_INCREF(Py_NotImplemented);
27854 return Py_NotImplemented;
27855 }
27856
27857
27858 SWIGINTERN PyObject *_wrap_DateTime___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27859 PyObject *resultobj = 0;
27860 wxDateTime *arg1 = (wxDateTime *) 0 ;
27861 wxDateTime *arg2 = (wxDateTime *) 0 ;
27862 bool result;
27863 void *argp1 = 0 ;
27864 int res1 = 0 ;
27865 void *argp2 = 0 ;
27866 int res2 = 0 ;
27867 PyObject * obj0 = 0 ;
27868 PyObject * obj1 = 0 ;
27869 char * kwnames[] = {
27870 (char *) "self",(char *) "other", NULL
27871 };
27872
27873 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
27874 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27875 if (!SWIG_IsOK(res1)) {
27876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___lt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27877 }
27878 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27879 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27880 if (!SWIG_IsOK(res2)) {
27881 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___lt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
27882 }
27883 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27884 {
27885 PyThreadState* __tstate = wxPyBeginAllowThreads();
27886 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
27887 wxPyEndAllowThreads(__tstate);
27888 if (PyErr_Occurred()) SWIG_fail;
27889 }
27890 {
27891 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27892 }
27893 return resultobj;
27894 fail:
27895 return NULL;
27896 }
27897
27898
27899 SWIGINTERN PyObject *_wrap_DateTime___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27900 PyObject *resultobj = 0;
27901 wxDateTime *arg1 = (wxDateTime *) 0 ;
27902 wxDateTime *arg2 = (wxDateTime *) 0 ;
27903 bool result;
27904 void *argp1 = 0 ;
27905 int res1 = 0 ;
27906 void *argp2 = 0 ;
27907 int res2 = 0 ;
27908 PyObject * obj0 = 0 ;
27909 PyObject * obj1 = 0 ;
27910 char * kwnames[] = {
27911 (char *) "self",(char *) "other", NULL
27912 };
27913
27914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) SWIG_fail;
27915 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27916 if (!SWIG_IsOK(res1)) {
27917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___le__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27918 }
27919 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27920 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27921 if (!SWIG_IsOK(res2)) {
27922 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___le__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
27923 }
27924 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27925 {
27926 PyThreadState* __tstate = wxPyBeginAllowThreads();
27927 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
27928 wxPyEndAllowThreads(__tstate);
27929 if (PyErr_Occurred()) SWIG_fail;
27930 }
27931 {
27932 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27933 }
27934 return resultobj;
27935 fail:
27936 return NULL;
27937 }
27938
27939
27940 SWIGINTERN PyObject *_wrap_DateTime___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27941 PyObject *resultobj = 0;
27942 wxDateTime *arg1 = (wxDateTime *) 0 ;
27943 wxDateTime *arg2 = (wxDateTime *) 0 ;
27944 bool result;
27945 void *argp1 = 0 ;
27946 int res1 = 0 ;
27947 void *argp2 = 0 ;
27948 int res2 = 0 ;
27949 PyObject * obj0 = 0 ;
27950 PyObject * obj1 = 0 ;
27951 char * kwnames[] = {
27952 (char *) "self",(char *) "other", NULL
27953 };
27954
27955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
27956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27957 if (!SWIG_IsOK(res1)) {
27958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___gt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27959 }
27960 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27961 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27962 if (!SWIG_IsOK(res2)) {
27963 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___gt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
27964 }
27965 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27966 {
27967 PyThreadState* __tstate = wxPyBeginAllowThreads();
27968 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
27969 wxPyEndAllowThreads(__tstate);
27970 if (PyErr_Occurred()) SWIG_fail;
27971 }
27972 {
27973 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27974 }
27975 return resultobj;
27976 fail:
27977 return NULL;
27978 }
27979
27980
27981 SWIGINTERN PyObject *_wrap_DateTime___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27982 PyObject *resultobj = 0;
27983 wxDateTime *arg1 = (wxDateTime *) 0 ;
27984 wxDateTime *arg2 = (wxDateTime *) 0 ;
27985 bool result;
27986 void *argp1 = 0 ;
27987 int res1 = 0 ;
27988 void *argp2 = 0 ;
27989 int res2 = 0 ;
27990 PyObject * obj0 = 0 ;
27991 PyObject * obj1 = 0 ;
27992 char * kwnames[] = {
27993 (char *) "self",(char *) "other", NULL
27994 };
27995
27996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
27997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27998 if (!SWIG_IsOK(res1)) {
27999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ge__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28000 }
28001 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28002 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28003 if (!SWIG_IsOK(res2)) {
28004 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ge__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28005 }
28006 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28007 {
28008 PyThreadState* __tstate = wxPyBeginAllowThreads();
28009 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
28010 wxPyEndAllowThreads(__tstate);
28011 if (PyErr_Occurred()) SWIG_fail;
28012 }
28013 {
28014 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28015 }
28016 return resultobj;
28017 fail:
28018 return NULL;
28019 }
28020
28021
28022 SWIGINTERN PyObject *_wrap_DateTime___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28023 PyObject *resultobj = 0;
28024 wxDateTime *arg1 = (wxDateTime *) 0 ;
28025 wxDateTime *arg2 = (wxDateTime *) 0 ;
28026 bool result;
28027 void *argp1 = 0 ;
28028 int res1 = 0 ;
28029 void *argp2 = 0 ;
28030 int res2 = 0 ;
28031 PyObject * obj0 = 0 ;
28032 PyObject * obj1 = 0 ;
28033 char * kwnames[] = {
28034 (char *) "self",(char *) "other", NULL
28035 };
28036
28037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
28038 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28039 if (!SWIG_IsOK(res1)) {
28040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___eq__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28041 }
28042 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28043 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28044 if (!SWIG_IsOK(res2)) {
28045 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___eq__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28046 }
28047 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28048 {
28049 PyThreadState* __tstate = wxPyBeginAllowThreads();
28050 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
28051 wxPyEndAllowThreads(__tstate);
28052 if (PyErr_Occurred()) SWIG_fail;
28053 }
28054 {
28055 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28056 }
28057 return resultobj;
28058 fail:
28059 return NULL;
28060 }
28061
28062
28063 SWIGINTERN PyObject *_wrap_DateTime___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28064 PyObject *resultobj = 0;
28065 wxDateTime *arg1 = (wxDateTime *) 0 ;
28066 wxDateTime *arg2 = (wxDateTime *) 0 ;
28067 bool result;
28068 void *argp1 = 0 ;
28069 int res1 = 0 ;
28070 void *argp2 = 0 ;
28071 int res2 = 0 ;
28072 PyObject * obj0 = 0 ;
28073 PyObject * obj1 = 0 ;
28074 char * kwnames[] = {
28075 (char *) "self",(char *) "other", NULL
28076 };
28077
28078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
28079 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28080 if (!SWIG_IsOK(res1)) {
28081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ne__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28082 }
28083 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28084 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28085 if (!SWIG_IsOK(res2)) {
28086 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ne__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28087 }
28088 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28089 {
28090 PyThreadState* __tstate = wxPyBeginAllowThreads();
28091 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
28092 wxPyEndAllowThreads(__tstate);
28093 if (PyErr_Occurred()) SWIG_fail;
28094 }
28095 {
28096 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28097 }
28098 return resultobj;
28099 fail:
28100 return NULL;
28101 }
28102
28103
28104 SWIGINTERN PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28105 PyObject *resultobj = 0;
28106 wxDateTime *arg1 = (wxDateTime *) 0 ;
28107 wxString *arg2 = 0 ;
28108 int result;
28109 void *argp1 = 0 ;
28110 int res1 = 0 ;
28111 bool temp2 = false ;
28112 PyObject * obj0 = 0 ;
28113 PyObject * obj1 = 0 ;
28114 char * kwnames[] = {
28115 (char *) "self",(char *) "date", NULL
28116 };
28117
28118 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) SWIG_fail;
28119 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28120 if (!SWIG_IsOK(res1)) {
28121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseRfc822Date" "', expected argument " "1"" of type '" "wxDateTime *""'");
28122 }
28123 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28124 {
28125 arg2 = wxString_in_helper(obj1);
28126 if (arg2 == NULL) SWIG_fail;
28127 temp2 = true;
28128 }
28129 {
28130 PyThreadState* __tstate = wxPyBeginAllowThreads();
28131 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
28132 wxPyEndAllowThreads(__tstate);
28133 if (PyErr_Occurred()) SWIG_fail;
28134 }
28135 resultobj = SWIG_From_int(static_cast< int >(result));
28136 {
28137 if (temp2)
28138 delete arg2;
28139 }
28140 return resultobj;
28141 fail:
28142 {
28143 if (temp2)
28144 delete arg2;
28145 }
28146 return NULL;
28147 }
28148
28149
28150 SWIGINTERN PyObject *_wrap_DateTime_ParseFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28151 PyObject *resultobj = 0;
28152 wxDateTime *arg1 = (wxDateTime *) 0 ;
28153 wxString *arg2 = 0 ;
28154 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
28155 wxString *arg3 = (wxString *) &arg3_defvalue ;
28156 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
28157 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
28158 int result;
28159 void *argp1 = 0 ;
28160 int res1 = 0 ;
28161 bool temp2 = false ;
28162 bool temp3 = false ;
28163 void *argp4 = 0 ;
28164 int res4 = 0 ;
28165 PyObject * obj0 = 0 ;
28166 PyObject * obj1 = 0 ;
28167 PyObject * obj2 = 0 ;
28168 PyObject * obj3 = 0 ;
28169 char * kwnames[] = {
28170 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
28171 };
28172
28173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28174 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28175 if (!SWIG_IsOK(res1)) {
28176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseFormat" "', expected argument " "1"" of type '" "wxDateTime *""'");
28177 }
28178 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28179 {
28180 arg2 = wxString_in_helper(obj1);
28181 if (arg2 == NULL) SWIG_fail;
28182 temp2 = true;
28183 }
28184 if (obj2) {
28185 {
28186 arg3 = wxString_in_helper(obj2);
28187 if (arg3 == NULL) SWIG_fail;
28188 temp3 = true;
28189 }
28190 }
28191 if (obj3) {
28192 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDateTime, 0 | 0);
28193 if (!SWIG_IsOK(res4)) {
28194 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
28195 }
28196 if (!argp4) {
28197 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
28198 }
28199 arg4 = reinterpret_cast< wxDateTime * >(argp4);
28200 }
28201 {
28202 PyThreadState* __tstate = wxPyBeginAllowThreads();
28203 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
28204 wxPyEndAllowThreads(__tstate);
28205 if (PyErr_Occurred()) SWIG_fail;
28206 }
28207 resultobj = SWIG_From_int(static_cast< int >(result));
28208 {
28209 if (temp2)
28210 delete arg2;
28211 }
28212 {
28213 if (temp3)
28214 delete arg3;
28215 }
28216 return resultobj;
28217 fail:
28218 {
28219 if (temp2)
28220 delete arg2;
28221 }
28222 {
28223 if (temp3)
28224 delete arg3;
28225 }
28226 return NULL;
28227 }
28228
28229
28230 SWIGINTERN PyObject *_wrap_DateTime_ParseDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28231 PyObject *resultobj = 0;
28232 wxDateTime *arg1 = (wxDateTime *) 0 ;
28233 wxString *arg2 = 0 ;
28234 int result;
28235 void *argp1 = 0 ;
28236 int res1 = 0 ;
28237 bool temp2 = false ;
28238 PyObject * obj0 = 0 ;
28239 PyObject * obj1 = 0 ;
28240 char * kwnames[] = {
28241 (char *) "self",(char *) "datetime", NULL
28242 };
28243
28244 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) SWIG_fail;
28245 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28246 if (!SWIG_IsOK(res1)) {
28247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
28248 }
28249 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28250 {
28251 arg2 = wxString_in_helper(obj1);
28252 if (arg2 == NULL) SWIG_fail;
28253 temp2 = true;
28254 }
28255 {
28256 PyThreadState* __tstate = wxPyBeginAllowThreads();
28257 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
28258 wxPyEndAllowThreads(__tstate);
28259 if (PyErr_Occurred()) SWIG_fail;
28260 }
28261 resultobj = SWIG_From_int(static_cast< int >(result));
28262 {
28263 if (temp2)
28264 delete arg2;
28265 }
28266 return resultobj;
28267 fail:
28268 {
28269 if (temp2)
28270 delete arg2;
28271 }
28272 return NULL;
28273 }
28274
28275
28276 SWIGINTERN PyObject *_wrap_DateTime_ParseDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28277 PyObject *resultobj = 0;
28278 wxDateTime *arg1 = (wxDateTime *) 0 ;
28279 wxString *arg2 = 0 ;
28280 int result;
28281 void *argp1 = 0 ;
28282 int res1 = 0 ;
28283 bool temp2 = false ;
28284 PyObject * obj0 = 0 ;
28285 PyObject * obj1 = 0 ;
28286 char * kwnames[] = {
28287 (char *) "self",(char *) "date", NULL
28288 };
28289
28290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) SWIG_fail;
28291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28292 if (!SWIG_IsOK(res1)) {
28293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDate" "', expected argument " "1"" of type '" "wxDateTime *""'");
28294 }
28295 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28296 {
28297 arg2 = wxString_in_helper(obj1);
28298 if (arg2 == NULL) SWIG_fail;
28299 temp2 = true;
28300 }
28301 {
28302 PyThreadState* __tstate = wxPyBeginAllowThreads();
28303 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
28304 wxPyEndAllowThreads(__tstate);
28305 if (PyErr_Occurred()) SWIG_fail;
28306 }
28307 resultobj = SWIG_From_int(static_cast< int >(result));
28308 {
28309 if (temp2)
28310 delete arg2;
28311 }
28312 return resultobj;
28313 fail:
28314 {
28315 if (temp2)
28316 delete arg2;
28317 }
28318 return NULL;
28319 }
28320
28321
28322 SWIGINTERN PyObject *_wrap_DateTime_ParseTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28323 PyObject *resultobj = 0;
28324 wxDateTime *arg1 = (wxDateTime *) 0 ;
28325 wxString *arg2 = 0 ;
28326 int result;
28327 void *argp1 = 0 ;
28328 int res1 = 0 ;
28329 bool temp2 = false ;
28330 PyObject * obj0 = 0 ;
28331 PyObject * obj1 = 0 ;
28332 char * kwnames[] = {
28333 (char *) "self",(char *) "time", NULL
28334 };
28335
28336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) SWIG_fail;
28337 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28338 if (!SWIG_IsOK(res1)) {
28339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
28340 }
28341 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28342 {
28343 arg2 = wxString_in_helper(obj1);
28344 if (arg2 == NULL) SWIG_fail;
28345 temp2 = true;
28346 }
28347 {
28348 PyThreadState* __tstate = wxPyBeginAllowThreads();
28349 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
28350 wxPyEndAllowThreads(__tstate);
28351 if (PyErr_Occurred()) SWIG_fail;
28352 }
28353 resultobj = SWIG_From_int(static_cast< int >(result));
28354 {
28355 if (temp2)
28356 delete arg2;
28357 }
28358 return resultobj;
28359 fail:
28360 {
28361 if (temp2)
28362 delete arg2;
28363 }
28364 return NULL;
28365 }
28366
28367
28368 SWIGINTERN PyObject *_wrap_DateTime_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28369 PyObject *resultobj = 0;
28370 wxDateTime *arg1 = (wxDateTime *) 0 ;
28371 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
28372 wxString *arg2 = (wxString *) &arg2_defvalue ;
28373 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
28374 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
28375 wxString result;
28376 void *argp1 = 0 ;
28377 int res1 = 0 ;
28378 bool temp2 = false ;
28379 bool temp3 = false ;
28380 PyObject * obj0 = 0 ;
28381 PyObject * obj1 = 0 ;
28382 PyObject * obj2 = 0 ;
28383 char * kwnames[] = {
28384 (char *) "self",(char *) "format",(char *) "tz", NULL
28385 };
28386
28387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28389 if (!SWIG_IsOK(res1)) {
28390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Format" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28391 }
28392 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28393 if (obj1) {
28394 {
28395 arg2 = wxString_in_helper(obj1);
28396 if (arg2 == NULL) SWIG_fail;
28397 temp2 = true;
28398 }
28399 }
28400 if (obj2) {
28401 {
28402 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
28403 temp3 = true;
28404 }
28405 }
28406 {
28407 PyThreadState* __tstate = wxPyBeginAllowThreads();
28408 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
28409 wxPyEndAllowThreads(__tstate);
28410 if (PyErr_Occurred()) SWIG_fail;
28411 }
28412 {
28413 #if wxUSE_UNICODE
28414 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28415 #else
28416 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28417 #endif
28418 }
28419 {
28420 if (temp2)
28421 delete arg2;
28422 }
28423 {
28424 if (temp3) delete arg3;
28425 }
28426 return resultobj;
28427 fail:
28428 {
28429 if (temp2)
28430 delete arg2;
28431 }
28432 {
28433 if (temp3) delete arg3;
28434 }
28435 return NULL;
28436 }
28437
28438
28439 SWIGINTERN PyObject *_wrap_DateTime_FormatDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28440 PyObject *resultobj = 0;
28441 wxDateTime *arg1 = (wxDateTime *) 0 ;
28442 wxString result;
28443 void *argp1 = 0 ;
28444 int res1 = 0 ;
28445 PyObject *swig_obj[1] ;
28446
28447 if (!args) SWIG_fail;
28448 swig_obj[0] = args;
28449 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28450 if (!SWIG_IsOK(res1)) {
28451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28452 }
28453 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28454 {
28455 PyThreadState* __tstate = wxPyBeginAllowThreads();
28456 result = ((wxDateTime const *)arg1)->FormatDate();
28457 wxPyEndAllowThreads(__tstate);
28458 if (PyErr_Occurred()) SWIG_fail;
28459 }
28460 {
28461 #if wxUSE_UNICODE
28462 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28463 #else
28464 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28465 #endif
28466 }
28467 return resultobj;
28468 fail:
28469 return NULL;
28470 }
28471
28472
28473 SWIGINTERN PyObject *_wrap_DateTime_FormatTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28474 PyObject *resultobj = 0;
28475 wxDateTime *arg1 = (wxDateTime *) 0 ;
28476 wxString result;
28477 void *argp1 = 0 ;
28478 int res1 = 0 ;
28479 PyObject *swig_obj[1] ;
28480
28481 if (!args) SWIG_fail;
28482 swig_obj[0] = args;
28483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28484 if (!SWIG_IsOK(res1)) {
28485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28486 }
28487 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28488 {
28489 PyThreadState* __tstate = wxPyBeginAllowThreads();
28490 result = ((wxDateTime const *)arg1)->FormatTime();
28491 wxPyEndAllowThreads(__tstate);
28492 if (PyErr_Occurred()) SWIG_fail;
28493 }
28494 {
28495 #if wxUSE_UNICODE
28496 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28497 #else
28498 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28499 #endif
28500 }
28501 return resultobj;
28502 fail:
28503 return NULL;
28504 }
28505
28506
28507 SWIGINTERN PyObject *_wrap_DateTime_FormatISODate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28508 PyObject *resultobj = 0;
28509 wxDateTime *arg1 = (wxDateTime *) 0 ;
28510 wxString result;
28511 void *argp1 = 0 ;
28512 int res1 = 0 ;
28513 PyObject *swig_obj[1] ;
28514
28515 if (!args) SWIG_fail;
28516 swig_obj[0] = args;
28517 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28518 if (!SWIG_IsOK(res1)) {
28519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISODate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28520 }
28521 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28522 {
28523 PyThreadState* __tstate = wxPyBeginAllowThreads();
28524 result = ((wxDateTime const *)arg1)->FormatISODate();
28525 wxPyEndAllowThreads(__tstate);
28526 if (PyErr_Occurred()) SWIG_fail;
28527 }
28528 {
28529 #if wxUSE_UNICODE
28530 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28531 #else
28532 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28533 #endif
28534 }
28535 return resultobj;
28536 fail:
28537 return NULL;
28538 }
28539
28540
28541 SWIGINTERN PyObject *_wrap_DateTime_FormatISOTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28542 PyObject *resultobj = 0;
28543 wxDateTime *arg1 = (wxDateTime *) 0 ;
28544 wxString result;
28545 void *argp1 = 0 ;
28546 int res1 = 0 ;
28547 PyObject *swig_obj[1] ;
28548
28549 if (!args) SWIG_fail;
28550 swig_obj[0] = args;
28551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28552 if (!SWIG_IsOK(res1)) {
28553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISOTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28554 }
28555 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28556 {
28557 PyThreadState* __tstate = wxPyBeginAllowThreads();
28558 result = ((wxDateTime const *)arg1)->FormatISOTime();
28559 wxPyEndAllowThreads(__tstate);
28560 if (PyErr_Occurred()) SWIG_fail;
28561 }
28562 {
28563 #if wxUSE_UNICODE
28564 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28565 #else
28566 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28567 #endif
28568 }
28569 return resultobj;
28570 fail:
28571 return NULL;
28572 }
28573
28574
28575 SWIGINTERN PyObject *DateTime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28576 PyObject *obj;
28577 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28578 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateTime, SWIG_NewClientData(obj));
28579 return SWIG_Py_Void();
28580 }
28581
28582 SWIGINTERN PyObject *DateTime_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28583 return SWIG_Python_InitShadowInstance(args);
28584 }
28585
28586 SWIGINTERN PyObject *_wrap_TimeSpan_Milliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28587 PyObject *resultobj = 0;
28588 long arg1 ;
28589 wxTimeSpan result;
28590 long val1 ;
28591 int ecode1 = 0 ;
28592 PyObject * obj0 = 0 ;
28593 char * kwnames[] = {
28594 (char *) "ms", NULL
28595 };
28596
28597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Milliseconds",kwnames,&obj0)) SWIG_fail;
28598 ecode1 = SWIG_AsVal_long(obj0, &val1);
28599 if (!SWIG_IsOK(ecode1)) {
28600 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Milliseconds" "', expected argument " "1"" of type '" "long""'");
28601 }
28602 arg1 = static_cast< long >(val1);
28603 {
28604 PyThreadState* __tstate = wxPyBeginAllowThreads();
28605 result = wxTimeSpan::Milliseconds(arg1);
28606 wxPyEndAllowThreads(__tstate);
28607 if (PyErr_Occurred()) SWIG_fail;
28608 }
28609 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28610 return resultobj;
28611 fail:
28612 return NULL;
28613 }
28614
28615
28616 SWIGINTERN PyObject *_wrap_TimeSpan_Millisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28617 PyObject *resultobj = 0;
28618 wxTimeSpan result;
28619
28620 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Millisecond",0,0,0)) SWIG_fail;
28621 {
28622 PyThreadState* __tstate = wxPyBeginAllowThreads();
28623 result = wxTimeSpan::Millisecond();
28624 wxPyEndAllowThreads(__tstate);
28625 if (PyErr_Occurred()) SWIG_fail;
28626 }
28627 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28628 return resultobj;
28629 fail:
28630 return NULL;
28631 }
28632
28633
28634 SWIGINTERN PyObject *_wrap_TimeSpan_Seconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28635 PyObject *resultobj = 0;
28636 long arg1 ;
28637 wxTimeSpan result;
28638 long val1 ;
28639 int ecode1 = 0 ;
28640 PyObject * obj0 = 0 ;
28641 char * kwnames[] = {
28642 (char *) "sec", NULL
28643 };
28644
28645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) SWIG_fail;
28646 ecode1 = SWIG_AsVal_long(obj0, &val1);
28647 if (!SWIG_IsOK(ecode1)) {
28648 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Seconds" "', expected argument " "1"" of type '" "long""'");
28649 }
28650 arg1 = static_cast< long >(val1);
28651 {
28652 PyThreadState* __tstate = wxPyBeginAllowThreads();
28653 result = wxTimeSpan::Seconds(arg1);
28654 wxPyEndAllowThreads(__tstate);
28655 if (PyErr_Occurred()) SWIG_fail;
28656 }
28657 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28658 return resultobj;
28659 fail:
28660 return NULL;
28661 }
28662
28663
28664 SWIGINTERN PyObject *_wrap_TimeSpan_Second(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28665 PyObject *resultobj = 0;
28666 wxTimeSpan result;
28667
28668 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Second",0,0,0)) SWIG_fail;
28669 {
28670 PyThreadState* __tstate = wxPyBeginAllowThreads();
28671 result = wxTimeSpan::Second();
28672 wxPyEndAllowThreads(__tstate);
28673 if (PyErr_Occurred()) SWIG_fail;
28674 }
28675 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28676 return resultobj;
28677 fail:
28678 return NULL;
28679 }
28680
28681
28682 SWIGINTERN PyObject *_wrap_TimeSpan_Minutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28683 PyObject *resultobj = 0;
28684 long arg1 ;
28685 wxTimeSpan result;
28686 long val1 ;
28687 int ecode1 = 0 ;
28688 PyObject * obj0 = 0 ;
28689 char * kwnames[] = {
28690 (char *) "min", NULL
28691 };
28692
28693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) SWIG_fail;
28694 ecode1 = SWIG_AsVal_long(obj0, &val1);
28695 if (!SWIG_IsOK(ecode1)) {
28696 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Minutes" "', expected argument " "1"" of type '" "long""'");
28697 }
28698 arg1 = static_cast< long >(val1);
28699 {
28700 PyThreadState* __tstate = wxPyBeginAllowThreads();
28701 result = wxTimeSpan::Minutes(arg1);
28702 wxPyEndAllowThreads(__tstate);
28703 if (PyErr_Occurred()) SWIG_fail;
28704 }
28705 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28706 return resultobj;
28707 fail:
28708 return NULL;
28709 }
28710
28711
28712 SWIGINTERN PyObject *_wrap_TimeSpan_Minute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28713 PyObject *resultobj = 0;
28714 wxTimeSpan result;
28715
28716 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Minute",0,0,0)) SWIG_fail;
28717 {
28718 PyThreadState* __tstate = wxPyBeginAllowThreads();
28719 result = wxTimeSpan::Minute();
28720 wxPyEndAllowThreads(__tstate);
28721 if (PyErr_Occurred()) SWIG_fail;
28722 }
28723 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28724 return resultobj;
28725 fail:
28726 return NULL;
28727 }
28728
28729
28730 SWIGINTERN PyObject *_wrap_TimeSpan_Hours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28731 PyObject *resultobj = 0;
28732 long arg1 ;
28733 wxTimeSpan result;
28734 long val1 ;
28735 int ecode1 = 0 ;
28736 PyObject * obj0 = 0 ;
28737 char * kwnames[] = {
28738 (char *) "hours", NULL
28739 };
28740
28741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) SWIG_fail;
28742 ecode1 = SWIG_AsVal_long(obj0, &val1);
28743 if (!SWIG_IsOK(ecode1)) {
28744 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Hours" "', expected argument " "1"" of type '" "long""'");
28745 }
28746 arg1 = static_cast< long >(val1);
28747 {
28748 PyThreadState* __tstate = wxPyBeginAllowThreads();
28749 result = wxTimeSpan::Hours(arg1);
28750 wxPyEndAllowThreads(__tstate);
28751 if (PyErr_Occurred()) SWIG_fail;
28752 }
28753 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28754 return resultobj;
28755 fail:
28756 return NULL;
28757 }
28758
28759
28760 SWIGINTERN PyObject *_wrap_TimeSpan_Hour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28761 PyObject *resultobj = 0;
28762 wxTimeSpan result;
28763
28764 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Hour",0,0,0)) SWIG_fail;
28765 {
28766 PyThreadState* __tstate = wxPyBeginAllowThreads();
28767 result = wxTimeSpan::Hour();
28768 wxPyEndAllowThreads(__tstate);
28769 if (PyErr_Occurred()) SWIG_fail;
28770 }
28771 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28772 return resultobj;
28773 fail:
28774 return NULL;
28775 }
28776
28777
28778 SWIGINTERN PyObject *_wrap_TimeSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28779 PyObject *resultobj = 0;
28780 long arg1 ;
28781 wxTimeSpan result;
28782 long val1 ;
28783 int ecode1 = 0 ;
28784 PyObject * obj0 = 0 ;
28785 char * kwnames[] = {
28786 (char *) "days", NULL
28787 };
28788
28789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) SWIG_fail;
28790 ecode1 = SWIG_AsVal_long(obj0, &val1);
28791 if (!SWIG_IsOK(ecode1)) {
28792 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Days" "', expected argument " "1"" of type '" "long""'");
28793 }
28794 arg1 = static_cast< long >(val1);
28795 {
28796 PyThreadState* __tstate = wxPyBeginAllowThreads();
28797 result = wxTimeSpan::Days(arg1);
28798 wxPyEndAllowThreads(__tstate);
28799 if (PyErr_Occurred()) SWIG_fail;
28800 }
28801 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28802 return resultobj;
28803 fail:
28804 return NULL;
28805 }
28806
28807
28808 SWIGINTERN PyObject *_wrap_TimeSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28809 PyObject *resultobj = 0;
28810 wxTimeSpan result;
28811
28812 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Day",0,0,0)) SWIG_fail;
28813 {
28814 PyThreadState* __tstate = wxPyBeginAllowThreads();
28815 result = wxTimeSpan::Day();
28816 wxPyEndAllowThreads(__tstate);
28817 if (PyErr_Occurred()) SWIG_fail;
28818 }
28819 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28820 return resultobj;
28821 fail:
28822 return NULL;
28823 }
28824
28825
28826 SWIGINTERN PyObject *_wrap_TimeSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28827 PyObject *resultobj = 0;
28828 long arg1 ;
28829 wxTimeSpan result;
28830 long val1 ;
28831 int ecode1 = 0 ;
28832 PyObject * obj0 = 0 ;
28833 char * kwnames[] = {
28834 (char *) "days", NULL
28835 };
28836
28837 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) SWIG_fail;
28838 ecode1 = SWIG_AsVal_long(obj0, &val1);
28839 if (!SWIG_IsOK(ecode1)) {
28840 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Weeks" "', expected argument " "1"" of type '" "long""'");
28841 }
28842 arg1 = static_cast< long >(val1);
28843 {
28844 PyThreadState* __tstate = wxPyBeginAllowThreads();
28845 result = wxTimeSpan::Weeks(arg1);
28846 wxPyEndAllowThreads(__tstate);
28847 if (PyErr_Occurred()) SWIG_fail;
28848 }
28849 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28850 return resultobj;
28851 fail:
28852 return NULL;
28853 }
28854
28855
28856 SWIGINTERN PyObject *_wrap_TimeSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28857 PyObject *resultobj = 0;
28858 wxTimeSpan result;
28859
28860 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Week",0,0,0)) SWIG_fail;
28861 {
28862 PyThreadState* __tstate = wxPyBeginAllowThreads();
28863 result = wxTimeSpan::Week();
28864 wxPyEndAllowThreads(__tstate);
28865 if (PyErr_Occurred()) SWIG_fail;
28866 }
28867 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28868 return resultobj;
28869 fail:
28870 return NULL;
28871 }
28872
28873
28874 SWIGINTERN PyObject *_wrap_new_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28875 PyObject *resultobj = 0;
28876 long arg1 = (long) 0 ;
28877 long arg2 = (long) 0 ;
28878 long arg3 = (long) 0 ;
28879 long arg4 = (long) 0 ;
28880 wxTimeSpan *result = 0 ;
28881 long val1 ;
28882 int ecode1 = 0 ;
28883 long val2 ;
28884 int ecode2 = 0 ;
28885 long val3 ;
28886 int ecode3 = 0 ;
28887 long val4 ;
28888 int ecode4 = 0 ;
28889 PyObject * obj0 = 0 ;
28890 PyObject * obj1 = 0 ;
28891 PyObject * obj2 = 0 ;
28892 PyObject * obj3 = 0 ;
28893 char * kwnames[] = {
28894 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
28895 };
28896
28897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28898 if (obj0) {
28899 ecode1 = SWIG_AsVal_long(obj0, &val1);
28900 if (!SWIG_IsOK(ecode1)) {
28901 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimeSpan" "', expected argument " "1"" of type '" "long""'");
28902 }
28903 arg1 = static_cast< long >(val1);
28904 }
28905 if (obj1) {
28906 ecode2 = SWIG_AsVal_long(obj1, &val2);
28907 if (!SWIG_IsOK(ecode2)) {
28908 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimeSpan" "', expected argument " "2"" of type '" "long""'");
28909 }
28910 arg2 = static_cast< long >(val2);
28911 }
28912 if (obj2) {
28913 ecode3 = SWIG_AsVal_long(obj2, &val3);
28914 if (!SWIG_IsOK(ecode3)) {
28915 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimeSpan" "', expected argument " "3"" of type '" "long""'");
28916 }
28917 arg3 = static_cast< long >(val3);
28918 }
28919 if (obj3) {
28920 ecode4 = SWIG_AsVal_long(obj3, &val4);
28921 if (!SWIG_IsOK(ecode4)) {
28922 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TimeSpan" "', expected argument " "4"" of type '" "long""'");
28923 }
28924 arg4 = static_cast< long >(val4);
28925 }
28926 {
28927 PyThreadState* __tstate = wxPyBeginAllowThreads();
28928 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
28929 wxPyEndAllowThreads(__tstate);
28930 if (PyErr_Occurred()) SWIG_fail;
28931 }
28932 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_NEW | 0 );
28933 return resultobj;
28934 fail:
28935 return NULL;
28936 }
28937
28938
28939 SWIGINTERN PyObject *_wrap_delete_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28940 PyObject *resultobj = 0;
28941 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28942 void *argp1 = 0 ;
28943 int res1 = 0 ;
28944 PyObject *swig_obj[1] ;
28945
28946 if (!args) SWIG_fail;
28947 swig_obj[0] = args;
28948 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
28949 if (!SWIG_IsOK(res1)) {
28950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimeSpan" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28951 }
28952 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28953 {
28954 PyThreadState* __tstate = wxPyBeginAllowThreads();
28955 delete arg1;
28956
28957 wxPyEndAllowThreads(__tstate);
28958 if (PyErr_Occurred()) SWIG_fail;
28959 }
28960 resultobj = SWIG_Py_Void();
28961 return resultobj;
28962 fail:
28963 return NULL;
28964 }
28965
28966
28967 SWIGINTERN PyObject *_wrap_TimeSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28968 PyObject *resultobj = 0;
28969 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28970 wxTimeSpan *arg2 = 0 ;
28971 wxTimeSpan *result = 0 ;
28972 void *argp1 = 0 ;
28973 int res1 = 0 ;
28974 void *argp2 = 0 ;
28975 int res2 = 0 ;
28976 PyObject * obj0 = 0 ;
28977 PyObject * obj1 = 0 ;
28978 char * kwnames[] = {
28979 (char *) "self",(char *) "diff", NULL
28980 };
28981
28982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
28983 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28984 if (!SWIG_IsOK(res1)) {
28985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Add" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28986 }
28987 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28988 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28989 if (!SWIG_IsOK(res2)) {
28990 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28991 }
28992 if (!argp2) {
28993 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28994 }
28995 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28996 {
28997 PyThreadState* __tstate = wxPyBeginAllowThreads();
28998 {
28999 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
29000 result = (wxTimeSpan *) &_result_ref;
29001 }
29002 wxPyEndAllowThreads(__tstate);
29003 if (PyErr_Occurred()) SWIG_fail;
29004 }
29005 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29006 return resultobj;
29007 fail:
29008 return NULL;
29009 }
29010
29011
29012 SWIGINTERN PyObject *_wrap_TimeSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29013 PyObject *resultobj = 0;
29014 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29015 wxTimeSpan *arg2 = 0 ;
29016 wxTimeSpan *result = 0 ;
29017 void *argp1 = 0 ;
29018 int res1 = 0 ;
29019 void *argp2 = 0 ;
29020 int res2 = 0 ;
29021 PyObject * obj0 = 0 ;
29022 PyObject * obj1 = 0 ;
29023 char * kwnames[] = {
29024 (char *) "self",(char *) "diff", NULL
29025 };
29026
29027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
29028 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29029 if (!SWIG_IsOK(res1)) {
29030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Subtract" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29031 }
29032 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29033 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29034 if (!SWIG_IsOK(res2)) {
29035 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29036 }
29037 if (!argp2) {
29038 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29039 }
29040 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29041 {
29042 PyThreadState* __tstate = wxPyBeginAllowThreads();
29043 {
29044 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
29045 result = (wxTimeSpan *) &_result_ref;
29046 }
29047 wxPyEndAllowThreads(__tstate);
29048 if (PyErr_Occurred()) SWIG_fail;
29049 }
29050 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29051 return resultobj;
29052 fail:
29053 return NULL;
29054 }
29055
29056
29057 SWIGINTERN PyObject *_wrap_TimeSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29058 PyObject *resultobj = 0;
29059 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29060 int arg2 ;
29061 wxTimeSpan *result = 0 ;
29062 void *argp1 = 0 ;
29063 int res1 = 0 ;
29064 int val2 ;
29065 int ecode2 = 0 ;
29066 PyObject * obj0 = 0 ;
29067 PyObject * obj1 = 0 ;
29068 char * kwnames[] = {
29069 (char *) "self",(char *) "n", NULL
29070 };
29071
29072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
29073 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29074 if (!SWIG_IsOK(res1)) {
29075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Multiply" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29076 }
29077 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29078 ecode2 = SWIG_AsVal_int(obj1, &val2);
29079 if (!SWIG_IsOK(ecode2)) {
29080 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
29081 }
29082 arg2 = static_cast< int >(val2);
29083 {
29084 PyThreadState* __tstate = wxPyBeginAllowThreads();
29085 {
29086 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
29087 result = (wxTimeSpan *) &_result_ref;
29088 }
29089 wxPyEndAllowThreads(__tstate);
29090 if (PyErr_Occurred()) SWIG_fail;
29091 }
29092 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29093 return resultobj;
29094 fail:
29095 return NULL;
29096 }
29097
29098
29099 SWIGINTERN PyObject *_wrap_TimeSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29100 PyObject *resultobj = 0;
29101 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29102 wxTimeSpan *result = 0 ;
29103 void *argp1 = 0 ;
29104 int res1 = 0 ;
29105 PyObject *swig_obj[1] ;
29106
29107 if (!args) SWIG_fail;
29108 swig_obj[0] = args;
29109 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29110 if (!SWIG_IsOK(res1)) {
29111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Neg" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29112 }
29113 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29114 {
29115 PyThreadState* __tstate = wxPyBeginAllowThreads();
29116 {
29117 wxTimeSpan &_result_ref = (arg1)->Neg();
29118 result = (wxTimeSpan *) &_result_ref;
29119 }
29120 wxPyEndAllowThreads(__tstate);
29121 if (PyErr_Occurred()) SWIG_fail;
29122 }
29123 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29124 return resultobj;
29125 fail:
29126 return NULL;
29127 }
29128
29129
29130 SWIGINTERN PyObject *_wrap_TimeSpan_Abs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29131 PyObject *resultobj = 0;
29132 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29133 wxTimeSpan result;
29134 void *argp1 = 0 ;
29135 int res1 = 0 ;
29136 PyObject *swig_obj[1] ;
29137
29138 if (!args) SWIG_fail;
29139 swig_obj[0] = args;
29140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29141 if (!SWIG_IsOK(res1)) {
29142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Abs" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29143 }
29144 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29145 {
29146 PyThreadState* __tstate = wxPyBeginAllowThreads();
29147 result = ((wxTimeSpan const *)arg1)->Abs();
29148 wxPyEndAllowThreads(__tstate);
29149 if (PyErr_Occurred()) SWIG_fail;
29150 }
29151 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29152 return resultobj;
29153 fail:
29154 return NULL;
29155 }
29156
29157
29158 SWIGINTERN PyObject *_wrap_TimeSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29159 PyObject *resultobj = 0;
29160 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29161 wxTimeSpan *arg2 = 0 ;
29162 wxTimeSpan *result = 0 ;
29163 void *argp1 = 0 ;
29164 int res1 = 0 ;
29165 void *argp2 = 0 ;
29166 int res2 = 0 ;
29167 PyObject * obj0 = 0 ;
29168 PyObject * obj1 = 0 ;
29169 char * kwnames[] = {
29170 (char *) "self",(char *) "diff", NULL
29171 };
29172
29173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
29174 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29175 if (!SWIG_IsOK(res1)) {
29176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___iadd__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29177 }
29178 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29179 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29180 if (!SWIG_IsOK(res2)) {
29181 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29182 }
29183 if (!argp2) {
29184 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29185 }
29186 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29187 {
29188 PyThreadState* __tstate = wxPyBeginAllowThreads();
29189 {
29190 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
29191 result = (wxTimeSpan *) &_result_ref;
29192 }
29193 wxPyEndAllowThreads(__tstate);
29194 if (PyErr_Occurred()) SWIG_fail;
29195 }
29196 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29197 return resultobj;
29198 fail:
29199 return NULL;
29200 }
29201
29202
29203 SWIGINTERN PyObject *_wrap_TimeSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29204 PyObject *resultobj = 0;
29205 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29206 wxTimeSpan *arg2 = 0 ;
29207 wxTimeSpan *result = 0 ;
29208 void *argp1 = 0 ;
29209 int res1 = 0 ;
29210 void *argp2 = 0 ;
29211 int res2 = 0 ;
29212 PyObject * obj0 = 0 ;
29213 PyObject * obj1 = 0 ;
29214 char * kwnames[] = {
29215 (char *) "self",(char *) "diff", NULL
29216 };
29217
29218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
29219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29220 if (!SWIG_IsOK(res1)) {
29221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___isub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29222 }
29223 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29224 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29225 if (!SWIG_IsOK(res2)) {
29226 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29227 }
29228 if (!argp2) {
29229 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29230 }
29231 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29232 {
29233 PyThreadState* __tstate = wxPyBeginAllowThreads();
29234 {
29235 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
29236 result = (wxTimeSpan *) &_result_ref;
29237 }
29238 wxPyEndAllowThreads(__tstate);
29239 if (PyErr_Occurred()) SWIG_fail;
29240 }
29241 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29242 return resultobj;
29243 fail:
29244 return NULL;
29245 }
29246
29247
29248 SWIGINTERN PyObject *_wrap_TimeSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29249 PyObject *resultobj = 0;
29250 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29251 int arg2 ;
29252 wxTimeSpan *result = 0 ;
29253 void *argp1 = 0 ;
29254 int res1 = 0 ;
29255 int val2 ;
29256 int ecode2 = 0 ;
29257 PyObject * obj0 = 0 ;
29258 PyObject * obj1 = 0 ;
29259 char * kwnames[] = {
29260 (char *) "self",(char *) "n", NULL
29261 };
29262
29263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
29264 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29265 if (!SWIG_IsOK(res1)) {
29266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___imul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29267 }
29268 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29269 ecode2 = SWIG_AsVal_int(obj1, &val2);
29270 if (!SWIG_IsOK(ecode2)) {
29271 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___imul__" "', expected argument " "2"" of type '" "int""'");
29272 }
29273 arg2 = static_cast< int >(val2);
29274 {
29275 PyThreadState* __tstate = wxPyBeginAllowThreads();
29276 {
29277 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
29278 result = (wxTimeSpan *) &_result_ref;
29279 }
29280 wxPyEndAllowThreads(__tstate);
29281 if (PyErr_Occurred()) SWIG_fail;
29282 }
29283 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29284 return resultobj;
29285 fail:
29286 return NULL;
29287 }
29288
29289
29290 SWIGINTERN PyObject *_wrap_TimeSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29291 PyObject *resultobj = 0;
29292 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29293 wxTimeSpan *result = 0 ;
29294 void *argp1 = 0 ;
29295 int res1 = 0 ;
29296 PyObject *swig_obj[1] ;
29297
29298 if (!args) SWIG_fail;
29299 swig_obj[0] = args;
29300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29301 if (!SWIG_IsOK(res1)) {
29302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___neg__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29303 }
29304 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29305 {
29306 PyThreadState* __tstate = wxPyBeginAllowThreads();
29307 {
29308 wxTimeSpan &_result_ref = (arg1)->operator -();
29309 result = (wxTimeSpan *) &_result_ref;
29310 }
29311 wxPyEndAllowThreads(__tstate);
29312 if (PyErr_Occurred()) SWIG_fail;
29313 }
29314 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29315 return resultobj;
29316 fail:
29317 return NULL;
29318 }
29319
29320
29321 SWIGINTERN PyObject *_wrap_TimeSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29322 PyObject *resultobj = 0;
29323 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29324 wxTimeSpan *arg2 = 0 ;
29325 wxTimeSpan result;
29326 void *argp1 = 0 ;
29327 int res1 = 0 ;
29328 void *argp2 = 0 ;
29329 int res2 = 0 ;
29330 PyObject * obj0 = 0 ;
29331 PyObject * obj1 = 0 ;
29332 char * kwnames[] = {
29333 (char *) "self",(char *) "other", NULL
29334 };
29335
29336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
29337 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29338 if (!SWIG_IsOK(res1)) {
29339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___add__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29340 }
29341 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29342 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29343 if (!SWIG_IsOK(res2)) {
29344 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29345 }
29346 if (!argp2) {
29347 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29348 }
29349 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29350 {
29351 PyThreadState* __tstate = wxPyBeginAllowThreads();
29352 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
29353 wxPyEndAllowThreads(__tstate);
29354 if (PyErr_Occurred()) SWIG_fail;
29355 }
29356 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29357 return resultobj;
29358 fail:
29359 return NULL;
29360 }
29361
29362
29363 SWIGINTERN PyObject *_wrap_TimeSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29364 PyObject *resultobj = 0;
29365 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29366 wxTimeSpan *arg2 = 0 ;
29367 wxTimeSpan result;
29368 void *argp1 = 0 ;
29369 int res1 = 0 ;
29370 void *argp2 = 0 ;
29371 int res2 = 0 ;
29372 PyObject * obj0 = 0 ;
29373 PyObject * obj1 = 0 ;
29374 char * kwnames[] = {
29375 (char *) "self",(char *) "other", NULL
29376 };
29377
29378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
29379 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29380 if (!SWIG_IsOK(res1)) {
29381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___sub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29382 }
29383 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29384 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29385 if (!SWIG_IsOK(res2)) {
29386 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29387 }
29388 if (!argp2) {
29389 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29390 }
29391 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29392 {
29393 PyThreadState* __tstate = wxPyBeginAllowThreads();
29394 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
29395 wxPyEndAllowThreads(__tstate);
29396 if (PyErr_Occurred()) SWIG_fail;
29397 }
29398 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29399 return resultobj;
29400 fail:
29401 return NULL;
29402 }
29403
29404
29405 SWIGINTERN PyObject *_wrap_TimeSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29406 PyObject *resultobj = 0;
29407 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29408 int arg2 ;
29409 wxTimeSpan result;
29410 void *argp1 = 0 ;
29411 int res1 = 0 ;
29412 int val2 ;
29413 int ecode2 = 0 ;
29414 PyObject * obj0 = 0 ;
29415 PyObject * obj1 = 0 ;
29416 char * kwnames[] = {
29417 (char *) "self",(char *) "n", NULL
29418 };
29419
29420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
29421 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29422 if (!SWIG_IsOK(res1)) {
29423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___mul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29424 }
29425 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29426 ecode2 = SWIG_AsVal_int(obj1, &val2);
29427 if (!SWIG_IsOK(ecode2)) {
29428 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___mul__" "', expected argument " "2"" of type '" "int""'");
29429 }
29430 arg2 = static_cast< int >(val2);
29431 {
29432 PyThreadState* __tstate = wxPyBeginAllowThreads();
29433 result = wxTimeSpan___mul__(arg1,arg2);
29434 wxPyEndAllowThreads(__tstate);
29435 if (PyErr_Occurred()) SWIG_fail;
29436 }
29437 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29438 return resultobj;
29439 fail:
29440 return NULL;
29441 }
29442
29443
29444 SWIGINTERN PyObject *_wrap_TimeSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29445 PyObject *resultobj = 0;
29446 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29447 int arg2 ;
29448 wxTimeSpan result;
29449 void *argp1 = 0 ;
29450 int res1 = 0 ;
29451 int val2 ;
29452 int ecode2 = 0 ;
29453 PyObject * obj0 = 0 ;
29454 PyObject * obj1 = 0 ;
29455 char * kwnames[] = {
29456 (char *) "self",(char *) "n", NULL
29457 };
29458
29459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
29460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29461 if (!SWIG_IsOK(res1)) {
29462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___rmul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29463 }
29464 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29465 ecode2 = SWIG_AsVal_int(obj1, &val2);
29466 if (!SWIG_IsOK(ecode2)) {
29467 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
29468 }
29469 arg2 = static_cast< int >(val2);
29470 {
29471 PyThreadState* __tstate = wxPyBeginAllowThreads();
29472 result = wxTimeSpan___rmul__(arg1,arg2);
29473 wxPyEndAllowThreads(__tstate);
29474 if (PyErr_Occurred()) SWIG_fail;
29475 }
29476 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29477 return resultobj;
29478 fail:
29479 return NULL;
29480 }
29481
29482
29483 SWIGINTERN PyObject *_wrap_TimeSpan___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29484 PyObject *resultobj = 0;
29485 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29486 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29487 bool result;
29488 void *argp1 = 0 ;
29489 int res1 = 0 ;
29490 void *argp2 = 0 ;
29491 int res2 = 0 ;
29492 PyObject * obj0 = 0 ;
29493 PyObject * obj1 = 0 ;
29494 char * kwnames[] = {
29495 (char *) "self",(char *) "other", NULL
29496 };
29497
29498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
29499 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29500 if (!SWIG_IsOK(res1)) {
29501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___lt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29502 }
29503 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29504 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29505 if (!SWIG_IsOK(res2)) {
29506 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___lt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29507 }
29508 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29509 {
29510 PyThreadState* __tstate = wxPyBeginAllowThreads();
29511 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
29512 wxPyEndAllowThreads(__tstate);
29513 if (PyErr_Occurred()) SWIG_fail;
29514 }
29515 {
29516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29517 }
29518 return resultobj;
29519 fail:
29520 return NULL;
29521 }
29522
29523
29524 SWIGINTERN PyObject *_wrap_TimeSpan___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29525 PyObject *resultobj = 0;
29526 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29527 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29528 bool result;
29529 void *argp1 = 0 ;
29530 int res1 = 0 ;
29531 void *argp2 = 0 ;
29532 int res2 = 0 ;
29533 PyObject * obj0 = 0 ;
29534 PyObject * obj1 = 0 ;
29535 char * kwnames[] = {
29536 (char *) "self",(char *) "other", NULL
29537 };
29538
29539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) SWIG_fail;
29540 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29541 if (!SWIG_IsOK(res1)) {
29542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___le__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29543 }
29544 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29545 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29546 if (!SWIG_IsOK(res2)) {
29547 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___le__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29548 }
29549 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29550 {
29551 PyThreadState* __tstate = wxPyBeginAllowThreads();
29552 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
29553 wxPyEndAllowThreads(__tstate);
29554 if (PyErr_Occurred()) SWIG_fail;
29555 }
29556 {
29557 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29558 }
29559 return resultobj;
29560 fail:
29561 return NULL;
29562 }
29563
29564
29565 SWIGINTERN PyObject *_wrap_TimeSpan___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29566 PyObject *resultobj = 0;
29567 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29568 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29569 bool result;
29570 void *argp1 = 0 ;
29571 int res1 = 0 ;
29572 void *argp2 = 0 ;
29573 int res2 = 0 ;
29574 PyObject * obj0 = 0 ;
29575 PyObject * obj1 = 0 ;
29576 char * kwnames[] = {
29577 (char *) "self",(char *) "other", NULL
29578 };
29579
29580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
29581 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29582 if (!SWIG_IsOK(res1)) {
29583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___gt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29584 }
29585 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29586 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29587 if (!SWIG_IsOK(res2)) {
29588 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___gt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29589 }
29590 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29591 {
29592 PyThreadState* __tstate = wxPyBeginAllowThreads();
29593 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
29594 wxPyEndAllowThreads(__tstate);
29595 if (PyErr_Occurred()) SWIG_fail;
29596 }
29597 {
29598 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29599 }
29600 return resultobj;
29601 fail:
29602 return NULL;
29603 }
29604
29605
29606 SWIGINTERN PyObject *_wrap_TimeSpan___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29607 PyObject *resultobj = 0;
29608 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29609 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29610 bool result;
29611 void *argp1 = 0 ;
29612 int res1 = 0 ;
29613 void *argp2 = 0 ;
29614 int res2 = 0 ;
29615 PyObject * obj0 = 0 ;
29616 PyObject * obj1 = 0 ;
29617 char * kwnames[] = {
29618 (char *) "self",(char *) "other", NULL
29619 };
29620
29621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
29622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29623 if (!SWIG_IsOK(res1)) {
29624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ge__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29625 }
29626 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29627 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29628 if (!SWIG_IsOK(res2)) {
29629 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ge__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29630 }
29631 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29632 {
29633 PyThreadState* __tstate = wxPyBeginAllowThreads();
29634 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
29635 wxPyEndAllowThreads(__tstate);
29636 if (PyErr_Occurred()) SWIG_fail;
29637 }
29638 {
29639 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29640 }
29641 return resultobj;
29642 fail:
29643 return NULL;
29644 }
29645
29646
29647 SWIGINTERN PyObject *_wrap_TimeSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29648 PyObject *resultobj = 0;
29649 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29650 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29651 bool result;
29652 void *argp1 = 0 ;
29653 int res1 = 0 ;
29654 void *argp2 = 0 ;
29655 int res2 = 0 ;
29656 PyObject * obj0 = 0 ;
29657 PyObject * obj1 = 0 ;
29658 char * kwnames[] = {
29659 (char *) "self",(char *) "other", NULL
29660 };
29661
29662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
29663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29664 if (!SWIG_IsOK(res1)) {
29665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___eq__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29666 }
29667 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29668 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29669 if (!SWIG_IsOK(res2)) {
29670 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___eq__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29671 }
29672 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29673 {
29674 PyThreadState* __tstate = wxPyBeginAllowThreads();
29675 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
29676 wxPyEndAllowThreads(__tstate);
29677 if (PyErr_Occurred()) SWIG_fail;
29678 }
29679 {
29680 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29681 }
29682 return resultobj;
29683 fail:
29684 return NULL;
29685 }
29686
29687
29688 SWIGINTERN PyObject *_wrap_TimeSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29689 PyObject *resultobj = 0;
29690 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29691 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29692 bool result;
29693 void *argp1 = 0 ;
29694 int res1 = 0 ;
29695 void *argp2 = 0 ;
29696 int res2 = 0 ;
29697 PyObject * obj0 = 0 ;
29698 PyObject * obj1 = 0 ;
29699 char * kwnames[] = {
29700 (char *) "self",(char *) "other", NULL
29701 };
29702
29703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
29704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29705 if (!SWIG_IsOK(res1)) {
29706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ne__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29707 }
29708 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29709 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29710 if (!SWIG_IsOK(res2)) {
29711 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ne__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29712 }
29713 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29714 {
29715 PyThreadState* __tstate = wxPyBeginAllowThreads();
29716 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
29717 wxPyEndAllowThreads(__tstate);
29718 if (PyErr_Occurred()) SWIG_fail;
29719 }
29720 {
29721 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29722 }
29723 return resultobj;
29724 fail:
29725 return NULL;
29726 }
29727
29728
29729 SWIGINTERN PyObject *_wrap_TimeSpan_IsNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29730 PyObject *resultobj = 0;
29731 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29732 bool result;
29733 void *argp1 = 0 ;
29734 int res1 = 0 ;
29735 PyObject *swig_obj[1] ;
29736
29737 if (!args) SWIG_fail;
29738 swig_obj[0] = args;
29739 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29740 if (!SWIG_IsOK(res1)) {
29741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNull" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29742 }
29743 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29744 {
29745 PyThreadState* __tstate = wxPyBeginAllowThreads();
29746 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
29747 wxPyEndAllowThreads(__tstate);
29748 if (PyErr_Occurred()) SWIG_fail;
29749 }
29750 {
29751 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29752 }
29753 return resultobj;
29754 fail:
29755 return NULL;
29756 }
29757
29758
29759 SWIGINTERN PyObject *_wrap_TimeSpan_IsPositive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29760 PyObject *resultobj = 0;
29761 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29762 bool result;
29763 void *argp1 = 0 ;
29764 int res1 = 0 ;
29765 PyObject *swig_obj[1] ;
29766
29767 if (!args) SWIG_fail;
29768 swig_obj[0] = args;
29769 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29770 if (!SWIG_IsOK(res1)) {
29771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsPositive" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29772 }
29773 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29774 {
29775 PyThreadState* __tstate = wxPyBeginAllowThreads();
29776 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
29777 wxPyEndAllowThreads(__tstate);
29778 if (PyErr_Occurred()) SWIG_fail;
29779 }
29780 {
29781 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29782 }
29783 return resultobj;
29784 fail:
29785 return NULL;
29786 }
29787
29788
29789 SWIGINTERN PyObject *_wrap_TimeSpan_IsNegative(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29790 PyObject *resultobj = 0;
29791 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29792 bool result;
29793 void *argp1 = 0 ;
29794 int res1 = 0 ;
29795 PyObject *swig_obj[1] ;
29796
29797 if (!args) SWIG_fail;
29798 swig_obj[0] = args;
29799 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29800 if (!SWIG_IsOK(res1)) {
29801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNegative" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29802 }
29803 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29804 {
29805 PyThreadState* __tstate = wxPyBeginAllowThreads();
29806 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
29807 wxPyEndAllowThreads(__tstate);
29808 if (PyErr_Occurred()) SWIG_fail;
29809 }
29810 {
29811 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29812 }
29813 return resultobj;
29814 fail:
29815 return NULL;
29816 }
29817
29818
29819 SWIGINTERN PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29820 PyObject *resultobj = 0;
29821 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29822 wxTimeSpan *arg2 = 0 ;
29823 bool result;
29824 void *argp1 = 0 ;
29825 int res1 = 0 ;
29826 void *argp2 = 0 ;
29827 int res2 = 0 ;
29828 PyObject * obj0 = 0 ;
29829 PyObject * obj1 = 0 ;
29830 char * kwnames[] = {
29831 (char *) "self",(char *) "ts", NULL
29832 };
29833
29834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
29835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29836 if (!SWIG_IsOK(res1)) {
29837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29838 }
29839 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29840 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29841 if (!SWIG_IsOK(res2)) {
29842 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29843 }
29844 if (!argp2) {
29845 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29846 }
29847 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29848 {
29849 PyThreadState* __tstate = wxPyBeginAllowThreads();
29850 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
29851 wxPyEndAllowThreads(__tstate);
29852 if (PyErr_Occurred()) SWIG_fail;
29853 }
29854 {
29855 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29856 }
29857 return resultobj;
29858 fail:
29859 return NULL;
29860 }
29861
29862
29863 SWIGINTERN PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29864 PyObject *resultobj = 0;
29865 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29866 wxTimeSpan *arg2 = 0 ;
29867 bool result;
29868 void *argp1 = 0 ;
29869 int res1 = 0 ;
29870 void *argp2 = 0 ;
29871 int res2 = 0 ;
29872 PyObject * obj0 = 0 ;
29873 PyObject * obj1 = 0 ;
29874 char * kwnames[] = {
29875 (char *) "self",(char *) "ts", NULL
29876 };
29877
29878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) SWIG_fail;
29879 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29880 if (!SWIG_IsOK(res1)) {
29881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29882 }
29883 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29884 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29885 if (!SWIG_IsOK(res2)) {
29886 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29887 }
29888 if (!argp2) {
29889 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29890 }
29891 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29892 {
29893 PyThreadState* __tstate = wxPyBeginAllowThreads();
29894 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
29895 wxPyEndAllowThreads(__tstate);
29896 if (PyErr_Occurred()) SWIG_fail;
29897 }
29898 {
29899 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29900 }
29901 return resultobj;
29902 fail:
29903 return NULL;
29904 }
29905
29906
29907 SWIGINTERN PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29908 PyObject *resultobj = 0;
29909 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29910 wxTimeSpan *arg2 = 0 ;
29911 bool result;
29912 void *argp1 = 0 ;
29913 int res1 = 0 ;
29914 void *argp2 = 0 ;
29915 int res2 = 0 ;
29916 PyObject * obj0 = 0 ;
29917 PyObject * obj1 = 0 ;
29918 char * kwnames[] = {
29919 (char *) "self",(char *) "t", NULL
29920 };
29921
29922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) SWIG_fail;
29923 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29924 if (!SWIG_IsOK(res1)) {
29925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29926 }
29927 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29928 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29929 if (!SWIG_IsOK(res2)) {
29930 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29931 }
29932 if (!argp2) {
29933 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29934 }
29935 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29936 {
29937 PyThreadState* __tstate = wxPyBeginAllowThreads();
29938 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
29939 wxPyEndAllowThreads(__tstate);
29940 if (PyErr_Occurred()) SWIG_fail;
29941 }
29942 {
29943 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29944 }
29945 return resultobj;
29946 fail:
29947 return NULL;
29948 }
29949
29950
29951 SWIGINTERN PyObject *_wrap_TimeSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29952 PyObject *resultobj = 0;
29953 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29954 int result;
29955 void *argp1 = 0 ;
29956 int res1 = 0 ;
29957 PyObject *swig_obj[1] ;
29958
29959 if (!args) SWIG_fail;
29960 swig_obj[0] = args;
29961 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29962 if (!SWIG_IsOK(res1)) {
29963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetWeeks" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29964 }
29965 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29966 {
29967 PyThreadState* __tstate = wxPyBeginAllowThreads();
29968 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
29969 wxPyEndAllowThreads(__tstate);
29970 if (PyErr_Occurred()) SWIG_fail;
29971 }
29972 resultobj = SWIG_From_int(static_cast< int >(result));
29973 return resultobj;
29974 fail:
29975 return NULL;
29976 }
29977
29978
29979 SWIGINTERN PyObject *_wrap_TimeSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29980 PyObject *resultobj = 0;
29981 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29982 int result;
29983 void *argp1 = 0 ;
29984 int res1 = 0 ;
29985 PyObject *swig_obj[1] ;
29986
29987 if (!args) SWIG_fail;
29988 swig_obj[0] = args;
29989 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29990 if (!SWIG_IsOK(res1)) {
29991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetDays" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29992 }
29993 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29994 {
29995 PyThreadState* __tstate = wxPyBeginAllowThreads();
29996 result = (int)((wxTimeSpan const *)arg1)->GetDays();
29997 wxPyEndAllowThreads(__tstate);
29998 if (PyErr_Occurred()) SWIG_fail;
29999 }
30000 resultobj = SWIG_From_int(static_cast< int >(result));
30001 return resultobj;
30002 fail:
30003 return NULL;
30004 }
30005
30006
30007 SWIGINTERN PyObject *_wrap_TimeSpan_GetHours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30008 PyObject *resultobj = 0;
30009 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30010 int result;
30011 void *argp1 = 0 ;
30012 int res1 = 0 ;
30013 PyObject *swig_obj[1] ;
30014
30015 if (!args) SWIG_fail;
30016 swig_obj[0] = args;
30017 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30018 if (!SWIG_IsOK(res1)) {
30019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetHours" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30020 }
30021 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30022 {
30023 PyThreadState* __tstate = wxPyBeginAllowThreads();
30024 result = (int)((wxTimeSpan const *)arg1)->GetHours();
30025 wxPyEndAllowThreads(__tstate);
30026 if (PyErr_Occurred()) SWIG_fail;
30027 }
30028 resultobj = SWIG_From_int(static_cast< int >(result));
30029 return resultobj;
30030 fail:
30031 return NULL;
30032 }
30033
30034
30035 SWIGINTERN PyObject *_wrap_TimeSpan_GetMinutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30036 PyObject *resultobj = 0;
30037 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30038 int result;
30039 void *argp1 = 0 ;
30040 int res1 = 0 ;
30041 PyObject *swig_obj[1] ;
30042
30043 if (!args) SWIG_fail;
30044 swig_obj[0] = args;
30045 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30046 if (!SWIG_IsOK(res1)) {
30047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMinutes" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30048 }
30049 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30050 {
30051 PyThreadState* __tstate = wxPyBeginAllowThreads();
30052 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
30053 wxPyEndAllowThreads(__tstate);
30054 if (PyErr_Occurred()) SWIG_fail;
30055 }
30056 resultobj = SWIG_From_int(static_cast< int >(result));
30057 return resultobj;
30058 fail:
30059 return NULL;
30060 }
30061
30062
30063 SWIGINTERN PyObject *_wrap_TimeSpan_GetSeconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30064 PyObject *resultobj = 0;
30065 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30066 wxLongLong result;
30067 void *argp1 = 0 ;
30068 int res1 = 0 ;
30069 PyObject *swig_obj[1] ;
30070
30071 if (!args) SWIG_fail;
30072 swig_obj[0] = args;
30073 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30074 if (!SWIG_IsOK(res1)) {
30075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetSeconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30076 }
30077 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30078 {
30079 PyThreadState* __tstate = wxPyBeginAllowThreads();
30080 result = ((wxTimeSpan const *)arg1)->GetSeconds();
30081 wxPyEndAllowThreads(__tstate);
30082 if (PyErr_Occurred()) SWIG_fail;
30083 }
30084 {
30085 PyObject *hi, *lo, *shifter, *shifted;
30086 hi = PyLong_FromLong( (&result)->GetHi() );
30087 lo = PyLong_FromLong( (&result)->GetLo() );
30088 shifter = PyLong_FromLong(32);
30089 shifted = PyNumber_Lshift(hi, shifter);
30090 resultobj = PyNumber_Or(shifted, lo);
30091 Py_DECREF(hi);
30092 Py_DECREF(lo);
30093 Py_DECREF(shifter);
30094 Py_DECREF(shifted);
30095 }
30096 return resultobj;
30097 fail:
30098 return NULL;
30099 }
30100
30101
30102 SWIGINTERN PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30103 PyObject *resultobj = 0;
30104 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30105 wxLongLong result;
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_wxTimeSpan, 0 | 0 );
30113 if (!SWIG_IsOK(res1)) {
30114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMilliseconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30115 }
30116 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30117 {
30118 PyThreadState* __tstate = wxPyBeginAllowThreads();
30119 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
30120 wxPyEndAllowThreads(__tstate);
30121 if (PyErr_Occurred()) SWIG_fail;
30122 }
30123 {
30124 PyObject *hi, *lo, *shifter, *shifted;
30125 hi = PyLong_FromLong( (&result)->GetHi() );
30126 lo = PyLong_FromLong( (&result)->GetLo() );
30127 shifter = PyLong_FromLong(32);
30128 shifted = PyNumber_Lshift(hi, shifter);
30129 resultobj = PyNumber_Or(shifted, lo);
30130 Py_DECREF(hi);
30131 Py_DECREF(lo);
30132 Py_DECREF(shifter);
30133 Py_DECREF(shifted);
30134 }
30135 return resultobj;
30136 fail:
30137 return NULL;
30138 }
30139
30140
30141 SWIGINTERN PyObject *_wrap_TimeSpan_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30142 PyObject *resultobj = 0;
30143 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30144 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
30145 wxString *arg2 = (wxString *) &arg2_defvalue ;
30146 wxString result;
30147 void *argp1 = 0 ;
30148 int res1 = 0 ;
30149 bool temp2 = false ;
30150 PyObject * obj0 = 0 ;
30151 PyObject * obj1 = 0 ;
30152 char * kwnames[] = {
30153 (char *) "self",(char *) "format", NULL
30154 };
30155
30156 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) SWIG_fail;
30157 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30158 if (!SWIG_IsOK(res1)) {
30159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Format" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30160 }
30161 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30162 if (obj1) {
30163 {
30164 arg2 = wxString_in_helper(obj1);
30165 if (arg2 == NULL) SWIG_fail;
30166 temp2 = true;
30167 }
30168 }
30169 {
30170 PyThreadState* __tstate = wxPyBeginAllowThreads();
30171 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
30172 wxPyEndAllowThreads(__tstate);
30173 if (PyErr_Occurred()) SWIG_fail;
30174 }
30175 {
30176 #if wxUSE_UNICODE
30177 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30178 #else
30179 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30180 #endif
30181 }
30182 {
30183 if (temp2)
30184 delete arg2;
30185 }
30186 return resultobj;
30187 fail:
30188 {
30189 if (temp2)
30190 delete arg2;
30191 }
30192 return NULL;
30193 }
30194
30195
30196 SWIGINTERN PyObject *TimeSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30197 PyObject *obj;
30198 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30199 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimeSpan, SWIG_NewClientData(obj));
30200 return SWIG_Py_Void();
30201 }
30202
30203 SWIGINTERN PyObject *TimeSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30204 return SWIG_Python_InitShadowInstance(args);
30205 }
30206
30207 SWIGINTERN PyObject *_wrap_new_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30208 PyObject *resultobj = 0;
30209 int arg1 = (int) 0 ;
30210 int arg2 = (int) 0 ;
30211 int arg3 = (int) 0 ;
30212 int arg4 = (int) 0 ;
30213 wxDateSpan *result = 0 ;
30214 int val1 ;
30215 int ecode1 = 0 ;
30216 int val2 ;
30217 int ecode2 = 0 ;
30218 int val3 ;
30219 int ecode3 = 0 ;
30220 int val4 ;
30221 int ecode4 = 0 ;
30222 PyObject * obj0 = 0 ;
30223 PyObject * obj1 = 0 ;
30224 PyObject * obj2 = 0 ;
30225 PyObject * obj3 = 0 ;
30226 char * kwnames[] = {
30227 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
30228 };
30229
30230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30231 if (obj0) {
30232 ecode1 = SWIG_AsVal_int(obj0, &val1);
30233 if (!SWIG_IsOK(ecode1)) {
30234 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateSpan" "', expected argument " "1"" of type '" "int""'");
30235 }
30236 arg1 = static_cast< int >(val1);
30237 }
30238 if (obj1) {
30239 ecode2 = SWIG_AsVal_int(obj1, &val2);
30240 if (!SWIG_IsOK(ecode2)) {
30241 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateSpan" "', expected argument " "2"" of type '" "int""'");
30242 }
30243 arg2 = static_cast< int >(val2);
30244 }
30245 if (obj2) {
30246 ecode3 = SWIG_AsVal_int(obj2, &val3);
30247 if (!SWIG_IsOK(ecode3)) {
30248 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateSpan" "', expected argument " "3"" of type '" "int""'");
30249 }
30250 arg3 = static_cast< int >(val3);
30251 }
30252 if (obj3) {
30253 ecode4 = SWIG_AsVal_int(obj3, &val4);
30254 if (!SWIG_IsOK(ecode4)) {
30255 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateSpan" "', expected argument " "4"" of type '" "int""'");
30256 }
30257 arg4 = static_cast< int >(val4);
30258 }
30259 {
30260 PyThreadState* __tstate = wxPyBeginAllowThreads();
30261 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
30262 wxPyEndAllowThreads(__tstate);
30263 if (PyErr_Occurred()) SWIG_fail;
30264 }
30265 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_NEW | 0 );
30266 return resultobj;
30267 fail:
30268 return NULL;
30269 }
30270
30271
30272 SWIGINTERN PyObject *_wrap_delete_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30273 PyObject *resultobj = 0;
30274 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30275 void *argp1 = 0 ;
30276 int res1 = 0 ;
30277 PyObject *swig_obj[1] ;
30278
30279 if (!args) SWIG_fail;
30280 swig_obj[0] = args;
30281 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
30282 if (!SWIG_IsOK(res1)) {
30283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateSpan" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30284 }
30285 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30286 {
30287 PyThreadState* __tstate = wxPyBeginAllowThreads();
30288 delete arg1;
30289
30290 wxPyEndAllowThreads(__tstate);
30291 if (PyErr_Occurred()) SWIG_fail;
30292 }
30293 resultobj = SWIG_Py_Void();
30294 return resultobj;
30295 fail:
30296 return NULL;
30297 }
30298
30299
30300 SWIGINTERN PyObject *_wrap_DateSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30301 PyObject *resultobj = 0;
30302 int arg1 ;
30303 wxDateSpan result;
30304 int val1 ;
30305 int ecode1 = 0 ;
30306 PyObject * obj0 = 0 ;
30307 char * kwnames[] = {
30308 (char *) "days", NULL
30309 };
30310
30311 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) SWIG_fail;
30312 ecode1 = SWIG_AsVal_int(obj0, &val1);
30313 if (!SWIG_IsOK(ecode1)) {
30314 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Days" "', expected argument " "1"" of type '" "int""'");
30315 }
30316 arg1 = static_cast< int >(val1);
30317 {
30318 PyThreadState* __tstate = wxPyBeginAllowThreads();
30319 result = wxDateSpan::Days(arg1);
30320 wxPyEndAllowThreads(__tstate);
30321 if (PyErr_Occurred()) SWIG_fail;
30322 }
30323 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30324 return resultobj;
30325 fail:
30326 return NULL;
30327 }
30328
30329
30330 SWIGINTERN PyObject *_wrap_DateSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30331 PyObject *resultobj = 0;
30332 wxDateSpan result;
30333
30334 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Day",0,0,0)) SWIG_fail;
30335 {
30336 PyThreadState* __tstate = wxPyBeginAllowThreads();
30337 result = wxDateSpan::Day();
30338 wxPyEndAllowThreads(__tstate);
30339 if (PyErr_Occurred()) SWIG_fail;
30340 }
30341 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30342 return resultobj;
30343 fail:
30344 return NULL;
30345 }
30346
30347
30348 SWIGINTERN PyObject *_wrap_DateSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30349 PyObject *resultobj = 0;
30350 int arg1 ;
30351 wxDateSpan result;
30352 int val1 ;
30353 int ecode1 = 0 ;
30354 PyObject * obj0 = 0 ;
30355 char * kwnames[] = {
30356 (char *) "weeks", NULL
30357 };
30358
30359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) SWIG_fail;
30360 ecode1 = SWIG_AsVal_int(obj0, &val1);
30361 if (!SWIG_IsOK(ecode1)) {
30362 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Weeks" "', expected argument " "1"" of type '" "int""'");
30363 }
30364 arg1 = static_cast< int >(val1);
30365 {
30366 PyThreadState* __tstate = wxPyBeginAllowThreads();
30367 result = wxDateSpan::Weeks(arg1);
30368 wxPyEndAllowThreads(__tstate);
30369 if (PyErr_Occurred()) SWIG_fail;
30370 }
30371 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30372 return resultobj;
30373 fail:
30374 return NULL;
30375 }
30376
30377
30378 SWIGINTERN PyObject *_wrap_DateSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30379 PyObject *resultobj = 0;
30380 wxDateSpan result;
30381
30382 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Week",0,0,0)) SWIG_fail;
30383 {
30384 PyThreadState* __tstate = wxPyBeginAllowThreads();
30385 result = wxDateSpan::Week();
30386 wxPyEndAllowThreads(__tstate);
30387 if (PyErr_Occurred()) SWIG_fail;
30388 }
30389 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30390 return resultobj;
30391 fail:
30392 return NULL;
30393 }
30394
30395
30396 SWIGINTERN PyObject *_wrap_DateSpan_Months(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30397 PyObject *resultobj = 0;
30398 int arg1 ;
30399 wxDateSpan result;
30400 int val1 ;
30401 int ecode1 = 0 ;
30402 PyObject * obj0 = 0 ;
30403 char * kwnames[] = {
30404 (char *) "mon", NULL
30405 };
30406
30407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) SWIG_fail;
30408 ecode1 = SWIG_AsVal_int(obj0, &val1);
30409 if (!SWIG_IsOK(ecode1)) {
30410 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Months" "', expected argument " "1"" of type '" "int""'");
30411 }
30412 arg1 = static_cast< int >(val1);
30413 {
30414 PyThreadState* __tstate = wxPyBeginAllowThreads();
30415 result = wxDateSpan::Months(arg1);
30416 wxPyEndAllowThreads(__tstate);
30417 if (PyErr_Occurred()) SWIG_fail;
30418 }
30419 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30420 return resultobj;
30421 fail:
30422 return NULL;
30423 }
30424
30425
30426 SWIGINTERN PyObject *_wrap_DateSpan_Month(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30427 PyObject *resultobj = 0;
30428 wxDateSpan result;
30429
30430 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Month",0,0,0)) SWIG_fail;
30431 {
30432 PyThreadState* __tstate = wxPyBeginAllowThreads();
30433 result = wxDateSpan::Month();
30434 wxPyEndAllowThreads(__tstate);
30435 if (PyErr_Occurred()) SWIG_fail;
30436 }
30437 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30438 return resultobj;
30439 fail:
30440 return NULL;
30441 }
30442
30443
30444 SWIGINTERN PyObject *_wrap_DateSpan_Years(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30445 PyObject *resultobj = 0;
30446 int arg1 ;
30447 wxDateSpan result;
30448 int val1 ;
30449 int ecode1 = 0 ;
30450 PyObject * obj0 = 0 ;
30451 char * kwnames[] = {
30452 (char *) "years", NULL
30453 };
30454
30455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) SWIG_fail;
30456 ecode1 = SWIG_AsVal_int(obj0, &val1);
30457 if (!SWIG_IsOK(ecode1)) {
30458 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Years" "', expected argument " "1"" of type '" "int""'");
30459 }
30460 arg1 = static_cast< int >(val1);
30461 {
30462 PyThreadState* __tstate = wxPyBeginAllowThreads();
30463 result = wxDateSpan::Years(arg1);
30464 wxPyEndAllowThreads(__tstate);
30465 if (PyErr_Occurred()) SWIG_fail;
30466 }
30467 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30468 return resultobj;
30469 fail:
30470 return NULL;
30471 }
30472
30473
30474 SWIGINTERN PyObject *_wrap_DateSpan_Year(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30475 PyObject *resultobj = 0;
30476 wxDateSpan result;
30477
30478 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Year",0,0,0)) SWIG_fail;
30479 {
30480 PyThreadState* __tstate = wxPyBeginAllowThreads();
30481 result = wxDateSpan::Year();
30482 wxPyEndAllowThreads(__tstate);
30483 if (PyErr_Occurred()) SWIG_fail;
30484 }
30485 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30486 return resultobj;
30487 fail:
30488 return NULL;
30489 }
30490
30491
30492 SWIGINTERN PyObject *_wrap_DateSpan_SetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30493 PyObject *resultobj = 0;
30494 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30495 int arg2 ;
30496 wxDateSpan *result = 0 ;
30497 void *argp1 = 0 ;
30498 int res1 = 0 ;
30499 int val2 ;
30500 int ecode2 = 0 ;
30501 PyObject * obj0 = 0 ;
30502 PyObject * obj1 = 0 ;
30503 char * kwnames[] = {
30504 (char *) "self",(char *) "n", NULL
30505 };
30506
30507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) SWIG_fail;
30508 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30509 if (!SWIG_IsOK(res1)) {
30510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetYears" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30511 }
30512 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30513 ecode2 = SWIG_AsVal_int(obj1, &val2);
30514 if (!SWIG_IsOK(ecode2)) {
30515 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetYears" "', expected argument " "2"" of type '" "int""'");
30516 }
30517 arg2 = static_cast< int >(val2);
30518 {
30519 PyThreadState* __tstate = wxPyBeginAllowThreads();
30520 {
30521 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
30522 result = (wxDateSpan *) &_result_ref;
30523 }
30524 wxPyEndAllowThreads(__tstate);
30525 if (PyErr_Occurred()) SWIG_fail;
30526 }
30527 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30528 return resultobj;
30529 fail:
30530 return NULL;
30531 }
30532
30533
30534 SWIGINTERN PyObject *_wrap_DateSpan_SetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30535 PyObject *resultobj = 0;
30536 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30537 int arg2 ;
30538 wxDateSpan *result = 0 ;
30539 void *argp1 = 0 ;
30540 int res1 = 0 ;
30541 int val2 ;
30542 int ecode2 = 0 ;
30543 PyObject * obj0 = 0 ;
30544 PyObject * obj1 = 0 ;
30545 char * kwnames[] = {
30546 (char *) "self",(char *) "n", NULL
30547 };
30548
30549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) SWIG_fail;
30550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30551 if (!SWIG_IsOK(res1)) {
30552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetMonths" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30553 }
30554 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30555 ecode2 = SWIG_AsVal_int(obj1, &val2);
30556 if (!SWIG_IsOK(ecode2)) {
30557 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetMonths" "', expected argument " "2"" of type '" "int""'");
30558 }
30559 arg2 = static_cast< int >(val2);
30560 {
30561 PyThreadState* __tstate = wxPyBeginAllowThreads();
30562 {
30563 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
30564 result = (wxDateSpan *) &_result_ref;
30565 }
30566 wxPyEndAllowThreads(__tstate);
30567 if (PyErr_Occurred()) SWIG_fail;
30568 }
30569 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30570 return resultobj;
30571 fail:
30572 return NULL;
30573 }
30574
30575
30576 SWIGINTERN PyObject *_wrap_DateSpan_SetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30577 PyObject *resultobj = 0;
30578 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30579 int arg2 ;
30580 wxDateSpan *result = 0 ;
30581 void *argp1 = 0 ;
30582 int res1 = 0 ;
30583 int val2 ;
30584 int ecode2 = 0 ;
30585 PyObject * obj0 = 0 ;
30586 PyObject * obj1 = 0 ;
30587 char * kwnames[] = {
30588 (char *) "self",(char *) "n", NULL
30589 };
30590
30591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) SWIG_fail;
30592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30593 if (!SWIG_IsOK(res1)) {
30594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetWeeks" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30595 }
30596 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30597 ecode2 = SWIG_AsVal_int(obj1, &val2);
30598 if (!SWIG_IsOK(ecode2)) {
30599 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetWeeks" "', expected argument " "2"" of type '" "int""'");
30600 }
30601 arg2 = static_cast< int >(val2);
30602 {
30603 PyThreadState* __tstate = wxPyBeginAllowThreads();
30604 {
30605 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
30606 result = (wxDateSpan *) &_result_ref;
30607 }
30608 wxPyEndAllowThreads(__tstate);
30609 if (PyErr_Occurred()) SWIG_fail;
30610 }
30611 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30612 return resultobj;
30613 fail:
30614 return NULL;
30615 }
30616
30617
30618 SWIGINTERN PyObject *_wrap_DateSpan_SetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30619 PyObject *resultobj = 0;
30620 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30621 int arg2 ;
30622 wxDateSpan *result = 0 ;
30623 void *argp1 = 0 ;
30624 int res1 = 0 ;
30625 int val2 ;
30626 int ecode2 = 0 ;
30627 PyObject * obj0 = 0 ;
30628 PyObject * obj1 = 0 ;
30629 char * kwnames[] = {
30630 (char *) "self",(char *) "n", NULL
30631 };
30632
30633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) SWIG_fail;
30634 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30635 if (!SWIG_IsOK(res1)) {
30636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetDays" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30637 }
30638 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30639 ecode2 = SWIG_AsVal_int(obj1, &val2);
30640 if (!SWIG_IsOK(ecode2)) {
30641 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetDays" "', expected argument " "2"" of type '" "int""'");
30642 }
30643 arg2 = static_cast< int >(val2);
30644 {
30645 PyThreadState* __tstate = wxPyBeginAllowThreads();
30646 {
30647 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
30648 result = (wxDateSpan *) &_result_ref;
30649 }
30650 wxPyEndAllowThreads(__tstate);
30651 if (PyErr_Occurred()) SWIG_fail;
30652 }
30653 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30654 return resultobj;
30655 fail:
30656 return NULL;
30657 }
30658
30659
30660 SWIGINTERN PyObject *_wrap_DateSpan_GetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30661 PyObject *resultobj = 0;
30662 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30663 int result;
30664 void *argp1 = 0 ;
30665 int res1 = 0 ;
30666 PyObject *swig_obj[1] ;
30667
30668 if (!args) SWIG_fail;
30669 swig_obj[0] = args;
30670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30671 if (!SWIG_IsOK(res1)) {
30672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetYears" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30673 }
30674 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30675 {
30676 PyThreadState* __tstate = wxPyBeginAllowThreads();
30677 result = (int)((wxDateSpan const *)arg1)->GetYears();
30678 wxPyEndAllowThreads(__tstate);
30679 if (PyErr_Occurred()) SWIG_fail;
30680 }
30681 resultobj = SWIG_From_int(static_cast< int >(result));
30682 return resultobj;
30683 fail:
30684 return NULL;
30685 }
30686
30687
30688 SWIGINTERN PyObject *_wrap_DateSpan_GetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30689 PyObject *resultobj = 0;
30690 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30691 int result;
30692 void *argp1 = 0 ;
30693 int res1 = 0 ;
30694 PyObject *swig_obj[1] ;
30695
30696 if (!args) SWIG_fail;
30697 swig_obj[0] = args;
30698 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30699 if (!SWIG_IsOK(res1)) {
30700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetMonths" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30701 }
30702 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30703 {
30704 PyThreadState* __tstate = wxPyBeginAllowThreads();
30705 result = (int)((wxDateSpan const *)arg1)->GetMonths();
30706 wxPyEndAllowThreads(__tstate);
30707 if (PyErr_Occurred()) SWIG_fail;
30708 }
30709 resultobj = SWIG_From_int(static_cast< int >(result));
30710 return resultobj;
30711 fail:
30712 return NULL;
30713 }
30714
30715
30716 SWIGINTERN PyObject *_wrap_DateSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30717 PyObject *resultobj = 0;
30718 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30719 int result;
30720 void *argp1 = 0 ;
30721 int res1 = 0 ;
30722 PyObject *swig_obj[1] ;
30723
30724 if (!args) SWIG_fail;
30725 swig_obj[0] = args;
30726 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30727 if (!SWIG_IsOK(res1)) {
30728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetWeeks" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30729 }
30730 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30731 {
30732 PyThreadState* __tstate = wxPyBeginAllowThreads();
30733 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
30734 wxPyEndAllowThreads(__tstate);
30735 if (PyErr_Occurred()) SWIG_fail;
30736 }
30737 resultobj = SWIG_From_int(static_cast< int >(result));
30738 return resultobj;
30739 fail:
30740 return NULL;
30741 }
30742
30743
30744 SWIGINTERN PyObject *_wrap_DateSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30745 PyObject *resultobj = 0;
30746 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30747 int result;
30748 void *argp1 = 0 ;
30749 int res1 = 0 ;
30750 PyObject *swig_obj[1] ;
30751
30752 if (!args) SWIG_fail;
30753 swig_obj[0] = args;
30754 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30755 if (!SWIG_IsOK(res1)) {
30756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30757 }
30758 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30759 {
30760 PyThreadState* __tstate = wxPyBeginAllowThreads();
30761 result = (int)((wxDateSpan const *)arg1)->GetDays();
30762 wxPyEndAllowThreads(__tstate);
30763 if (PyErr_Occurred()) SWIG_fail;
30764 }
30765 resultobj = SWIG_From_int(static_cast< int >(result));
30766 return resultobj;
30767 fail:
30768 return NULL;
30769 }
30770
30771
30772 SWIGINTERN PyObject *_wrap_DateSpan_GetTotalDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30773 PyObject *resultobj = 0;
30774 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30775 int result;
30776 void *argp1 = 0 ;
30777 int res1 = 0 ;
30778 PyObject *swig_obj[1] ;
30779
30780 if (!args) SWIG_fail;
30781 swig_obj[0] = args;
30782 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30783 if (!SWIG_IsOK(res1)) {
30784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetTotalDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30785 }
30786 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30787 {
30788 PyThreadState* __tstate = wxPyBeginAllowThreads();
30789 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
30790 wxPyEndAllowThreads(__tstate);
30791 if (PyErr_Occurred()) SWIG_fail;
30792 }
30793 resultobj = SWIG_From_int(static_cast< int >(result));
30794 return resultobj;
30795 fail:
30796 return NULL;
30797 }
30798
30799
30800 SWIGINTERN PyObject *_wrap_DateSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30801 PyObject *resultobj = 0;
30802 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30803 wxDateSpan *arg2 = 0 ;
30804 wxDateSpan *result = 0 ;
30805 void *argp1 = 0 ;
30806 int res1 = 0 ;
30807 void *argp2 = 0 ;
30808 int res2 = 0 ;
30809 PyObject * obj0 = 0 ;
30810 PyObject * obj1 = 0 ;
30811 char * kwnames[] = {
30812 (char *) "self",(char *) "other", NULL
30813 };
30814
30815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
30816 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30817 if (!SWIG_IsOK(res1)) {
30818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Add" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30819 }
30820 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30821 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30822 if (!SWIG_IsOK(res2)) {
30823 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30824 }
30825 if (!argp2) {
30826 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30827 }
30828 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30829 {
30830 PyThreadState* __tstate = wxPyBeginAllowThreads();
30831 {
30832 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
30833 result = (wxDateSpan *) &_result_ref;
30834 }
30835 wxPyEndAllowThreads(__tstate);
30836 if (PyErr_Occurred()) SWIG_fail;
30837 }
30838 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30839 return resultobj;
30840 fail:
30841 return NULL;
30842 }
30843
30844
30845 SWIGINTERN PyObject *_wrap_DateSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30846 PyObject *resultobj = 0;
30847 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30848 wxDateSpan *arg2 = 0 ;
30849 wxDateSpan *result = 0 ;
30850 void *argp1 = 0 ;
30851 int res1 = 0 ;
30852 void *argp2 = 0 ;
30853 int res2 = 0 ;
30854 PyObject * obj0 = 0 ;
30855 PyObject * obj1 = 0 ;
30856 char * kwnames[] = {
30857 (char *) "self",(char *) "other", NULL
30858 };
30859
30860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
30861 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30862 if (!SWIG_IsOK(res1)) {
30863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Subtract" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30864 }
30865 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30866 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30867 if (!SWIG_IsOK(res2)) {
30868 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30869 }
30870 if (!argp2) {
30871 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30872 }
30873 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30874 {
30875 PyThreadState* __tstate = wxPyBeginAllowThreads();
30876 {
30877 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
30878 result = (wxDateSpan *) &_result_ref;
30879 }
30880 wxPyEndAllowThreads(__tstate);
30881 if (PyErr_Occurred()) SWIG_fail;
30882 }
30883 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30884 return resultobj;
30885 fail:
30886 return NULL;
30887 }
30888
30889
30890 SWIGINTERN PyObject *_wrap_DateSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30891 PyObject *resultobj = 0;
30892 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30893 wxDateSpan *result = 0 ;
30894 void *argp1 = 0 ;
30895 int res1 = 0 ;
30896 PyObject *swig_obj[1] ;
30897
30898 if (!args) SWIG_fail;
30899 swig_obj[0] = args;
30900 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30901 if (!SWIG_IsOK(res1)) {
30902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Neg" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30903 }
30904 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30905 {
30906 PyThreadState* __tstate = wxPyBeginAllowThreads();
30907 {
30908 wxDateSpan &_result_ref = (arg1)->Neg();
30909 result = (wxDateSpan *) &_result_ref;
30910 }
30911 wxPyEndAllowThreads(__tstate);
30912 if (PyErr_Occurred()) SWIG_fail;
30913 }
30914 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30915 return resultobj;
30916 fail:
30917 return NULL;
30918 }
30919
30920
30921 SWIGINTERN PyObject *_wrap_DateSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30922 PyObject *resultobj = 0;
30923 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30924 int arg2 ;
30925 wxDateSpan *result = 0 ;
30926 void *argp1 = 0 ;
30927 int res1 = 0 ;
30928 int val2 ;
30929 int ecode2 = 0 ;
30930 PyObject * obj0 = 0 ;
30931 PyObject * obj1 = 0 ;
30932 char * kwnames[] = {
30933 (char *) "self",(char *) "factor", NULL
30934 };
30935
30936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
30937 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30938 if (!SWIG_IsOK(res1)) {
30939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Multiply" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30940 }
30941 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30942 ecode2 = SWIG_AsVal_int(obj1, &val2);
30943 if (!SWIG_IsOK(ecode2)) {
30944 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
30945 }
30946 arg2 = static_cast< int >(val2);
30947 {
30948 PyThreadState* __tstate = wxPyBeginAllowThreads();
30949 {
30950 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
30951 result = (wxDateSpan *) &_result_ref;
30952 }
30953 wxPyEndAllowThreads(__tstate);
30954 if (PyErr_Occurred()) SWIG_fail;
30955 }
30956 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30957 return resultobj;
30958 fail:
30959 return NULL;
30960 }
30961
30962
30963 SWIGINTERN PyObject *_wrap_DateSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30964 PyObject *resultobj = 0;
30965 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30966 wxDateSpan *arg2 = 0 ;
30967 wxDateSpan *result = 0 ;
30968 void *argp1 = 0 ;
30969 int res1 = 0 ;
30970 void *argp2 = 0 ;
30971 int res2 = 0 ;
30972 PyObject * obj0 = 0 ;
30973 PyObject * obj1 = 0 ;
30974 char * kwnames[] = {
30975 (char *) "self",(char *) "other", NULL
30976 };
30977
30978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
30979 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
30980 if (!SWIG_IsOK(res1)) {
30981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___iadd__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30982 }
30983 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30984 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30985 if (!SWIG_IsOK(res2)) {
30986 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30987 }
30988 if (!argp2) {
30989 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30990 }
30991 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30992 {
30993 PyThreadState* __tstate = wxPyBeginAllowThreads();
30994 {
30995 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
30996 result = (wxDateSpan *) &_result_ref;
30997 }
30998 wxPyEndAllowThreads(__tstate);
30999 if (PyErr_Occurred()) SWIG_fail;
31000 }
31001 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31002 return resultobj;
31003 fail:
31004 return NULL;
31005 }
31006
31007
31008 SWIGINTERN PyObject *_wrap_DateSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31009 PyObject *resultobj = 0;
31010 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31011 wxDateSpan *arg2 = 0 ;
31012 wxDateSpan *result = 0 ;
31013 void *argp1 = 0 ;
31014 int res1 = 0 ;
31015 void *argp2 = 0 ;
31016 int res2 = 0 ;
31017 PyObject * obj0 = 0 ;
31018 PyObject * obj1 = 0 ;
31019 char * kwnames[] = {
31020 (char *) "self",(char *) "other", NULL
31021 };
31022
31023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
31024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
31025 if (!SWIG_IsOK(res1)) {
31026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___isub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31027 }
31028 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31029 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31030 if (!SWIG_IsOK(res2)) {
31031 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31032 }
31033 if (!argp2) {
31034 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31035 }
31036 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31037 {
31038 PyThreadState* __tstate = wxPyBeginAllowThreads();
31039 {
31040 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
31041 result = (wxDateSpan *) &_result_ref;
31042 }
31043 wxPyEndAllowThreads(__tstate);
31044 if (PyErr_Occurred()) SWIG_fail;
31045 }
31046 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31047 return resultobj;
31048 fail:
31049 return NULL;
31050 }
31051
31052
31053 SWIGINTERN PyObject *_wrap_DateSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31054 PyObject *resultobj = 0;
31055 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31056 wxDateSpan *result = 0 ;
31057 void *argp1 = 0 ;
31058 int res1 = 0 ;
31059 PyObject *swig_obj[1] ;
31060
31061 if (!args) SWIG_fail;
31062 swig_obj[0] = args;
31063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31064 if (!SWIG_IsOK(res1)) {
31065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___neg__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31066 }
31067 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31068 {
31069 PyThreadState* __tstate = wxPyBeginAllowThreads();
31070 {
31071 wxDateSpan &_result_ref = (arg1)->operator -();
31072 result = (wxDateSpan *) &_result_ref;
31073 }
31074 wxPyEndAllowThreads(__tstate);
31075 if (PyErr_Occurred()) SWIG_fail;
31076 }
31077 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
31078 return resultobj;
31079 fail:
31080 return NULL;
31081 }
31082
31083
31084 SWIGINTERN PyObject *_wrap_DateSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31085 PyObject *resultobj = 0;
31086 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31087 int arg2 ;
31088 wxDateSpan *result = 0 ;
31089 void *argp1 = 0 ;
31090 int res1 = 0 ;
31091 int val2 ;
31092 int ecode2 = 0 ;
31093 PyObject * obj0 = 0 ;
31094 PyObject * obj1 = 0 ;
31095 char * kwnames[] = {
31096 (char *) "self",(char *) "factor", NULL
31097 };
31098
31099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
31100 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
31101 if (!SWIG_IsOK(res1)) {
31102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___imul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31103 }
31104 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31105 ecode2 = SWIG_AsVal_int(obj1, &val2);
31106 if (!SWIG_IsOK(ecode2)) {
31107 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___imul__" "', expected argument " "2"" of type '" "int""'");
31108 }
31109 arg2 = static_cast< int >(val2);
31110 {
31111 PyThreadState* __tstate = wxPyBeginAllowThreads();
31112 {
31113 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
31114 result = (wxDateSpan *) &_result_ref;
31115 }
31116 wxPyEndAllowThreads(__tstate);
31117 if (PyErr_Occurred()) SWIG_fail;
31118 }
31119 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31120 return resultobj;
31121 fail:
31122 return NULL;
31123 }
31124
31125
31126 SWIGINTERN PyObject *_wrap_DateSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31127 PyObject *resultobj = 0;
31128 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31129 wxDateSpan *arg2 = 0 ;
31130 wxDateSpan result;
31131 void *argp1 = 0 ;
31132 int res1 = 0 ;
31133 void *argp2 = 0 ;
31134 int res2 = 0 ;
31135 PyObject * obj0 = 0 ;
31136 PyObject * obj1 = 0 ;
31137 char * kwnames[] = {
31138 (char *) "self",(char *) "other", NULL
31139 };
31140
31141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
31142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31143 if (!SWIG_IsOK(res1)) {
31144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___add__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31145 }
31146 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31147 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31148 if (!SWIG_IsOK(res2)) {
31149 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31150 }
31151 if (!argp2) {
31152 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31153 }
31154 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31155 {
31156 PyThreadState* __tstate = wxPyBeginAllowThreads();
31157 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
31158 wxPyEndAllowThreads(__tstate);
31159 if (PyErr_Occurred()) SWIG_fail;
31160 }
31161 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31162 return resultobj;
31163 fail:
31164 return NULL;
31165 }
31166
31167
31168 SWIGINTERN PyObject *_wrap_DateSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31169 PyObject *resultobj = 0;
31170 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31171 wxDateSpan *arg2 = 0 ;
31172 wxDateSpan result;
31173 void *argp1 = 0 ;
31174 int res1 = 0 ;
31175 void *argp2 = 0 ;
31176 int res2 = 0 ;
31177 PyObject * obj0 = 0 ;
31178 PyObject * obj1 = 0 ;
31179 char * kwnames[] = {
31180 (char *) "self",(char *) "other", NULL
31181 };
31182
31183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
31184 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31185 if (!SWIG_IsOK(res1)) {
31186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___sub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31187 }
31188 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31189 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31190 if (!SWIG_IsOK(res2)) {
31191 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31192 }
31193 if (!argp2) {
31194 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31195 }
31196 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31197 {
31198 PyThreadState* __tstate = wxPyBeginAllowThreads();
31199 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
31200 wxPyEndAllowThreads(__tstate);
31201 if (PyErr_Occurred()) SWIG_fail;
31202 }
31203 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31204 return resultobj;
31205 fail:
31206 return NULL;
31207 }
31208
31209
31210 SWIGINTERN PyObject *_wrap_DateSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31211 PyObject *resultobj = 0;
31212 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31213 int arg2 ;
31214 wxDateSpan result;
31215 void *argp1 = 0 ;
31216 int res1 = 0 ;
31217 int val2 ;
31218 int ecode2 = 0 ;
31219 PyObject * obj0 = 0 ;
31220 PyObject * obj1 = 0 ;
31221 char * kwnames[] = {
31222 (char *) "self",(char *) "n", NULL
31223 };
31224
31225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
31226 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31227 if (!SWIG_IsOK(res1)) {
31228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___mul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31229 }
31230 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31231 ecode2 = SWIG_AsVal_int(obj1, &val2);
31232 if (!SWIG_IsOK(ecode2)) {
31233 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___mul__" "', expected argument " "2"" of type '" "int""'");
31234 }
31235 arg2 = static_cast< int >(val2);
31236 {
31237 PyThreadState* __tstate = wxPyBeginAllowThreads();
31238 result = wxDateSpan___mul__(arg1,arg2);
31239 wxPyEndAllowThreads(__tstate);
31240 if (PyErr_Occurred()) SWIG_fail;
31241 }
31242 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31243 return resultobj;
31244 fail:
31245 return NULL;
31246 }
31247
31248
31249 SWIGINTERN PyObject *_wrap_DateSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31250 PyObject *resultobj = 0;
31251 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31252 int arg2 ;
31253 wxDateSpan result;
31254 void *argp1 = 0 ;
31255 int res1 = 0 ;
31256 int val2 ;
31257 int ecode2 = 0 ;
31258 PyObject * obj0 = 0 ;
31259 PyObject * obj1 = 0 ;
31260 char * kwnames[] = {
31261 (char *) "self",(char *) "n", NULL
31262 };
31263
31264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
31265 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31266 if (!SWIG_IsOK(res1)) {
31267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___rmul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31268 }
31269 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31270 ecode2 = SWIG_AsVal_int(obj1, &val2);
31271 if (!SWIG_IsOK(ecode2)) {
31272 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
31273 }
31274 arg2 = static_cast< int >(val2);
31275 {
31276 PyThreadState* __tstate = wxPyBeginAllowThreads();
31277 result = wxDateSpan___rmul__(arg1,arg2);
31278 wxPyEndAllowThreads(__tstate);
31279 if (PyErr_Occurred()) SWIG_fail;
31280 }
31281 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31282 return resultobj;
31283 fail:
31284 return NULL;
31285 }
31286
31287
31288 SWIGINTERN PyObject *_wrap_DateSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31289 PyObject *resultobj = 0;
31290 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31291 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
31292 bool result;
31293 void *argp1 = 0 ;
31294 int res1 = 0 ;
31295 void *argp2 = 0 ;
31296 int res2 = 0 ;
31297 PyObject * obj0 = 0 ;
31298 PyObject * obj1 = 0 ;
31299 char * kwnames[] = {
31300 (char *) "self",(char *) "other", NULL
31301 };
31302
31303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
31304 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31305 if (!SWIG_IsOK(res1)) {
31306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___eq__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31307 }
31308 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31309 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31310 if (!SWIG_IsOK(res2)) {
31311 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___eq__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
31312 }
31313 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31314 {
31315 PyThreadState* __tstate = wxPyBeginAllowThreads();
31316 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
31317 wxPyEndAllowThreads(__tstate);
31318 if (PyErr_Occurred()) SWIG_fail;
31319 }
31320 {
31321 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31322 }
31323 return resultobj;
31324 fail:
31325 return NULL;
31326 }
31327
31328
31329 SWIGINTERN PyObject *_wrap_DateSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31330 PyObject *resultobj = 0;
31331 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31332 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
31333 bool result;
31334 void *argp1 = 0 ;
31335 int res1 = 0 ;
31336 void *argp2 = 0 ;
31337 int res2 = 0 ;
31338 PyObject * obj0 = 0 ;
31339 PyObject * obj1 = 0 ;
31340 char * kwnames[] = {
31341 (char *) "self",(char *) "other", NULL
31342 };
31343
31344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
31345 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31346 if (!SWIG_IsOK(res1)) {
31347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___ne__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31348 }
31349 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31350 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31351 if (!SWIG_IsOK(res2)) {
31352 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___ne__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
31353 }
31354 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31355 {
31356 PyThreadState* __tstate = wxPyBeginAllowThreads();
31357 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
31358 wxPyEndAllowThreads(__tstate);
31359 if (PyErr_Occurred()) SWIG_fail;
31360 }
31361 {
31362 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31363 }
31364 return resultobj;
31365 fail:
31366 return NULL;
31367 }
31368
31369
31370 SWIGINTERN PyObject *DateSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31371 PyObject *obj;
31372 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31373 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateSpan, SWIG_NewClientData(obj));
31374 return SWIG_Py_Void();
31375 }
31376
31377 SWIGINTERN PyObject *DateSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31378 return SWIG_Python_InitShadowInstance(args);
31379 }
31380
31381 SWIGINTERN PyObject *_wrap_GetLocalTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31382 PyObject *resultobj = 0;
31383 long result;
31384
31385 if (!SWIG_Python_UnpackTuple(args,"GetLocalTime",0,0,0)) SWIG_fail;
31386 {
31387 PyThreadState* __tstate = wxPyBeginAllowThreads();
31388 result = (long)wxGetLocalTime();
31389 wxPyEndAllowThreads(__tstate);
31390 if (PyErr_Occurred()) SWIG_fail;
31391 }
31392 resultobj = SWIG_From_long(static_cast< long >(result));
31393 return resultobj;
31394 fail:
31395 return NULL;
31396 }
31397
31398
31399 SWIGINTERN PyObject *_wrap_GetUTCTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31400 PyObject *resultobj = 0;
31401 long result;
31402
31403 if (!SWIG_Python_UnpackTuple(args,"GetUTCTime",0,0,0)) SWIG_fail;
31404 {
31405 PyThreadState* __tstate = wxPyBeginAllowThreads();
31406 result = (long)wxGetUTCTime();
31407 wxPyEndAllowThreads(__tstate);
31408 if (PyErr_Occurred()) SWIG_fail;
31409 }
31410 resultobj = SWIG_From_long(static_cast< long >(result));
31411 return resultobj;
31412 fail:
31413 return NULL;
31414 }
31415
31416
31417 SWIGINTERN PyObject *_wrap_GetCurrentTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31418 PyObject *resultobj = 0;
31419 long result;
31420
31421 if (!SWIG_Python_UnpackTuple(args,"GetCurrentTime",0,0,0)) SWIG_fail;
31422 {
31423 PyThreadState* __tstate = wxPyBeginAllowThreads();
31424 result = (long)wxGetCurrentTime();
31425 wxPyEndAllowThreads(__tstate);
31426 if (PyErr_Occurred()) SWIG_fail;
31427 }
31428 resultobj = SWIG_From_long(static_cast< long >(result));
31429 return resultobj;
31430 fail:
31431 return NULL;
31432 }
31433
31434
31435 SWIGINTERN PyObject *_wrap_GetLocalTimeMillis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31436 PyObject *resultobj = 0;
31437 wxLongLong result;
31438
31439 if (!SWIG_Python_UnpackTuple(args,"GetLocalTimeMillis",0,0,0)) SWIG_fail;
31440 {
31441 PyThreadState* __tstate = wxPyBeginAllowThreads();
31442 result = wxGetLocalTimeMillis();
31443 wxPyEndAllowThreads(__tstate);
31444 if (PyErr_Occurred()) SWIG_fail;
31445 }
31446 {
31447 PyObject *hi, *lo, *shifter, *shifted;
31448 hi = PyLong_FromLong( (&result)->GetHi() );
31449 lo = PyLong_FromLong( (&result)->GetLo() );
31450 shifter = PyLong_FromLong(32);
31451 shifted = PyNumber_Lshift(hi, shifter);
31452 resultobj = PyNumber_Or(shifted, lo);
31453 Py_DECREF(hi);
31454 Py_DECREF(lo);
31455 Py_DECREF(shifter);
31456 Py_DECREF(shifted);
31457 }
31458 return resultobj;
31459 fail:
31460 return NULL;
31461 }
31462
31463
31464 SWIGINTERN int DefaultDateTime_set(PyObject *) {
31465 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTime is read-only.");
31466 return 1;
31467 }
31468
31469
31470 SWIGINTERN PyObject *DefaultDateTime_get(void) {
31471 PyObject *pyobj = 0;
31472
31473 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0 );
31474 return pyobj;
31475 }
31476
31477
31478 SWIGINTERN PyObject *_wrap_new_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31479 PyObject *resultobj = 0;
31480 wxDataFormatId arg1 ;
31481 wxDataFormat *result = 0 ;
31482 int val1 ;
31483 int ecode1 = 0 ;
31484 PyObject * obj0 = 0 ;
31485 char * kwnames[] = {
31486 (char *) "type", NULL
31487 };
31488
31489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) SWIG_fail;
31490 ecode1 = SWIG_AsVal_int(obj0, &val1);
31491 if (!SWIG_IsOK(ecode1)) {
31492 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DataFormat" "', expected argument " "1"" of type '" "wxDataFormatId""'");
31493 }
31494 arg1 = static_cast< wxDataFormatId >(val1);
31495 {
31496 PyThreadState* __tstate = wxPyBeginAllowThreads();
31497 result = (wxDataFormat *)new wxDataFormat(arg1);
31498 wxPyEndAllowThreads(__tstate);
31499 if (PyErr_Occurred()) SWIG_fail;
31500 }
31501 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_NEW | 0 );
31502 return resultobj;
31503 fail:
31504 return NULL;
31505 }
31506
31507
31508 SWIGINTERN PyObject *_wrap_new_CustomDataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31509 PyObject *resultobj = 0;
31510 wxString *arg1 = 0 ;
31511 wxDataFormat *result = 0 ;
31512 bool temp1 = false ;
31513 PyObject * obj0 = 0 ;
31514 char * kwnames[] = {
31515 (char *) "format", NULL
31516 };
31517
31518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) SWIG_fail;
31519 {
31520 arg1 = wxString_in_helper(obj0);
31521 if (arg1 == NULL) SWIG_fail;
31522 temp1 = true;
31523 }
31524 {
31525 PyThreadState* __tstate = wxPyBeginAllowThreads();
31526 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
31527 wxPyEndAllowThreads(__tstate);
31528 if (PyErr_Occurred()) SWIG_fail;
31529 }
31530 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
31531 {
31532 if (temp1)
31533 delete arg1;
31534 }
31535 return resultobj;
31536 fail:
31537 {
31538 if (temp1)
31539 delete arg1;
31540 }
31541 return NULL;
31542 }
31543
31544
31545 SWIGINTERN PyObject *_wrap_delete_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31546 PyObject *resultobj = 0;
31547 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31548 void *argp1 = 0 ;
31549 int res1 = 0 ;
31550 PyObject *swig_obj[1] ;
31551
31552 if (!args) SWIG_fail;
31553 swig_obj[0] = args;
31554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, SWIG_POINTER_DISOWN | 0 );
31555 if (!SWIG_IsOK(res1)) {
31556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataFormat" "', expected argument " "1"" of type '" "wxDataFormat *""'");
31557 }
31558 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31559 {
31560 PyThreadState* __tstate = wxPyBeginAllowThreads();
31561 delete arg1;
31562
31563 wxPyEndAllowThreads(__tstate);
31564 if (PyErr_Occurred()) SWIG_fail;
31565 }
31566 resultobj = SWIG_Py_Void();
31567 return resultobj;
31568 fail:
31569 return NULL;
31570 }
31571
31572
31573 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31574 PyObject *resultobj = 0;
31575 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31576 wxDataFormatId arg2 ;
31577 bool result;
31578 void *argp1 = 0 ;
31579 int res1 = 0 ;
31580 int val2 ;
31581 int ecode2 = 0 ;
31582
31583 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31585 if (!SWIG_IsOK(res1)) {
31586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31587 }
31588 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31589 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
31590 if (!SWIG_IsOK(ecode2)) {
31591 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31592 }
31593 arg2 = static_cast< wxDataFormatId >(val2);
31594 {
31595 PyThreadState* __tstate = wxPyBeginAllowThreads();
31596 result = (bool)((wxDataFormat const *)arg1)->operator ==(arg2);
31597 wxPyEndAllowThreads(__tstate);
31598 if (PyErr_Occurred()) SWIG_fail;
31599 }
31600 {
31601 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31602 }
31603 return resultobj;
31604 fail:
31605 return NULL;
31606 }
31607
31608
31609 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31610 PyObject *resultobj = 0;
31611 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31612 wxDataFormatId arg2 ;
31613 bool result;
31614 void *argp1 = 0 ;
31615 int res1 = 0 ;
31616 int val2 ;
31617 int ecode2 = 0 ;
31618
31619 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31621 if (!SWIG_IsOK(res1)) {
31622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31623 }
31624 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31625 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
31626 if (!SWIG_IsOK(ecode2)) {
31627 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31628 }
31629 arg2 = static_cast< wxDataFormatId >(val2);
31630 {
31631 PyThreadState* __tstate = wxPyBeginAllowThreads();
31632 result = (bool)((wxDataFormat const *)arg1)->operator !=(arg2);
31633 wxPyEndAllowThreads(__tstate);
31634 if (PyErr_Occurred()) SWIG_fail;
31635 }
31636 {
31637 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31638 }
31639 return resultobj;
31640 fail:
31641 return NULL;
31642 }
31643
31644
31645 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31646 PyObject *resultobj = 0;
31647 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31648 wxDataFormat *arg2 = 0 ;
31649 bool result;
31650 void *argp1 = 0 ;
31651 int res1 = 0 ;
31652 void *argp2 = 0 ;
31653 int res2 = 0 ;
31654
31655 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
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___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31659 }
31660 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31661 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31662 if (!SWIG_IsOK(res2)) {
31663 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31664 }
31665 if (!argp2) {
31666 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31667 }
31668 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31669 {
31670 PyThreadState* __tstate = wxPyBeginAllowThreads();
31671 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
31672 wxPyEndAllowThreads(__tstate);
31673 if (PyErr_Occurred()) SWIG_fail;
31674 }
31675 {
31676 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31677 }
31678 return resultobj;
31679 fail:
31680 return NULL;
31681 }
31682
31683
31684 SWIGINTERN PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
31685 int argc;
31686 PyObject *argv[3];
31687
31688 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___eq__",0,2,argv))) SWIG_fail;
31689 --argc;
31690 if (argc == 2) {
31691 int _v = 0;
31692 {
31693 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
31694 _v = SWIG_CheckState(res);
31695 }
31696 if (!_v) goto check_1;
31697 return _wrap_DataFormat___eq____SWIG_1(self, argc, argv);
31698 }
31699 check_1:
31700
31701 if (argc == 2) {
31702 return _wrap_DataFormat___eq____SWIG_0(self, argc, argv);
31703 }
31704
31705 fail:
31706 Py_INCREF(Py_NotImplemented);
31707 return Py_NotImplemented;
31708 }
31709
31710
31711 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31712 PyObject *resultobj = 0;
31713 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31714 wxDataFormat *arg2 = 0 ;
31715 bool result;
31716 void *argp1 = 0 ;
31717 int res1 = 0 ;
31718 void *argp2 = 0 ;
31719 int res2 = 0 ;
31720
31721 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31723 if (!SWIG_IsOK(res1)) {
31724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31725 }
31726 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31727 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31728 if (!SWIG_IsOK(res2)) {
31729 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31730 }
31731 if (!argp2) {
31732 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31733 }
31734 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31735 {
31736 PyThreadState* __tstate = wxPyBeginAllowThreads();
31737 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
31738 wxPyEndAllowThreads(__tstate);
31739 if (PyErr_Occurred()) SWIG_fail;
31740 }
31741 {
31742 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31743 }
31744 return resultobj;
31745 fail:
31746 return NULL;
31747 }
31748
31749
31750 SWIGINTERN PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
31751 int argc;
31752 PyObject *argv[3];
31753
31754 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___ne__",0,2,argv))) SWIG_fail;
31755 --argc;
31756 if (argc == 2) {
31757 int _v = 0;
31758 {
31759 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
31760 _v = SWIG_CheckState(res);
31761 }
31762 if (!_v) goto check_1;
31763 return _wrap_DataFormat___ne____SWIG_1(self, argc, argv);
31764 }
31765 check_1:
31766
31767 if (argc == 2) {
31768 return _wrap_DataFormat___ne____SWIG_0(self, argc, argv);
31769 }
31770
31771 fail:
31772 Py_INCREF(Py_NotImplemented);
31773 return Py_NotImplemented;
31774 }
31775
31776
31777 SWIGINTERN PyObject *_wrap_DataFormat_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31778 PyObject *resultobj = 0;
31779 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31780 wxDataFormatId arg2 ;
31781 void *argp1 = 0 ;
31782 int res1 = 0 ;
31783 int val2 ;
31784 int ecode2 = 0 ;
31785 PyObject * obj0 = 0 ;
31786 PyObject * obj1 = 0 ;
31787 char * kwnames[] = {
31788 (char *) "self",(char *) "format", NULL
31789 };
31790
31791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
31792 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31793 if (!SWIG_IsOK(res1)) {
31794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetType" "', expected argument " "1"" of type '" "wxDataFormat *""'");
31795 }
31796 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31797 ecode2 = SWIG_AsVal_int(obj1, &val2);
31798 if (!SWIG_IsOK(ecode2)) {
31799 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat_SetType" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31800 }
31801 arg2 = static_cast< wxDataFormatId >(val2);
31802 {
31803 PyThreadState* __tstate = wxPyBeginAllowThreads();
31804 (arg1)->SetType(arg2);
31805 wxPyEndAllowThreads(__tstate);
31806 if (PyErr_Occurred()) SWIG_fail;
31807 }
31808 resultobj = SWIG_Py_Void();
31809 return resultobj;
31810 fail:
31811 return NULL;
31812 }
31813
31814
31815 SWIGINTERN PyObject *_wrap_DataFormat_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31816 PyObject *resultobj = 0;
31817 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31818 wxDataFormatId result;
31819 void *argp1 = 0 ;
31820 int res1 = 0 ;
31821 PyObject *swig_obj[1] ;
31822
31823 if (!args) SWIG_fail;
31824 swig_obj[0] = args;
31825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31826 if (!SWIG_IsOK(res1)) {
31827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetType" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31828 }
31829 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31830 {
31831 PyThreadState* __tstate = wxPyBeginAllowThreads();
31832 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
31833 wxPyEndAllowThreads(__tstate);
31834 if (PyErr_Occurred()) SWIG_fail;
31835 }
31836 resultobj = SWIG_From_int(static_cast< int >(result));
31837 return resultobj;
31838 fail:
31839 return NULL;
31840 }
31841
31842
31843 SWIGINTERN PyObject *_wrap_DataFormat_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31844 PyObject *resultobj = 0;
31845 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31846 wxString result;
31847 void *argp1 = 0 ;
31848 int res1 = 0 ;
31849 PyObject *swig_obj[1] ;
31850
31851 if (!args) SWIG_fail;
31852 swig_obj[0] = args;
31853 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31854 if (!SWIG_IsOK(res1)) {
31855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetId" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31856 }
31857 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31858 {
31859 PyThreadState* __tstate = wxPyBeginAllowThreads();
31860 result = ((wxDataFormat const *)arg1)->GetId();
31861 wxPyEndAllowThreads(__tstate);
31862 if (PyErr_Occurred()) SWIG_fail;
31863 }
31864 {
31865 #if wxUSE_UNICODE
31866 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31867 #else
31868 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31869 #endif
31870 }
31871 return resultobj;
31872 fail:
31873 return NULL;
31874 }
31875
31876
31877 SWIGINTERN PyObject *_wrap_DataFormat_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31878 PyObject *resultobj = 0;
31879 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31880 wxString *arg2 = 0 ;
31881 void *argp1 = 0 ;
31882 int res1 = 0 ;
31883 bool temp2 = false ;
31884 PyObject * obj0 = 0 ;
31885 PyObject * obj1 = 0 ;
31886 char * kwnames[] = {
31887 (char *) "self",(char *) "format", NULL
31888 };
31889
31890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
31891 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31892 if (!SWIG_IsOK(res1)) {
31893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetId" "', expected argument " "1"" of type '" "wxDataFormat *""'");
31894 }
31895 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31896 {
31897 arg2 = wxString_in_helper(obj1);
31898 if (arg2 == NULL) SWIG_fail;
31899 temp2 = true;
31900 }
31901 {
31902 PyThreadState* __tstate = wxPyBeginAllowThreads();
31903 (arg1)->SetId((wxString const &)*arg2);
31904 wxPyEndAllowThreads(__tstate);
31905 if (PyErr_Occurred()) SWIG_fail;
31906 }
31907 resultobj = SWIG_Py_Void();
31908 {
31909 if (temp2)
31910 delete arg2;
31911 }
31912 return resultobj;
31913 fail:
31914 {
31915 if (temp2)
31916 delete arg2;
31917 }
31918 return NULL;
31919 }
31920
31921
31922 SWIGINTERN PyObject *DataFormat_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31923 PyObject *obj;
31924 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31925 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataFormat, SWIG_NewClientData(obj));
31926 return SWIG_Py_Void();
31927 }
31928
31929 SWIGINTERN PyObject *DataFormat_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31930 return SWIG_Python_InitShadowInstance(args);
31931 }
31932
31933 SWIGINTERN int FormatInvalid_set(PyObject *) {
31934 SWIG_Error(SWIG_AttributeError,"Variable FormatInvalid is read-only.");
31935 return 1;
31936 }
31937
31938
31939 SWIGINTERN PyObject *FormatInvalid_get(void) {
31940 PyObject *pyobj = 0;
31941
31942 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0 );
31943 return pyobj;
31944 }
31945
31946
31947 SWIGINTERN PyObject *_wrap_delete_DataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31948 PyObject *resultobj = 0;
31949 wxDataObject *arg1 = (wxDataObject *) 0 ;
31950 void *argp1 = 0 ;
31951 int res1 = 0 ;
31952 PyObject *swig_obj[1] ;
31953
31954 if (!args) SWIG_fail;
31955 swig_obj[0] = args;
31956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
31957 if (!SWIG_IsOK(res1)) {
31958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataObject" "', expected argument " "1"" of type '" "wxDataObject *""'");
31959 }
31960 arg1 = reinterpret_cast< wxDataObject * >(argp1);
31961 {
31962 PyThreadState* __tstate = wxPyBeginAllowThreads();
31963 delete arg1;
31964
31965 wxPyEndAllowThreads(__tstate);
31966 if (PyErr_Occurred()) SWIG_fail;
31967 }
31968 resultobj = SWIG_Py_Void();
31969 return resultobj;
31970 fail:
31971 return NULL;
31972 }
31973
31974
31975 SWIGINTERN PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31976 PyObject *resultobj = 0;
31977 wxDataObject *arg1 = (wxDataObject *) 0 ;
31978 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
31979 SwigValueWrapper<wxDataFormat > result;
31980 void *argp1 = 0 ;
31981 int res1 = 0 ;
31982 int val2 ;
31983 int ecode2 = 0 ;
31984 PyObject * obj0 = 0 ;
31985 PyObject * obj1 = 0 ;
31986 char * kwnames[] = {
31987 (char *) "self",(char *) "dir", NULL
31988 };
31989
31990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) SWIG_fail;
31991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
31992 if (!SWIG_IsOK(res1)) {
31993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "1"" of type '" "wxDataObject const *""'");
31994 }
31995 arg1 = reinterpret_cast< wxDataObject * >(argp1);
31996 if (obj1) {
31997 ecode2 = SWIG_AsVal_int(obj1, &val2);
31998 if (!SWIG_IsOK(ecode2)) {
31999 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
32000 }
32001 arg2 = static_cast< wxDataObject::Direction >(val2);
32002 }
32003 {
32004 PyThreadState* __tstate = wxPyBeginAllowThreads();
32005 result = ((wxDataObject const *)arg1)->GetPreferredFormat(arg2);
32006 wxPyEndAllowThreads(__tstate);
32007 if (PyErr_Occurred()) SWIG_fail;
32008 }
32009 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
32010 return resultobj;
32011 fail:
32012 return NULL;
32013 }
32014
32015
32016 SWIGINTERN PyObject *_wrap_DataObject_GetFormatCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32017 PyObject *resultobj = 0;
32018 wxDataObject *arg1 = (wxDataObject *) 0 ;
32019 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
32020 size_t result;
32021 void *argp1 = 0 ;
32022 int res1 = 0 ;
32023 int val2 ;
32024 int ecode2 = 0 ;
32025 PyObject * obj0 = 0 ;
32026 PyObject * obj1 = 0 ;
32027 char * kwnames[] = {
32028 (char *) "self",(char *) "dir", NULL
32029 };
32030
32031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) SWIG_fail;
32032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32033 if (!SWIG_IsOK(res1)) {
32034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetFormatCount" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32035 }
32036 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32037 if (obj1) {
32038 ecode2 = SWIG_AsVal_int(obj1, &val2);
32039 if (!SWIG_IsOK(ecode2)) {
32040 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetFormatCount" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
32041 }
32042 arg2 = static_cast< wxDataObject::Direction >(val2);
32043 }
32044 {
32045 PyThreadState* __tstate = wxPyBeginAllowThreads();
32046 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount(arg2);
32047 wxPyEndAllowThreads(__tstate);
32048 if (PyErr_Occurred()) SWIG_fail;
32049 }
32050 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32051 return resultobj;
32052 fail:
32053 return NULL;
32054 }
32055
32056
32057 SWIGINTERN PyObject *_wrap_DataObject_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32058 PyObject *resultobj = 0;
32059 wxDataObject *arg1 = (wxDataObject *) 0 ;
32060 wxDataFormat *arg2 = 0 ;
32061 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
32062 bool result;
32063 void *argp1 = 0 ;
32064 int res1 = 0 ;
32065 void *argp2 = 0 ;
32066 int res2 = 0 ;
32067 int val3 ;
32068 int ecode3 = 0 ;
32069 PyObject * obj0 = 0 ;
32070 PyObject * obj1 = 0 ;
32071 PyObject * obj2 = 0 ;
32072 char * kwnames[] = {
32073 (char *) "self",(char *) "format",(char *) "dir", NULL
32074 };
32075
32076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32078 if (!SWIG_IsOK(res1)) {
32079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_IsSupported" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32080 }
32081 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32082 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32083 if (!SWIG_IsOK(res2)) {
32084 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32085 }
32086 if (!argp2) {
32087 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32088 }
32089 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32090 if (obj2) {
32091 ecode3 = SWIG_AsVal_int(obj2, &val3);
32092 if (!SWIG_IsOK(ecode3)) {
32093 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObject_IsSupported" "', expected argument " "3"" of type '" "wxDataObject::Direction""'");
32094 }
32095 arg3 = static_cast< wxDataObject::Direction >(val3);
32096 }
32097 {
32098 PyThreadState* __tstate = wxPyBeginAllowThreads();
32099 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,arg3);
32100 wxPyEndAllowThreads(__tstate);
32101 if (PyErr_Occurred()) SWIG_fail;
32102 }
32103 {
32104 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32105 }
32106 return resultobj;
32107 fail:
32108 return NULL;
32109 }
32110
32111
32112 SWIGINTERN PyObject *_wrap_DataObject_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32113 PyObject *resultobj = 0;
32114 wxDataObject *arg1 = (wxDataObject *) 0 ;
32115 wxDataFormat *arg2 = 0 ;
32116 size_t result;
32117 void *argp1 = 0 ;
32118 int res1 = 0 ;
32119 void *argp2 = 0 ;
32120 int res2 = 0 ;
32121 PyObject * obj0 = 0 ;
32122 PyObject * obj1 = 0 ;
32123 char * kwnames[] = {
32124 (char *) "self",(char *) "format", NULL
32125 };
32126
32127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) SWIG_fail;
32128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32129 if (!SWIG_IsOK(res1)) {
32130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataSize" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32131 }
32132 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32133 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32134 if (!SWIG_IsOK(res2)) {
32135 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32136 }
32137 if (!argp2) {
32138 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32139 }
32140 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32141 {
32142 PyThreadState* __tstate = wxPyBeginAllowThreads();
32143 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
32144 wxPyEndAllowThreads(__tstate);
32145 if (PyErr_Occurred()) SWIG_fail;
32146 }
32147 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32148 return resultobj;
32149 fail:
32150 return NULL;
32151 }
32152
32153
32154 SWIGINTERN PyObject *_wrap_DataObject_GetAllFormats(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32155 PyObject *resultobj = 0;
32156 wxDataObject *arg1 = (wxDataObject *) 0 ;
32157 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
32158 PyObject *result = 0 ;
32159 void *argp1 = 0 ;
32160 int res1 = 0 ;
32161 int val2 ;
32162 int ecode2 = 0 ;
32163 PyObject * obj0 = 0 ;
32164 PyObject * obj1 = 0 ;
32165 char * kwnames[] = {
32166 (char *) "self",(char *) "dir", NULL
32167 };
32168
32169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) SWIG_fail;
32170 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32171 if (!SWIG_IsOK(res1)) {
32172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetAllFormats" "', expected argument " "1"" of type '" "wxDataObject *""'");
32173 }
32174 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32175 if (obj1) {
32176 ecode2 = SWIG_AsVal_int(obj1, &val2);
32177 if (!SWIG_IsOK(ecode2)) {
32178 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetAllFormats" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
32179 }
32180 arg2 = static_cast< wxDataObject::Direction >(val2);
32181 }
32182 {
32183 PyThreadState* __tstate = wxPyBeginAllowThreads();
32184 result = (PyObject *)wxDataObject_GetAllFormats(arg1,arg2);
32185 wxPyEndAllowThreads(__tstate);
32186 if (PyErr_Occurred()) SWIG_fail;
32187 }
32188 resultobj = result;
32189 return resultobj;
32190 fail:
32191 return NULL;
32192 }
32193
32194
32195 SWIGINTERN PyObject *_wrap_DataObject_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32196 PyObject *resultobj = 0;
32197 wxDataObject *arg1 = (wxDataObject *) 0 ;
32198 wxDataFormat *arg2 = 0 ;
32199 PyObject *result = 0 ;
32200 void *argp1 = 0 ;
32201 int res1 = 0 ;
32202 void *argp2 = 0 ;
32203 int res2 = 0 ;
32204 PyObject * obj0 = 0 ;
32205 PyObject * obj1 = 0 ;
32206 char * kwnames[] = {
32207 (char *) "self",(char *) "format", NULL
32208 };
32209
32210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) SWIG_fail;
32211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32212 if (!SWIG_IsOK(res1)) {
32213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataHere" "', expected argument " "1"" of type '" "wxDataObject *""'");
32214 }
32215 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32216 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32217 if (!SWIG_IsOK(res2)) {
32218 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32219 }
32220 if (!argp2) {
32221 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32222 }
32223 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32224 {
32225 PyThreadState* __tstate = wxPyBeginAllowThreads();
32226 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
32227 wxPyEndAllowThreads(__tstate);
32228 if (PyErr_Occurred()) SWIG_fail;
32229 }
32230 resultobj = result;
32231 return resultobj;
32232 fail:
32233 return NULL;
32234 }
32235
32236
32237 SWIGINTERN PyObject *_wrap_DataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32238 PyObject *resultobj = 0;
32239 wxDataObject *arg1 = (wxDataObject *) 0 ;
32240 wxDataFormat *arg2 = 0 ;
32241 PyObject *arg3 = (PyObject *) 0 ;
32242 bool result;
32243 void *argp1 = 0 ;
32244 int res1 = 0 ;
32245 void *argp2 = 0 ;
32246 int res2 = 0 ;
32247 PyObject * obj0 = 0 ;
32248 PyObject * obj1 = 0 ;
32249 PyObject * obj2 = 0 ;
32250 char * kwnames[] = {
32251 (char *) "self",(char *) "format",(char *) "data", NULL
32252 };
32253
32254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32255 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32256 if (!SWIG_IsOK(res1)) {
32257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_SetData" "', expected argument " "1"" of type '" "wxDataObject *""'");
32258 }
32259 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32260 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32261 if (!SWIG_IsOK(res2)) {
32262 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32263 }
32264 if (!argp2) {
32265 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32266 }
32267 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32268 arg3 = obj2;
32269 {
32270 PyThreadState* __tstate = wxPyBeginAllowThreads();
32271 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
32272 wxPyEndAllowThreads(__tstate);
32273 if (PyErr_Occurred()) SWIG_fail;
32274 }
32275 {
32276 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32277 }
32278 return resultobj;
32279 fail:
32280 return NULL;
32281 }
32282
32283
32284 SWIGINTERN PyObject *DataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32285 PyObject *obj;
32286 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32287 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObject, SWIG_NewClientData(obj));
32288 return SWIG_Py_Void();
32289 }
32290
32291 SWIGINTERN PyObject *_wrap_new_DataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32292 PyObject *resultobj = 0;
32293 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
32294 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
32295 wxDataObjectSimple *result = 0 ;
32296 void *argp1 = 0 ;
32297 int res1 = 0 ;
32298 PyObject * obj0 = 0 ;
32299 char * kwnames[] = {
32300 (char *) "format", NULL
32301 };
32302
32303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) SWIG_fail;
32304 if (obj0) {
32305 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
32306 if (!SWIG_IsOK(res1)) {
32307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32308 }
32309 if (!argp1) {
32310 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32311 }
32312 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
32313 }
32314 {
32315 PyThreadState* __tstate = wxPyBeginAllowThreads();
32316 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
32317 wxPyEndAllowThreads(__tstate);
32318 if (PyErr_Occurred()) SWIG_fail;
32319 }
32320 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_NEW | 0 );
32321 return resultobj;
32322 fail:
32323 return NULL;
32324 }
32325
32326
32327 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32328 PyObject *resultobj = 0;
32329 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32330 wxDataFormat *result = 0 ;
32331 void *argp1 = 0 ;
32332 int res1 = 0 ;
32333 PyObject *swig_obj[1] ;
32334
32335 if (!args) SWIG_fail;
32336 swig_obj[0] = args;
32337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32338 if (!SWIG_IsOK(res1)) {
32339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32340 }
32341 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32342 {
32343 PyThreadState* __tstate = wxPyBeginAllowThreads();
32344 {
32345 wxDataFormat const &_result_ref = (arg1)->GetFormat();
32346 result = (wxDataFormat *) &_result_ref;
32347 }
32348 wxPyEndAllowThreads(__tstate);
32349 if (PyErr_Occurred()) SWIG_fail;
32350 }
32351 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, 0 | 0 );
32352 return resultobj;
32353 fail:
32354 return NULL;
32355 }
32356
32357
32358 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32359 PyObject *resultobj = 0;
32360 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32361 wxDataFormat *arg2 = 0 ;
32362 void *argp1 = 0 ;
32363 int res1 = 0 ;
32364 void *argp2 = 0 ;
32365 int res2 = 0 ;
32366 PyObject * obj0 = 0 ;
32367 PyObject * obj1 = 0 ;
32368 char * kwnames[] = {
32369 (char *) "self",(char *) "format", NULL
32370 };
32371
32372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) SWIG_fail;
32373 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32374 if (!SWIG_IsOK(res1)) {
32375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32376 }
32377 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32378 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32379 if (!SWIG_IsOK(res2)) {
32380 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32381 }
32382 if (!argp2) {
32383 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32384 }
32385 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32386 {
32387 PyThreadState* __tstate = wxPyBeginAllowThreads();
32388 (arg1)->SetFormat((wxDataFormat const &)*arg2);
32389 wxPyEndAllowThreads(__tstate);
32390 if (PyErr_Occurred()) SWIG_fail;
32391 }
32392 resultobj = SWIG_Py_Void();
32393 return resultobj;
32394 fail:
32395 return NULL;
32396 }
32397
32398
32399 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32400 PyObject *resultobj = 0;
32401 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32402 size_t result;
32403 void *argp1 = 0 ;
32404 int res1 = 0 ;
32405 PyObject *swig_obj[1] ;
32406
32407 if (!args) SWIG_fail;
32408 swig_obj[0] = args;
32409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32410 if (!SWIG_IsOK(res1)) {
32411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataSize" "', expected argument " "1"" of type '" "wxDataObjectSimple const *""'");
32412 }
32413 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32414 {
32415 PyThreadState* __tstate = wxPyBeginAllowThreads();
32416 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
32417 wxPyEndAllowThreads(__tstate);
32418 if (PyErr_Occurred()) SWIG_fail;
32419 }
32420 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32421 return resultobj;
32422 fail:
32423 return NULL;
32424 }
32425
32426
32427 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32428 PyObject *resultobj = 0;
32429 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32430 PyObject *result = 0 ;
32431 void *argp1 = 0 ;
32432 int res1 = 0 ;
32433 PyObject *swig_obj[1] ;
32434
32435 if (!args) SWIG_fail;
32436 swig_obj[0] = args;
32437 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32438 if (!SWIG_IsOK(res1)) {
32439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataHere" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32440 }
32441 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32442 {
32443 PyThreadState* __tstate = wxPyBeginAllowThreads();
32444 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
32445 wxPyEndAllowThreads(__tstate);
32446 if (PyErr_Occurred()) SWIG_fail;
32447 }
32448 resultobj = result;
32449 return resultobj;
32450 fail:
32451 return NULL;
32452 }
32453
32454
32455 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32456 PyObject *resultobj = 0;
32457 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32458 PyObject *arg2 = (PyObject *) 0 ;
32459 bool result;
32460 void *argp1 = 0 ;
32461 int res1 = 0 ;
32462 PyObject * obj0 = 0 ;
32463 PyObject * obj1 = 0 ;
32464 char * kwnames[] = {
32465 (char *) "self",(char *) "data", NULL
32466 };
32467
32468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
32469 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32470 if (!SWIG_IsOK(res1)) {
32471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetData" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32472 }
32473 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32474 arg2 = obj1;
32475 {
32476 PyThreadState* __tstate = wxPyBeginAllowThreads();
32477 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
32478 wxPyEndAllowThreads(__tstate);
32479 if (PyErr_Occurred()) SWIG_fail;
32480 }
32481 {
32482 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32483 }
32484 return resultobj;
32485 fail:
32486 return NULL;
32487 }
32488
32489
32490 SWIGINTERN PyObject *DataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32491 PyObject *obj;
32492 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32493 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectSimple, SWIG_NewClientData(obj));
32494 return SWIG_Py_Void();
32495 }
32496
32497 SWIGINTERN PyObject *DataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32498 return SWIG_Python_InitShadowInstance(args);
32499 }
32500
32501 SWIGINTERN PyObject *_wrap_new_PyDataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32502 PyObject *resultobj = 0;
32503 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
32504 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
32505 wxPyDataObjectSimple *result = 0 ;
32506 void *argp1 = 0 ;
32507 int res1 = 0 ;
32508 PyObject * obj0 = 0 ;
32509 char * kwnames[] = {
32510 (char *) "format", NULL
32511 };
32512
32513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) SWIG_fail;
32514 if (obj0) {
32515 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
32516 if (!SWIG_IsOK(res1)) {
32517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32518 }
32519 if (!argp1) {
32520 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32521 }
32522 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
32523 }
32524 {
32525 PyThreadState* __tstate = wxPyBeginAllowThreads();
32526 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
32527 wxPyEndAllowThreads(__tstate);
32528 if (PyErr_Occurred()) SWIG_fail;
32529 }
32530 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_NEW | 0 );
32531 return resultobj;
32532 fail:
32533 return NULL;
32534 }
32535
32536
32537 SWIGINTERN PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32538 PyObject *resultobj = 0;
32539 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
32540 PyObject *arg2 = (PyObject *) 0 ;
32541 PyObject *arg3 = (PyObject *) 0 ;
32542 void *argp1 = 0 ;
32543 int res1 = 0 ;
32544 PyObject * obj0 = 0 ;
32545 PyObject * obj1 = 0 ;
32546 PyObject * obj2 = 0 ;
32547 char * kwnames[] = {
32548 (char *) "self",(char *) "self",(char *) "_class", NULL
32549 };
32550
32551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32552 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDataObjectSimple, 0 | 0 );
32553 if (!SWIG_IsOK(res1)) {
32554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyDataObjectSimple__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDataObjectSimple *""'");
32555 }
32556 arg1 = reinterpret_cast< wxPyDataObjectSimple * >(argp1);
32557 arg2 = obj1;
32558 arg3 = obj2;
32559 {
32560 PyThreadState* __tstate = wxPyBeginAllowThreads();
32561 (arg1)->_setCallbackInfo(arg2,arg3);
32562 wxPyEndAllowThreads(__tstate);
32563 if (PyErr_Occurred()) SWIG_fail;
32564 }
32565 resultobj = SWIG_Py_Void();
32566 return resultobj;
32567 fail:
32568 return NULL;
32569 }
32570
32571
32572 SWIGINTERN PyObject *PyDataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32573 PyObject *obj;
32574 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32575 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDataObjectSimple, SWIG_NewClientData(obj));
32576 return SWIG_Py_Void();
32577 }
32578
32579 SWIGINTERN PyObject *PyDataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32580 return SWIG_Python_InitShadowInstance(args);
32581 }
32582
32583 SWIGINTERN PyObject *_wrap_new_DataObjectComposite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32584 PyObject *resultobj = 0;
32585 wxDataObjectComposite *result = 0 ;
32586
32587 if (!SWIG_Python_UnpackTuple(args,"new_DataObjectComposite",0,0,0)) SWIG_fail;
32588 {
32589 PyThreadState* __tstate = wxPyBeginAllowThreads();
32590 result = (wxDataObjectComposite *)new wxDataObjectComposite();
32591 wxPyEndAllowThreads(__tstate);
32592 if (PyErr_Occurred()) SWIG_fail;
32593 }
32594 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_NEW | 0 );
32595 return resultobj;
32596 fail:
32597 return NULL;
32598 }
32599
32600
32601 SWIGINTERN PyObject *_wrap_DataObjectComposite_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32602 PyObject *resultobj = 0;
32603 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
32604 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
32605 bool arg3 = (bool) false ;
32606 void *argp1 = 0 ;
32607 int res1 = 0 ;
32608 int res2 = 0 ;
32609 bool val3 ;
32610 int ecode3 = 0 ;
32611 PyObject * obj0 = 0 ;
32612 PyObject * obj1 = 0 ;
32613 PyObject * obj2 = 0 ;
32614 char * kwnames[] = {
32615 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
32616 };
32617
32618 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32619 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
32620 if (!SWIG_IsOK(res1)) {
32621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_Add" "', expected argument " "1"" of type '" "wxDataObjectComposite *""'");
32622 }
32623 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
32624 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_DISOWN | 0 );
32625 if (!SWIG_IsOK(res2)) {
32626 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectComposite_Add" "', expected argument " "2"" of type '" "wxDataObjectSimple *""'");
32627 }
32628 if (obj2) {
32629 ecode3 = SWIG_AsVal_bool(obj2, &val3);
32630 if (!SWIG_IsOK(ecode3)) {
32631 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObjectComposite_Add" "', expected argument " "3"" of type '" "bool""'");
32632 }
32633 arg3 = static_cast< bool >(val3);
32634 }
32635 {
32636 PyThreadState* __tstate = wxPyBeginAllowThreads();
32637 (arg1)->Add(arg2,arg3);
32638 wxPyEndAllowThreads(__tstate);
32639 if (PyErr_Occurred()) SWIG_fail;
32640 }
32641 resultobj = SWIG_Py_Void();
32642 return resultobj;
32643 fail:
32644 return NULL;
32645 }
32646
32647
32648 SWIGINTERN PyObject *_wrap_DataObjectComposite_GetReceivedFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32649 PyObject *resultobj = 0;
32650 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
32651 SwigValueWrapper<wxDataFormat > result;
32652 void *argp1 = 0 ;
32653 int res1 = 0 ;
32654 PyObject *swig_obj[1] ;
32655
32656 if (!args) SWIG_fail;
32657 swig_obj[0] = args;
32658 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
32659 if (!SWIG_IsOK(res1)) {
32660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_GetReceivedFormat" "', expected argument " "1"" of type '" "wxDataObjectComposite const *""'");
32661 }
32662 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
32663 {
32664 PyThreadState* __tstate = wxPyBeginAllowThreads();
32665 result = ((wxDataObjectComposite const *)arg1)->GetReceivedFormat();
32666 wxPyEndAllowThreads(__tstate);
32667 if (PyErr_Occurred()) SWIG_fail;
32668 }
32669 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
32670 return resultobj;
32671 fail:
32672 return NULL;
32673 }
32674
32675
32676 SWIGINTERN PyObject *DataObjectComposite_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32677 PyObject *obj;
32678 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32679 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectComposite, SWIG_NewClientData(obj));
32680 return SWIG_Py_Void();
32681 }
32682
32683 SWIGINTERN PyObject *DataObjectComposite_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32684 return SWIG_Python_InitShadowInstance(args);
32685 }
32686
32687 SWIGINTERN PyObject *_wrap_new_TextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32688 PyObject *resultobj = 0;
32689 wxString const &arg1_defvalue = wxPyEmptyString ;
32690 wxString *arg1 = (wxString *) &arg1_defvalue ;
32691 wxTextDataObject *result = 0 ;
32692 bool temp1 = false ;
32693 PyObject * obj0 = 0 ;
32694 char * kwnames[] = {
32695 (char *) "text", NULL
32696 };
32697
32698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) SWIG_fail;
32699 if (obj0) {
32700 {
32701 arg1 = wxString_in_helper(obj0);
32702 if (arg1 == NULL) SWIG_fail;
32703 temp1 = true;
32704 }
32705 }
32706 {
32707 PyThreadState* __tstate = wxPyBeginAllowThreads();
32708 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
32709 wxPyEndAllowThreads(__tstate);
32710 if (PyErr_Occurred()) SWIG_fail;
32711 }
32712 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_NEW | 0 );
32713 {
32714 if (temp1)
32715 delete arg1;
32716 }
32717 return resultobj;
32718 fail:
32719 {
32720 if (temp1)
32721 delete arg1;
32722 }
32723 return NULL;
32724 }
32725
32726
32727 SWIGINTERN PyObject *_wrap_TextDataObject_GetTextLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32728 PyObject *resultobj = 0;
32729 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32730 size_t result;
32731 void *argp1 = 0 ;
32732 int res1 = 0 ;
32733 PyObject *swig_obj[1] ;
32734
32735 if (!args) SWIG_fail;
32736 swig_obj[0] = args;
32737 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32738 if (!SWIG_IsOK(res1)) {
32739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetTextLength" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32740 }
32741 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32742 {
32743 PyThreadState* __tstate = wxPyBeginAllowThreads();
32744 result = (size_t)(arg1)->GetTextLength();
32745 wxPyEndAllowThreads(__tstate);
32746 if (PyErr_Occurred()) SWIG_fail;
32747 }
32748 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32749 return resultobj;
32750 fail:
32751 return NULL;
32752 }
32753
32754
32755 SWIGINTERN PyObject *_wrap_TextDataObject_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32756 PyObject *resultobj = 0;
32757 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32758 wxString result;
32759 void *argp1 = 0 ;
32760 int res1 = 0 ;
32761 PyObject *swig_obj[1] ;
32762
32763 if (!args) SWIG_fail;
32764 swig_obj[0] = args;
32765 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32766 if (!SWIG_IsOK(res1)) {
32767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32768 }
32769 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32770 {
32771 PyThreadState* __tstate = wxPyBeginAllowThreads();
32772 result = (arg1)->GetText();
32773 wxPyEndAllowThreads(__tstate);
32774 if (PyErr_Occurred()) SWIG_fail;
32775 }
32776 {
32777 #if wxUSE_UNICODE
32778 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32779 #else
32780 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32781 #endif
32782 }
32783 return resultobj;
32784 fail:
32785 return NULL;
32786 }
32787
32788
32789 SWIGINTERN PyObject *_wrap_TextDataObject_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32790 PyObject *resultobj = 0;
32791 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32792 wxString *arg2 = 0 ;
32793 void *argp1 = 0 ;
32794 int res1 = 0 ;
32795 bool temp2 = false ;
32796 PyObject * obj0 = 0 ;
32797 PyObject * obj1 = 0 ;
32798 char * kwnames[] = {
32799 (char *) "self",(char *) "text", NULL
32800 };
32801
32802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
32803 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32804 if (!SWIG_IsOK(res1)) {
32805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_SetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32806 }
32807 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32808 {
32809 arg2 = wxString_in_helper(obj1);
32810 if (arg2 == NULL) SWIG_fail;
32811 temp2 = true;
32812 }
32813 {
32814 PyThreadState* __tstate = wxPyBeginAllowThreads();
32815 (arg1)->SetText((wxString const &)*arg2);
32816 wxPyEndAllowThreads(__tstate);
32817 if (PyErr_Occurred()) SWIG_fail;
32818 }
32819 resultobj = SWIG_Py_Void();
32820 {
32821 if (temp2)
32822 delete arg2;
32823 }
32824 return resultobj;
32825 fail:
32826 {
32827 if (temp2)
32828 delete arg2;
32829 }
32830 return NULL;
32831 }
32832
32833
32834 SWIGINTERN PyObject *TextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32835 PyObject *obj;
32836 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32837 SWIG_TypeNewClientData(SWIGTYPE_p_wxTextDataObject, SWIG_NewClientData(obj));
32838 return SWIG_Py_Void();
32839 }
32840
32841 SWIGINTERN PyObject *TextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32842 return SWIG_Python_InitShadowInstance(args);
32843 }
32844
32845 SWIGINTERN PyObject *_wrap_new_PyTextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32846 PyObject *resultobj = 0;
32847 wxString const &arg1_defvalue = wxPyEmptyString ;
32848 wxString *arg1 = (wxString *) &arg1_defvalue ;
32849 wxPyTextDataObject *result = 0 ;
32850 bool temp1 = false ;
32851 PyObject * obj0 = 0 ;
32852 char * kwnames[] = {
32853 (char *) "text", NULL
32854 };
32855
32856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) SWIG_fail;
32857 if (obj0) {
32858 {
32859 arg1 = wxString_in_helper(obj0);
32860 if (arg1 == NULL) SWIG_fail;
32861 temp1 = true;
32862 }
32863 }
32864 {
32865 PyThreadState* __tstate = wxPyBeginAllowThreads();
32866 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
32867 wxPyEndAllowThreads(__tstate);
32868 if (PyErr_Occurred()) SWIG_fail;
32869 }
32870 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_NEW | 0 );
32871 {
32872 if (temp1)
32873 delete arg1;
32874 }
32875 return resultobj;
32876 fail:
32877 {
32878 if (temp1)
32879 delete arg1;
32880 }
32881 return NULL;
32882 }
32883
32884
32885 SWIGINTERN PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32886 PyObject *resultobj = 0;
32887 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
32888 PyObject *arg2 = (PyObject *) 0 ;
32889 PyObject *arg3 = (PyObject *) 0 ;
32890 void *argp1 = 0 ;
32891 int res1 = 0 ;
32892 PyObject * obj0 = 0 ;
32893 PyObject * obj1 = 0 ;
32894 PyObject * obj2 = 0 ;
32895 char * kwnames[] = {
32896 (char *) "self",(char *) "self",(char *) "_class", NULL
32897 };
32898
32899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDataObject, 0 | 0 );
32901 if (!SWIG_IsOK(res1)) {
32902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTextDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDataObject *""'");
32903 }
32904 arg1 = reinterpret_cast< wxPyTextDataObject * >(argp1);
32905 arg2 = obj1;
32906 arg3 = obj2;
32907 {
32908 PyThreadState* __tstate = wxPyBeginAllowThreads();
32909 (arg1)->_setCallbackInfo(arg2,arg3);
32910 wxPyEndAllowThreads(__tstate);
32911 if (PyErr_Occurred()) SWIG_fail;
32912 }
32913 resultobj = SWIG_Py_Void();
32914 return resultobj;
32915 fail:
32916 return NULL;
32917 }
32918
32919
32920 SWIGINTERN PyObject *PyTextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32921 PyObject *obj;
32922 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32923 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDataObject, SWIG_NewClientData(obj));
32924 return SWIG_Py_Void();
32925 }
32926
32927 SWIGINTERN PyObject *PyTextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32928 return SWIG_Python_InitShadowInstance(args);
32929 }
32930
32931 SWIGINTERN PyObject *_wrap_new_BitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32932 PyObject *resultobj = 0;
32933 wxBitmap const &arg1_defvalue = wxNullBitmap ;
32934 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
32935 wxBitmapDataObject *result = 0 ;
32936 void *argp1 = 0 ;
32937 int res1 = 0 ;
32938 PyObject * obj0 = 0 ;
32939 char * kwnames[] = {
32940 (char *) "bitmap", NULL
32941 };
32942
32943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) SWIG_fail;
32944 if (obj0) {
32945 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
32946 if (!SWIG_IsOK(res1)) {
32947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
32948 }
32949 if (!argp1) {
32950 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
32951 }
32952 arg1 = reinterpret_cast< wxBitmap * >(argp1);
32953 }
32954 {
32955 PyThreadState* __tstate = wxPyBeginAllowThreads();
32956 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
32957 wxPyEndAllowThreads(__tstate);
32958 if (PyErr_Occurred()) SWIG_fail;
32959 }
32960 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_NEW | 0 );
32961 return resultobj;
32962 fail:
32963 return NULL;
32964 }
32965
32966
32967 SWIGINTERN PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32968 PyObject *resultobj = 0;
32969 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
32970 wxBitmap result;
32971 void *argp1 = 0 ;
32972 int res1 = 0 ;
32973 PyObject *swig_obj[1] ;
32974
32975 if (!args) SWIG_fail;
32976 swig_obj[0] = args;
32977 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
32978 if (!SWIG_IsOK(res1)) {
32979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_GetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject const *""'");
32980 }
32981 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
32982 {
32983 PyThreadState* __tstate = wxPyBeginAllowThreads();
32984 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
32985 wxPyEndAllowThreads(__tstate);
32986 if (PyErr_Occurred()) SWIG_fail;
32987 }
32988 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
32989 return resultobj;
32990 fail:
32991 return NULL;
32992 }
32993
32994
32995 SWIGINTERN PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32996 PyObject *resultobj = 0;
32997 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
32998 wxBitmap *arg2 = 0 ;
32999 void *argp1 = 0 ;
33000 int res1 = 0 ;
33001 void *argp2 = 0 ;
33002 int res2 = 0 ;
33003 PyObject * obj0 = 0 ;
33004 PyObject * obj1 = 0 ;
33005 char * kwnames[] = {
33006 (char *) "self",(char *) "bitmap", NULL
33007 };
33008
33009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
33010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
33011 if (!SWIG_IsOK(res1)) {
33012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject *""'");
33013 }
33014 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
33015 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
33016 if (!SWIG_IsOK(res2)) {
33017 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
33018 }
33019 if (!argp2) {
33020 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
33021 }
33022 arg2 = reinterpret_cast< wxBitmap * >(argp2);
33023 {
33024 PyThreadState* __tstate = wxPyBeginAllowThreads();
33025 (arg1)->SetBitmap((wxBitmap const &)*arg2);
33026 wxPyEndAllowThreads(__tstate);
33027 if (PyErr_Occurred()) SWIG_fail;
33028 }
33029 resultobj = SWIG_Py_Void();
33030 return resultobj;
33031 fail:
33032 return NULL;
33033 }
33034
33035
33036 SWIGINTERN PyObject *BitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33037 PyObject *obj;
33038 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33039 SWIG_TypeNewClientData(SWIGTYPE_p_wxBitmapDataObject, SWIG_NewClientData(obj));
33040 return SWIG_Py_Void();
33041 }
33042
33043 SWIGINTERN PyObject *BitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33044 return SWIG_Python_InitShadowInstance(args);
33045 }
33046
33047 SWIGINTERN PyObject *_wrap_new_PyBitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33048 PyObject *resultobj = 0;
33049 wxBitmap const &arg1_defvalue = wxNullBitmap ;
33050 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
33051 wxPyBitmapDataObject *result = 0 ;
33052 void *argp1 = 0 ;
33053 int res1 = 0 ;
33054 PyObject * obj0 = 0 ;
33055 char * kwnames[] = {
33056 (char *) "bitmap", NULL
33057 };
33058
33059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) SWIG_fail;
33060 if (obj0) {
33061 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
33062 if (!SWIG_IsOK(res1)) {
33063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
33064 }
33065 if (!argp1) {
33066 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
33067 }
33068 arg1 = reinterpret_cast< wxBitmap * >(argp1);
33069 }
33070 {
33071 PyThreadState* __tstate = wxPyBeginAllowThreads();
33072 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
33073 wxPyEndAllowThreads(__tstate);
33074 if (PyErr_Occurred()) SWIG_fail;
33075 }
33076 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_NEW | 0 );
33077 return resultobj;
33078 fail:
33079 return NULL;
33080 }
33081
33082
33083 SWIGINTERN PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33084 PyObject *resultobj = 0;
33085 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
33086 PyObject *arg2 = (PyObject *) 0 ;
33087 PyObject *arg3 = (PyObject *) 0 ;
33088 void *argp1 = 0 ;
33089 int res1 = 0 ;
33090 PyObject * obj0 = 0 ;
33091 PyObject * obj1 = 0 ;
33092 PyObject * obj2 = 0 ;
33093 char * kwnames[] = {
33094 (char *) "self",(char *) "self",(char *) "_class", NULL
33095 };
33096
33097 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33098 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyBitmapDataObject, 0 | 0 );
33099 if (!SWIG_IsOK(res1)) {
33100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyBitmapDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyBitmapDataObject *""'");
33101 }
33102 arg1 = reinterpret_cast< wxPyBitmapDataObject * >(argp1);
33103 arg2 = obj1;
33104 arg3 = obj2;
33105 {
33106 PyThreadState* __tstate = wxPyBeginAllowThreads();
33107 (arg1)->_setCallbackInfo(arg2,arg3);
33108 wxPyEndAllowThreads(__tstate);
33109 if (PyErr_Occurred()) SWIG_fail;
33110 }
33111 resultobj = SWIG_Py_Void();
33112 return resultobj;
33113 fail:
33114 return NULL;
33115 }
33116
33117
33118 SWIGINTERN PyObject *PyBitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33119 PyObject *obj;
33120 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33121 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyBitmapDataObject, SWIG_NewClientData(obj));
33122 return SWIG_Py_Void();
33123 }
33124
33125 SWIGINTERN PyObject *PyBitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33126 return SWIG_Python_InitShadowInstance(args);
33127 }
33128
33129 SWIGINTERN PyObject *_wrap_new_FileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33130 PyObject *resultobj = 0;
33131 wxFileDataObject *result = 0 ;
33132
33133 if (!SWIG_Python_UnpackTuple(args,"new_FileDataObject",0,0,0)) SWIG_fail;
33134 {
33135 PyThreadState* __tstate = wxPyBeginAllowThreads();
33136 result = (wxFileDataObject *)new wxFileDataObject();
33137 wxPyEndAllowThreads(__tstate);
33138 if (PyErr_Occurred()) SWIG_fail;
33139 }
33140 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_NEW | 0 );
33141 return resultobj;
33142 fail:
33143 return NULL;
33144 }
33145
33146
33147 SWIGINTERN PyObject *_wrap_FileDataObject_GetFilenames(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33148 PyObject *resultobj = 0;
33149 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
33150 wxArrayString *result = 0 ;
33151 void *argp1 = 0 ;
33152 int res1 = 0 ;
33153 PyObject *swig_obj[1] ;
33154
33155 if (!args) SWIG_fail;
33156 swig_obj[0] = args;
33157 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
33158 if (!SWIG_IsOK(res1)) {
33159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_GetFilenames" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
33160 }
33161 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
33162 {
33163 PyThreadState* __tstate = wxPyBeginAllowThreads();
33164 {
33165 wxArrayString const &_result_ref = (arg1)->GetFilenames();
33166 result = (wxArrayString *) &_result_ref;
33167 }
33168 wxPyEndAllowThreads(__tstate);
33169 if (PyErr_Occurred()) SWIG_fail;
33170 }
33171 {
33172 resultobj = wxArrayString2PyList_helper(*result);
33173 }
33174 return resultobj;
33175 fail:
33176 return NULL;
33177 }
33178
33179
33180 SWIGINTERN PyObject *_wrap_FileDataObject_AddFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33181 PyObject *resultobj = 0;
33182 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
33183 wxString *arg2 = 0 ;
33184 void *argp1 = 0 ;
33185 int res1 = 0 ;
33186 bool temp2 = false ;
33187 PyObject * obj0 = 0 ;
33188 PyObject * obj1 = 0 ;
33189 char * kwnames[] = {
33190 (char *) "self",(char *) "filename", NULL
33191 };
33192
33193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) SWIG_fail;
33194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
33195 if (!SWIG_IsOK(res1)) {
33196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_AddFile" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
33197 }
33198 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
33199 {
33200 arg2 = wxString_in_helper(obj1);
33201 if (arg2 == NULL) SWIG_fail;
33202 temp2 = true;
33203 }
33204 {
33205 PyThreadState* __tstate = wxPyBeginAllowThreads();
33206 (arg1)->AddFile((wxString const &)*arg2);
33207 wxPyEndAllowThreads(__tstate);
33208 if (PyErr_Occurred()) SWIG_fail;
33209 }
33210 resultobj = SWIG_Py_Void();
33211 {
33212 if (temp2)
33213 delete arg2;
33214 }
33215 return resultobj;
33216 fail:
33217 {
33218 if (temp2)
33219 delete arg2;
33220 }
33221 return NULL;
33222 }
33223
33224
33225 SWIGINTERN PyObject *FileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33226 PyObject *obj;
33227 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33228 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileDataObject, SWIG_NewClientData(obj));
33229 return SWIG_Py_Void();
33230 }
33231
33232 SWIGINTERN PyObject *FileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33233 return SWIG_Python_InitShadowInstance(args);
33234 }
33235
33236 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
33237 PyObject *resultobj = 0;
33238 wxDataFormat *arg1 = 0 ;
33239 wxCustomDataObject *result = 0 ;
33240 void *argp1 = 0 ;
33241 int res1 = 0 ;
33242
33243 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
33244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
33245 if (!SWIG_IsOK(res1)) {
33246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
33247 }
33248 if (!argp1) {
33249 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
33250 }
33251 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
33252 {
33253 PyThreadState* __tstate = wxPyBeginAllowThreads();
33254 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
33255 wxPyEndAllowThreads(__tstate);
33256 if (PyErr_Occurred()) SWIG_fail;
33257 }
33258 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33259 return resultobj;
33260 fail:
33261 return NULL;
33262 }
33263
33264
33265 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
33266 PyObject *resultobj = 0;
33267 wxString *arg1 = 0 ;
33268 wxCustomDataObject *result = 0 ;
33269 bool temp1 = false ;
33270
33271 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
33272 {
33273 arg1 = wxString_in_helper(swig_obj[0]);
33274 if (arg1 == NULL) SWIG_fail;
33275 temp1 = true;
33276 }
33277 {
33278 PyThreadState* __tstate = wxPyBeginAllowThreads();
33279 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
33280 wxPyEndAllowThreads(__tstate);
33281 if (PyErr_Occurred()) SWIG_fail;
33282 }
33283 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33284 {
33285 if (temp1)
33286 delete arg1;
33287 }
33288 return resultobj;
33289 fail:
33290 {
33291 if (temp1)
33292 delete arg1;
33293 }
33294 return NULL;
33295 }
33296
33297
33298 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
33299 PyObject *resultobj = 0;
33300 wxCustomDataObject *result = 0 ;
33301
33302 if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
33303 {
33304 PyThreadState* __tstate = wxPyBeginAllowThreads();
33305 result = (wxCustomDataObject *)new wxCustomDataObject();
33306 wxPyEndAllowThreads(__tstate);
33307 if (PyErr_Occurred()) SWIG_fail;
33308 }
33309 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33310 return resultobj;
33311 fail:
33312 return NULL;
33313 }
33314
33315
33316 SWIGINTERN PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
33317 int argc;
33318 PyObject *argv[2];
33319
33320 if (!(argc = SWIG_Python_UnpackTuple(args,"new_CustomDataObject",0,1,argv))) SWIG_fail;
33321 --argc;
33322 if (argc == 0) {
33323 return _wrap_new_CustomDataObject__SWIG_2(self, argc, argv);
33324 }
33325 if (argc == 1) {
33326 int _v = 0;
33327 {
33328 {
33329 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
33330 }
33331 }
33332 if (!_v) goto check_2;
33333 return _wrap_new_CustomDataObject__SWIG_1(self, argc, argv);
33334 }
33335 check_2:
33336
33337 if (argc == 1) {
33338 return _wrap_new_CustomDataObject__SWIG_0(self, argc, argv);
33339 }
33340
33341 fail:
33342 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
33343 return NULL;
33344 }
33345
33346
33347 SWIGINTERN PyObject *_wrap_CustomDataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33348 PyObject *resultobj = 0;
33349 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33350 PyObject *arg2 = (PyObject *) 0 ;
33351 bool result;
33352 void *argp1 = 0 ;
33353 int res1 = 0 ;
33354 PyObject * obj0 = 0 ;
33355 PyObject * obj1 = 0 ;
33356 char * kwnames[] = {
33357 (char *) "self",(char *) "data", NULL
33358 };
33359
33360 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
33361 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33362 if (!SWIG_IsOK(res1)) {
33363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_SetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33364 }
33365 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33366 arg2 = obj1;
33367 {
33368 PyThreadState* __tstate = wxPyBeginAllowThreads();
33369 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
33370 wxPyEndAllowThreads(__tstate);
33371 if (PyErr_Occurred()) SWIG_fail;
33372 }
33373 {
33374 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33375 }
33376 return resultobj;
33377 fail:
33378 return NULL;
33379 }
33380
33381
33382 SWIGINTERN PyObject *_wrap_CustomDataObject_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33383 PyObject *resultobj = 0;
33384 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33385 size_t result;
33386 void *argp1 = 0 ;
33387 int res1 = 0 ;
33388 PyObject *swig_obj[1] ;
33389
33390 if (!args) SWIG_fail;
33391 swig_obj[0] = args;
33392 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33393 if (!SWIG_IsOK(res1)) {
33394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetSize" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33395 }
33396 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33397 {
33398 PyThreadState* __tstate = wxPyBeginAllowThreads();
33399 result = (size_t)(arg1)->GetSize();
33400 wxPyEndAllowThreads(__tstate);
33401 if (PyErr_Occurred()) SWIG_fail;
33402 }
33403 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
33404 return resultobj;
33405 fail:
33406 return NULL;
33407 }
33408
33409
33410 SWIGINTERN PyObject *_wrap_CustomDataObject_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33411 PyObject *resultobj = 0;
33412 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33413 PyObject *result = 0 ;
33414 void *argp1 = 0 ;
33415 int res1 = 0 ;
33416 PyObject *swig_obj[1] ;
33417
33418 if (!args) SWIG_fail;
33419 swig_obj[0] = args;
33420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33421 if (!SWIG_IsOK(res1)) {
33422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33423 }
33424 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33425 {
33426 PyThreadState* __tstate = wxPyBeginAllowThreads();
33427 result = (PyObject *)wxCustomDataObject_GetData(arg1);
33428 wxPyEndAllowThreads(__tstate);
33429 if (PyErr_Occurred()) SWIG_fail;
33430 }
33431 resultobj = result;
33432 return resultobj;
33433 fail:
33434 return NULL;
33435 }
33436
33437
33438 SWIGINTERN PyObject *CustomDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33439 PyObject *obj;
33440 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33441 SWIG_TypeNewClientData(SWIGTYPE_p_wxCustomDataObject, SWIG_NewClientData(obj));
33442 return SWIG_Py_Void();
33443 }
33444
33445 SWIGINTERN PyObject *CustomDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33446 return SWIG_Python_InitShadowInstance(args);
33447 }
33448
33449 SWIGINTERN PyObject *_wrap_new_URLDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33450 PyObject *resultobj = 0;
33451 wxString const &arg1_defvalue = wxPyEmptyString ;
33452 wxString *arg1 = (wxString *) &arg1_defvalue ;
33453 wxURLDataObject *result = 0 ;
33454 bool temp1 = false ;
33455 PyObject * obj0 = 0 ;
33456 char * kwnames[] = {
33457 (char *) "url", NULL
33458 };
33459
33460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_URLDataObject",kwnames,&obj0)) SWIG_fail;
33461 if (obj0) {
33462 {
33463 arg1 = wxString_in_helper(obj0);
33464 if (arg1 == NULL) SWIG_fail;
33465 temp1 = true;
33466 }
33467 }
33468 {
33469 PyThreadState* __tstate = wxPyBeginAllowThreads();
33470 result = (wxURLDataObject *)new wxURLDataObject((wxString const &)*arg1);
33471 wxPyEndAllowThreads(__tstate);
33472 if (PyErr_Occurred()) SWIG_fail;
33473 }
33474 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_NEW | 0 );
33475 {
33476 if (temp1)
33477 delete arg1;
33478 }
33479 return resultobj;
33480 fail:
33481 {
33482 if (temp1)
33483 delete arg1;
33484 }
33485 return NULL;
33486 }
33487
33488
33489 SWIGINTERN PyObject *_wrap_URLDataObject_GetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33490 PyObject *resultobj = 0;
33491 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
33492 wxString result;
33493 void *argp1 = 0 ;
33494 int res1 = 0 ;
33495 PyObject *swig_obj[1] ;
33496
33497 if (!args) SWIG_fail;
33498 swig_obj[0] = args;
33499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
33500 if (!SWIG_IsOK(res1)) {
33501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_GetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
33502 }
33503 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
33504 {
33505 PyThreadState* __tstate = wxPyBeginAllowThreads();
33506 result = (arg1)->GetURL();
33507 wxPyEndAllowThreads(__tstate);
33508 if (PyErr_Occurred()) SWIG_fail;
33509 }
33510 {
33511 #if wxUSE_UNICODE
33512 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33513 #else
33514 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33515 #endif
33516 }
33517 return resultobj;
33518 fail:
33519 return NULL;
33520 }
33521
33522
33523 SWIGINTERN PyObject *_wrap_URLDataObject_SetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33524 PyObject *resultobj = 0;
33525 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
33526 wxString *arg2 = 0 ;
33527 void *argp1 = 0 ;
33528 int res1 = 0 ;
33529 bool temp2 = false ;
33530 PyObject * obj0 = 0 ;
33531 PyObject * obj1 = 0 ;
33532 char * kwnames[] = {
33533 (char *) "self",(char *) "url", NULL
33534 };
33535
33536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) SWIG_fail;
33537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
33538 if (!SWIG_IsOK(res1)) {
33539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_SetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
33540 }
33541 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
33542 {
33543 arg2 = wxString_in_helper(obj1);
33544 if (arg2 == NULL) SWIG_fail;
33545 temp2 = true;
33546 }
33547 {
33548 PyThreadState* __tstate = wxPyBeginAllowThreads();
33549 (arg1)->SetURL((wxString const &)*arg2);
33550 wxPyEndAllowThreads(__tstate);
33551 if (PyErr_Occurred()) SWIG_fail;
33552 }
33553 resultobj = SWIG_Py_Void();
33554 {
33555 if (temp2)
33556 delete arg2;
33557 }
33558 return resultobj;
33559 fail:
33560 {
33561 if (temp2)
33562 delete arg2;
33563 }
33564 return NULL;
33565 }
33566
33567
33568 SWIGINTERN PyObject *URLDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33569 PyObject *obj;
33570 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33571 SWIG_TypeNewClientData(SWIGTYPE_p_wxURLDataObject, SWIG_NewClientData(obj));
33572 return SWIG_Py_Void();
33573 }
33574
33575 SWIGINTERN PyObject *URLDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33576 return SWIG_Python_InitShadowInstance(args);
33577 }
33578
33579 SWIGINTERN PyObject *_wrap_new_MetafileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33580 PyObject *resultobj = 0;
33581 wxMetafileDataObject *result = 0 ;
33582
33583 if (!SWIG_Python_UnpackTuple(args,"new_MetafileDataObject",0,0,0)) SWIG_fail;
33584 {
33585 PyThreadState* __tstate = wxPyBeginAllowThreads();
33586 result = (wxMetafileDataObject *)new wxMetafileDataObject();
33587 wxPyEndAllowThreads(__tstate);
33588 if (PyErr_Occurred()) SWIG_fail;
33589 }
33590 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_NEW | 0 );
33591 return resultobj;
33592 fail:
33593 return NULL;
33594 }
33595
33596
33597 SWIGINTERN PyObject *_wrap_MetafileDataObject_SetMetafile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33598 PyObject *resultobj = 0;
33599 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
33600 wxMetafile *arg2 = 0 ;
33601 void *argp1 = 0 ;
33602 int res1 = 0 ;
33603 void *argp2 = 0 ;
33604 int res2 = 0 ;
33605 PyObject * obj0 = 0 ;
33606 PyObject * obj1 = 0 ;
33607 char * kwnames[] = {
33608 (char *) "self",(char *) "metafile", NULL
33609 };
33610
33611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MetafileDataObject_SetMetafile",kwnames,&obj0,&obj1)) SWIG_fail;
33612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMetafileDataObject, 0 | 0 );
33613 if (!SWIG_IsOK(res1)) {
33614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetafileDataObject_SetMetafile" "', expected argument " "1"" of type '" "wxMetafileDataObject *""'");
33615 }
33616 arg1 = reinterpret_cast< wxMetafileDataObject * >(argp1);
33617 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxMetafile, 0 | 0);
33618 if (!SWIG_IsOK(res2)) {
33619 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MetafileDataObject_SetMetafile" "', expected argument " "2"" of type '" "wxMetafile const &""'");
33620 }
33621 if (!argp2) {
33622 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MetafileDataObject_SetMetafile" "', expected argument " "2"" of type '" "wxMetafile const &""'");
33623 }
33624 arg2 = reinterpret_cast< wxMetafile * >(argp2);
33625 {
33626 PyThreadState* __tstate = wxPyBeginAllowThreads();
33627 (arg1)->SetMetafile((wxMetafile const &)*arg2);
33628 wxPyEndAllowThreads(__tstate);
33629 if (PyErr_Occurred()) SWIG_fail;
33630 }
33631 resultobj = SWIG_Py_Void();
33632 return resultobj;
33633 fail:
33634 return NULL;
33635 }
33636
33637
33638 SWIGINTERN PyObject *_wrap_MetafileDataObject_GetMetafile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33639 PyObject *resultobj = 0;
33640 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
33641 wxMetafile result;
33642 void *argp1 = 0 ;
33643 int res1 = 0 ;
33644 PyObject *swig_obj[1] ;
33645
33646 if (!args) SWIG_fail;
33647 swig_obj[0] = args;
33648 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMetafileDataObject, 0 | 0 );
33649 if (!SWIG_IsOK(res1)) {
33650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetafileDataObject_GetMetafile" "', expected argument " "1"" of type '" "wxMetafileDataObject const *""'");
33651 }
33652 arg1 = reinterpret_cast< wxMetafileDataObject * >(argp1);
33653 {
33654 PyThreadState* __tstate = wxPyBeginAllowThreads();
33655 result = ((wxMetafileDataObject const *)arg1)->GetMetafile();
33656 wxPyEndAllowThreads(__tstate);
33657 if (PyErr_Occurred()) SWIG_fail;
33658 }
33659 resultobj = SWIG_NewPointerObj((new wxMetafile(static_cast< const wxMetafile& >(result))), SWIGTYPE_p_wxMetafile, SWIG_POINTER_OWN | 0 );
33660 return resultobj;
33661 fail:
33662 return NULL;
33663 }
33664
33665
33666 SWIGINTERN PyObject *MetafileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33667 PyObject *obj;
33668 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33669 SWIG_TypeNewClientData(SWIGTYPE_p_wxMetafileDataObject, SWIG_NewClientData(obj));
33670 return SWIG_Py_Void();
33671 }
33672
33673 SWIGINTERN PyObject *MetafileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33674 return SWIG_Python_InitShadowInstance(args);
33675 }
33676
33677 SWIGINTERN PyObject *_wrap_IsDragResultOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33678 PyObject *resultobj = 0;
33679 wxDragResult arg1 ;
33680 bool result;
33681 int val1 ;
33682 int ecode1 = 0 ;
33683 PyObject * obj0 = 0 ;
33684 char * kwnames[] = {
33685 (char *) "res", NULL
33686 };
33687
33688 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) SWIG_fail;
33689 ecode1 = SWIG_AsVal_int(obj0, &val1);
33690 if (!SWIG_IsOK(ecode1)) {
33691 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsDragResultOk" "', expected argument " "1"" of type '" "wxDragResult""'");
33692 }
33693 arg1 = static_cast< wxDragResult >(val1);
33694 {
33695 PyThreadState* __tstate = wxPyBeginAllowThreads();
33696 result = (bool)wxIsDragResultOk(arg1);
33697 wxPyEndAllowThreads(__tstate);
33698 if (PyErr_Occurred()) SWIG_fail;
33699 }
33700 {
33701 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33702 }
33703 return resultobj;
33704 fail:
33705 return NULL;
33706 }
33707
33708
33709 SWIGINTERN PyObject *_wrap_new_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33710 PyObject *resultobj = 0;
33711 wxWindow *arg1 = (wxWindow *) 0 ;
33712 wxCursor const &arg2_defvalue = wxNullCursor ;
33713 wxCursor *arg2 = (wxCursor *) &arg2_defvalue ;
33714 wxCursor const &arg3_defvalue = wxNullCursor ;
33715 wxCursor *arg3 = (wxCursor *) &arg3_defvalue ;
33716 wxCursor const &arg4_defvalue = wxNullCursor ;
33717 wxCursor *arg4 = (wxCursor *) &arg4_defvalue ;
33718 wxPyDropSource *result = 0 ;
33719 void *argp1 = 0 ;
33720 int res1 = 0 ;
33721 void *argp2 = 0 ;
33722 int res2 = 0 ;
33723 void *argp3 = 0 ;
33724 int res3 = 0 ;
33725 void *argp4 = 0 ;
33726 int res4 = 0 ;
33727 PyObject * obj0 = 0 ;
33728 PyObject * obj1 = 0 ;
33729 PyObject * obj2 = 0 ;
33730 PyObject * obj3 = 0 ;
33731 char * kwnames[] = {
33732 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
33733 };
33734
33735 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33736 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33737 if (!SWIG_IsOK(res1)) {
33738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropSource" "', expected argument " "1"" of type '" "wxWindow *""'");
33739 }
33740 arg1 = reinterpret_cast< wxWindow * >(argp1);
33741 if (obj1) {
33742 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
33743 if (!SWIG_IsOK(res2)) {
33744 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxCursor const &""'");
33745 }
33746 if (!argp2) {
33747 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxCursor const &""'");
33748 }
33749 arg2 = reinterpret_cast< wxCursor * >(argp2);
33750 }
33751 if (obj2) {
33752 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxCursor, 0 | 0);
33753 if (!SWIG_IsOK(res3)) {
33754 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxCursor const &""'");
33755 }
33756 if (!argp3) {
33757 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxCursor const &""'");
33758 }
33759 arg3 = reinterpret_cast< wxCursor * >(argp3);
33760 }
33761 if (obj3) {
33762 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxCursor, 0 | 0);
33763 if (!SWIG_IsOK(res4)) {
33764 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxCursor const &""'");
33765 }
33766 if (!argp4) {
33767 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxCursor const &""'");
33768 }
33769 arg4 = reinterpret_cast< wxCursor * >(argp4);
33770 }
33771 {
33772 PyThreadState* __tstate = wxPyBeginAllowThreads();
33773 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxCursor const &)*arg2,(wxCursor const &)*arg3,(wxCursor const &)*arg4);
33774 wxPyEndAllowThreads(__tstate);
33775 if (PyErr_Occurred()) SWIG_fail;
33776 }
33777 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_NEW | 0 );
33778 return resultobj;
33779 fail:
33780 return NULL;
33781 }
33782
33783
33784 SWIGINTERN PyObject *_wrap_DropSource__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33785 PyObject *resultobj = 0;
33786 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33787 PyObject *arg2 = (PyObject *) 0 ;
33788 PyObject *arg3 = (PyObject *) 0 ;
33789 int arg4 ;
33790 void *argp1 = 0 ;
33791 int res1 = 0 ;
33792 int val4 ;
33793 int ecode4 = 0 ;
33794 PyObject * obj0 = 0 ;
33795 PyObject * obj1 = 0 ;
33796 PyObject * obj2 = 0 ;
33797 PyObject * obj3 = 0 ;
33798 char * kwnames[] = {
33799 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
33800 };
33801
33802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33803 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33804 if (!SWIG_IsOK(res1)) {
33805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33806 }
33807 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33808 arg2 = obj1;
33809 arg3 = obj2;
33810 ecode4 = SWIG_AsVal_int(obj3, &val4);
33811 if (!SWIG_IsOK(ecode4)) {
33812 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropSource__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
33813 }
33814 arg4 = static_cast< int >(val4);
33815 {
33816 PyThreadState* __tstate = wxPyBeginAllowThreads();
33817 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
33818 wxPyEndAllowThreads(__tstate);
33819 if (PyErr_Occurred()) SWIG_fail;
33820 }
33821 resultobj = SWIG_Py_Void();
33822 return resultobj;
33823 fail:
33824 return NULL;
33825 }
33826
33827
33828 SWIGINTERN PyObject *_wrap_delete_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33829 PyObject *resultobj = 0;
33830 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33831 void *argp1 = 0 ;
33832 int res1 = 0 ;
33833 PyObject *swig_obj[1] ;
33834
33835 if (!args) SWIG_fail;
33836 swig_obj[0] = args;
33837 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_DISOWN | 0 );
33838 if (!SWIG_IsOK(res1)) {
33839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropSource" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33840 }
33841 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33842 {
33843 PyThreadState* __tstate = wxPyBeginAllowThreads();
33844 delete arg1;
33845
33846 wxPyEndAllowThreads(__tstate);
33847 if (PyErr_Occurred()) SWIG_fail;
33848 }
33849 resultobj = SWIG_Py_Void();
33850 return resultobj;
33851 fail:
33852 return NULL;
33853 }
33854
33855
33856 SWIGINTERN PyObject *_wrap_DropSource_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33857 PyObject *resultobj = 0;
33858 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33859 wxDataObject *arg2 = 0 ;
33860 void *argp1 = 0 ;
33861 int res1 = 0 ;
33862 void *argp2 = 0 ;
33863 int res2 = 0 ;
33864 PyObject * obj0 = 0 ;
33865 PyObject * obj1 = 0 ;
33866 char * kwnames[] = {
33867 (char *) "self",(char *) "data", NULL
33868 };
33869
33870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
33871 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33872 if (!SWIG_IsOK(res1)) {
33873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetData" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33874 }
33875 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33876 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
33877 if (!SWIG_IsOK(res2)) {
33878 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
33879 }
33880 if (!argp2) {
33881 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
33882 }
33883 arg2 = reinterpret_cast< wxDataObject * >(argp2);
33884 {
33885 PyThreadState* __tstate = wxPyBeginAllowThreads();
33886 (arg1)->SetData(*arg2);
33887 wxPyEndAllowThreads(__tstate);
33888 if (PyErr_Occurred()) SWIG_fail;
33889 }
33890 resultobj = SWIG_Py_Void();
33891 return resultobj;
33892 fail:
33893 return NULL;
33894 }
33895
33896
33897 SWIGINTERN PyObject *_wrap_DropSource_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33898 PyObject *resultobj = 0;
33899 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33900 wxDataObject *result = 0 ;
33901 void *argp1 = 0 ;
33902 int res1 = 0 ;
33903 PyObject *swig_obj[1] ;
33904
33905 if (!args) SWIG_fail;
33906 swig_obj[0] = args;
33907 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33908 if (!SWIG_IsOK(res1)) {
33909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33910 }
33911 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33912 {
33913 PyThreadState* __tstate = wxPyBeginAllowThreads();
33914 result = (wxDataObject *)(arg1)->GetDataObject();
33915 wxPyEndAllowThreads(__tstate);
33916 if (PyErr_Occurred()) SWIG_fail;
33917 }
33918 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
33919 return resultobj;
33920 fail:
33921 return NULL;
33922 }
33923
33924
33925 SWIGINTERN PyObject *_wrap_DropSource_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33926 PyObject *resultobj = 0;
33927 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33928 wxDragResult arg2 ;
33929 wxCursor *arg3 = 0 ;
33930 void *argp1 = 0 ;
33931 int res1 = 0 ;
33932 int val2 ;
33933 int ecode2 = 0 ;
33934 void *argp3 = 0 ;
33935 int res3 = 0 ;
33936 PyObject * obj0 = 0 ;
33937 PyObject * obj1 = 0 ;
33938 PyObject * obj2 = 0 ;
33939 char * kwnames[] = {
33940 (char *) "self",(char *) "res",(char *) "cursor", NULL
33941 };
33942
33943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33945 if (!SWIG_IsOK(res1)) {
33946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetCursor" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33947 }
33948 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33949 ecode2 = SWIG_AsVal_int(obj1, &val2);
33950 if (!SWIG_IsOK(ecode2)) {
33951 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_SetCursor" "', expected argument " "2"" of type '" "wxDragResult""'");
33952 }
33953 arg2 = static_cast< wxDragResult >(val2);
33954 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxCursor, 0 | 0);
33955 if (!SWIG_IsOK(res3)) {
33956 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
33957 }
33958 if (!argp3) {
33959 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
33960 }
33961 arg3 = reinterpret_cast< wxCursor * >(argp3);
33962 {
33963 PyThreadState* __tstate = wxPyBeginAllowThreads();
33964 (arg1)->SetCursor(arg2,(wxCursor const &)*arg3);
33965 wxPyEndAllowThreads(__tstate);
33966 if (PyErr_Occurred()) SWIG_fail;
33967 }
33968 resultobj = SWIG_Py_Void();
33969 return resultobj;
33970 fail:
33971 return NULL;
33972 }
33973
33974
33975 SWIGINTERN PyObject *_wrap_DropSource_DoDragDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33976 PyObject *resultobj = 0;
33977 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33978 int arg2 = (int) wxDrag_CopyOnly ;
33979 wxDragResult result;
33980 void *argp1 = 0 ;
33981 int res1 = 0 ;
33982 int val2 ;
33983 int ecode2 = 0 ;
33984 PyObject * obj0 = 0 ;
33985 PyObject * obj1 = 0 ;
33986 char * kwnames[] = {
33987 (char *) "self",(char *) "flags", NULL
33988 };
33989
33990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) SWIG_fail;
33991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33992 if (!SWIG_IsOK(res1)) {
33993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_DoDragDrop" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33994 }
33995 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33996 if (obj1) {
33997 ecode2 = SWIG_AsVal_int(obj1, &val2);
33998 if (!SWIG_IsOK(ecode2)) {
33999 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_DoDragDrop" "', expected argument " "2"" of type '" "int""'");
34000 }
34001 arg2 = static_cast< int >(val2);
34002 }
34003 {
34004 PyThreadState* __tstate = wxPyBeginAllowThreads();
34005 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
34006 wxPyEndAllowThreads(__tstate);
34007 if (PyErr_Occurred()) SWIG_fail;
34008 }
34009 resultobj = SWIG_From_int(static_cast< int >(result));
34010 return resultobj;
34011 fail:
34012 return NULL;
34013 }
34014
34015
34016 SWIGINTERN PyObject *_wrap_DropSource_GiveFeedback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34017 PyObject *resultobj = 0;
34018 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
34019 wxDragResult arg2 ;
34020 bool result;
34021 void *argp1 = 0 ;
34022 int res1 = 0 ;
34023 int val2 ;
34024 int ecode2 = 0 ;
34025 PyObject * obj0 = 0 ;
34026 PyObject * obj1 = 0 ;
34027 char * kwnames[] = {
34028 (char *) "self",(char *) "effect", NULL
34029 };
34030
34031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_GiveFeedback",kwnames,&obj0,&obj1)) SWIG_fail;
34032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
34033 if (!SWIG_IsOK(res1)) {
34034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GiveFeedback" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
34035 }
34036 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
34037 ecode2 = SWIG_AsVal_int(obj1, &val2);
34038 if (!SWIG_IsOK(ecode2)) {
34039 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_GiveFeedback" "', expected argument " "2"" of type '" "wxDragResult""'");
34040 }
34041 arg2 = static_cast< wxDragResult >(val2);
34042 {
34043 PyThreadState* __tstate = wxPyBeginAllowThreads();
34044 result = (bool)(arg1)->GiveFeedback(arg2);
34045 wxPyEndAllowThreads(__tstate);
34046 if (PyErr_Occurred()) SWIG_fail;
34047 }
34048 {
34049 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34050 }
34051 return resultobj;
34052 fail:
34053 return NULL;
34054 }
34055
34056
34057 SWIGINTERN PyObject *DropSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34058 PyObject *obj;
34059 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34060 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropSource, SWIG_NewClientData(obj));
34061 return SWIG_Py_Void();
34062 }
34063
34064 SWIGINTERN PyObject *DropSource_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34065 return SWIG_Python_InitShadowInstance(args);
34066 }
34067
34068 SWIGINTERN PyObject *_wrap_new_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34069 PyObject *resultobj = 0;
34070 wxDataObject *arg1 = (wxDataObject *) NULL ;
34071 wxPyDropTarget *result = 0 ;
34072 int res1 = 0 ;
34073 PyObject * obj0 = 0 ;
34074 char * kwnames[] = {
34075 (char *) "dataObject", NULL
34076 };
34077
34078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) SWIG_fail;
34079 if (obj0) {
34080 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34081 if (!SWIG_IsOK(res1)) {
34082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropTarget" "', expected argument " "1"" of type '" "wxDataObject *""'");
34083 }
34084 }
34085 {
34086 PyThreadState* __tstate = wxPyBeginAllowThreads();
34087 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
34088 wxPyEndAllowThreads(__tstate);
34089 if (PyErr_Occurred()) SWIG_fail;
34090 }
34091 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_NEW | 0 );
34092 return resultobj;
34093 fail:
34094 return NULL;
34095 }
34096
34097
34098 SWIGINTERN PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34099 PyObject *resultobj = 0;
34100 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34101 PyObject *arg2 = (PyObject *) 0 ;
34102 PyObject *arg3 = (PyObject *) 0 ;
34103 void *argp1 = 0 ;
34104 int res1 = 0 ;
34105 PyObject * obj0 = 0 ;
34106 PyObject * obj1 = 0 ;
34107 PyObject * obj2 = 0 ;
34108 char * kwnames[] = {
34109 (char *) "self",(char *) "self",(char *) "_class", NULL
34110 };
34111
34112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34114 if (!SWIG_IsOK(res1)) {
34115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34116 }
34117 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34118 arg2 = obj1;
34119 arg3 = obj2;
34120 {
34121 PyThreadState* __tstate = wxPyBeginAllowThreads();
34122 (arg1)->_setCallbackInfo(arg2,arg3);
34123 wxPyEndAllowThreads(__tstate);
34124 if (PyErr_Occurred()) SWIG_fail;
34125 }
34126 resultobj = SWIG_Py_Void();
34127 return resultobj;
34128 fail:
34129 return NULL;
34130 }
34131
34132
34133 SWIGINTERN PyObject *_wrap_delete_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34134 PyObject *resultobj = 0;
34135 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34136 void *argp1 = 0 ;
34137 int res1 = 0 ;
34138 PyObject *swig_obj[1] ;
34139
34140 if (!args) SWIG_fail;
34141 swig_obj[0] = args;
34142 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
34143 if (!SWIG_IsOK(res1)) {
34144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropTarget" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34145 }
34146 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34147 {
34148 PyThreadState* __tstate = wxPyBeginAllowThreads();
34149 delete arg1;
34150
34151 wxPyEndAllowThreads(__tstate);
34152 if (PyErr_Occurred()) SWIG_fail;
34153 }
34154 resultobj = SWIG_Py_Void();
34155 return resultobj;
34156 fail:
34157 return NULL;
34158 }
34159
34160
34161 SWIGINTERN PyObject *_wrap_DropTarget_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34162 PyObject *resultobj = 0;
34163 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34164 wxDataObject *result = 0 ;
34165 void *argp1 = 0 ;
34166 int res1 = 0 ;
34167 PyObject *swig_obj[1] ;
34168
34169 if (!args) SWIG_fail;
34170 swig_obj[0] = args;
34171 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34172 if (!SWIG_IsOK(res1)) {
34173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34174 }
34175 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34176 {
34177 PyThreadState* __tstate = wxPyBeginAllowThreads();
34178 result = (wxDataObject *)(arg1)->GetDataObject();
34179 wxPyEndAllowThreads(__tstate);
34180 if (PyErr_Occurred()) SWIG_fail;
34181 }
34182 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
34183 return resultobj;
34184 fail:
34185 return NULL;
34186 }
34187
34188
34189 SWIGINTERN PyObject *_wrap_DropTarget_SetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34190 PyObject *resultobj = 0;
34191 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34192 wxDataObject *arg2 = (wxDataObject *) 0 ;
34193 void *argp1 = 0 ;
34194 int res1 = 0 ;
34195 int res2 = 0 ;
34196 PyObject * obj0 = 0 ;
34197 PyObject * obj1 = 0 ;
34198 char * kwnames[] = {
34199 (char *) "self",(char *) "dataObject", NULL
34200 };
34201
34202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) SWIG_fail;
34203 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34204 if (!SWIG_IsOK(res1)) {
34205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34206 }
34207 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34208 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34209 if (!SWIG_IsOK(res2)) {
34210 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropTarget_SetDataObject" "', expected argument " "2"" of type '" "wxDataObject *""'");
34211 }
34212 {
34213 PyThreadState* __tstate = wxPyBeginAllowThreads();
34214 (arg1)->SetDataObject(arg2);
34215 wxPyEndAllowThreads(__tstate);
34216 if (PyErr_Occurred()) SWIG_fail;
34217 }
34218 resultobj = SWIG_Py_Void();
34219 return resultobj;
34220 fail:
34221 return NULL;
34222 }
34223
34224
34225 SWIGINTERN PyObject *_wrap_DropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34226 PyObject *resultobj = 0;
34227 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34228 int arg2 ;
34229 int arg3 ;
34230 wxDragResult arg4 ;
34231 wxDragResult result;
34232 void *argp1 = 0 ;
34233 int res1 = 0 ;
34234 int val2 ;
34235 int ecode2 = 0 ;
34236 int val3 ;
34237 int ecode3 = 0 ;
34238 int val4 ;
34239 int ecode4 = 0 ;
34240 PyObject * obj0 = 0 ;
34241 PyObject * obj1 = 0 ;
34242 PyObject * obj2 = 0 ;
34243 PyObject * obj3 = 0 ;
34244 char * kwnames[] = {
34245 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34246 };
34247
34248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34250 if (!SWIG_IsOK(res1)) {
34251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34252 }
34253 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34254 ecode2 = SWIG_AsVal_int(obj1, &val2);
34255 if (!SWIG_IsOK(ecode2)) {
34256 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
34257 }
34258 arg2 = static_cast< int >(val2);
34259 ecode3 = SWIG_AsVal_int(obj2, &val3);
34260 if (!SWIG_IsOK(ecode3)) {
34261 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
34262 }
34263 arg3 = static_cast< int >(val3);
34264 ecode4 = SWIG_AsVal_int(obj3, &val4);
34265 if (!SWIG_IsOK(ecode4)) {
34266 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
34267 }
34268 arg4 = static_cast< wxDragResult >(val4);
34269 {
34270 PyThreadState* __tstate = wxPyBeginAllowThreads();
34271 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
34272 wxPyEndAllowThreads(__tstate);
34273 if (PyErr_Occurred()) SWIG_fail;
34274 }
34275 resultobj = SWIG_From_int(static_cast< int >(result));
34276 return resultobj;
34277 fail:
34278 return NULL;
34279 }
34280
34281
34282 SWIGINTERN PyObject *_wrap_DropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34283 PyObject *resultobj = 0;
34284 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34285 int arg2 ;
34286 int arg3 ;
34287 wxDragResult arg4 ;
34288 wxDragResult result;
34289 void *argp1 = 0 ;
34290 int res1 = 0 ;
34291 int val2 ;
34292 int ecode2 = 0 ;
34293 int val3 ;
34294 int ecode3 = 0 ;
34295 int val4 ;
34296 int ecode4 = 0 ;
34297 PyObject * obj0 = 0 ;
34298 PyObject * obj1 = 0 ;
34299 PyObject * obj2 = 0 ;
34300 PyObject * obj3 = 0 ;
34301 char * kwnames[] = {
34302 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34303 };
34304
34305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34306 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34307 if (!SWIG_IsOK(res1)) {
34308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34309 }
34310 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34311 ecode2 = SWIG_AsVal_int(obj1, &val2);
34312 if (!SWIG_IsOK(ecode2)) {
34313 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
34314 }
34315 arg2 = static_cast< int >(val2);
34316 ecode3 = SWIG_AsVal_int(obj2, &val3);
34317 if (!SWIG_IsOK(ecode3)) {
34318 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
34319 }
34320 arg3 = static_cast< int >(val3);
34321 ecode4 = SWIG_AsVal_int(obj3, &val4);
34322 if (!SWIG_IsOK(ecode4)) {
34323 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
34324 }
34325 arg4 = static_cast< wxDragResult >(val4);
34326 {
34327 PyThreadState* __tstate = wxPyBeginAllowThreads();
34328 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
34329 wxPyEndAllowThreads(__tstate);
34330 if (PyErr_Occurred()) SWIG_fail;
34331 }
34332 resultobj = SWIG_From_int(static_cast< int >(result));
34333 return resultobj;
34334 fail:
34335 return NULL;
34336 }
34337
34338
34339 SWIGINTERN PyObject *_wrap_DropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34340 PyObject *resultobj = 0;
34341 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34342 void *argp1 = 0 ;
34343 int res1 = 0 ;
34344 PyObject *swig_obj[1] ;
34345
34346 if (!args) SWIG_fail;
34347 swig_obj[0] = args;
34348 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34349 if (!SWIG_IsOK(res1)) {
34350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34351 }
34352 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34353 {
34354 PyThreadState* __tstate = wxPyBeginAllowThreads();
34355 (arg1)->OnLeave();
34356 wxPyEndAllowThreads(__tstate);
34357 if (PyErr_Occurred()) SWIG_fail;
34358 }
34359 resultobj = SWIG_Py_Void();
34360 return resultobj;
34361 fail:
34362 return NULL;
34363 }
34364
34365
34366 SWIGINTERN PyObject *_wrap_DropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34367 PyObject *resultobj = 0;
34368 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34369 int arg2 ;
34370 int arg3 ;
34371 bool result;
34372 void *argp1 = 0 ;
34373 int res1 = 0 ;
34374 int val2 ;
34375 int ecode2 = 0 ;
34376 int val3 ;
34377 int ecode3 = 0 ;
34378 PyObject * obj0 = 0 ;
34379 PyObject * obj1 = 0 ;
34380 PyObject * obj2 = 0 ;
34381 char * kwnames[] = {
34382 (char *) "self",(char *) "x",(char *) "y", NULL
34383 };
34384
34385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34387 if (!SWIG_IsOK(res1)) {
34388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34389 }
34390 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34391 ecode2 = SWIG_AsVal_int(obj1, &val2);
34392 if (!SWIG_IsOK(ecode2)) {
34393 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
34394 }
34395 arg2 = static_cast< int >(val2);
34396 ecode3 = SWIG_AsVal_int(obj2, &val3);
34397 if (!SWIG_IsOK(ecode3)) {
34398 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
34399 }
34400 arg3 = static_cast< int >(val3);
34401 {
34402 PyThreadState* __tstate = wxPyBeginAllowThreads();
34403 result = (bool)(arg1)->OnDrop(arg2,arg3);
34404 wxPyEndAllowThreads(__tstate);
34405 if (PyErr_Occurred()) SWIG_fail;
34406 }
34407 {
34408 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34409 }
34410 return resultobj;
34411 fail:
34412 return NULL;
34413 }
34414
34415
34416 SWIGINTERN PyObject *_wrap_DropTarget_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34417 PyObject *resultobj = 0;
34418 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34419 bool result;
34420 void *argp1 = 0 ;
34421 int res1 = 0 ;
34422 PyObject *swig_obj[1] ;
34423
34424 if (!args) SWIG_fail;
34425 swig_obj[0] = args;
34426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34427 if (!SWIG_IsOK(res1)) {
34428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetData" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34429 }
34430 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34431 {
34432 PyThreadState* __tstate = wxPyBeginAllowThreads();
34433 result = (bool)(arg1)->GetData();
34434 wxPyEndAllowThreads(__tstate);
34435 if (PyErr_Occurred()) SWIG_fail;
34436 }
34437 {
34438 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34439 }
34440 return resultobj;
34441 fail:
34442 return NULL;
34443 }
34444
34445
34446 SWIGINTERN PyObject *_wrap_DropTarget_SetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34447 PyObject *resultobj = 0;
34448 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34449 wxDragResult arg2 ;
34450 void *argp1 = 0 ;
34451 int res1 = 0 ;
34452 int val2 ;
34453 int ecode2 = 0 ;
34454 PyObject * obj0 = 0 ;
34455 PyObject * obj1 = 0 ;
34456 char * kwnames[] = {
34457 (char *) "self",(char *) "action", NULL
34458 };
34459
34460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDefaultAction",kwnames,&obj0,&obj1)) SWIG_fail;
34461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34462 if (!SWIG_IsOK(res1)) {
34463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34464 }
34465 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34466 ecode2 = SWIG_AsVal_int(obj1, &val2);
34467 if (!SWIG_IsOK(ecode2)) {
34468 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "2"" of type '" "wxDragResult""'");
34469 }
34470 arg2 = static_cast< wxDragResult >(val2);
34471 {
34472 PyThreadState* __tstate = wxPyBeginAllowThreads();
34473 (arg1)->SetDefaultAction(arg2);
34474 wxPyEndAllowThreads(__tstate);
34475 if (PyErr_Occurred()) SWIG_fail;
34476 }
34477 resultobj = SWIG_Py_Void();
34478 return resultobj;
34479 fail:
34480 return NULL;
34481 }
34482
34483
34484 SWIGINTERN PyObject *_wrap_DropTarget_GetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34485 PyObject *resultobj = 0;
34486 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34487 wxDragResult result;
34488 void *argp1 = 0 ;
34489 int res1 = 0 ;
34490 PyObject *swig_obj[1] ;
34491
34492 if (!args) SWIG_fail;
34493 swig_obj[0] = args;
34494 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34495 if (!SWIG_IsOK(res1)) {
34496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34497 }
34498 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34499 {
34500 PyThreadState* __tstate = wxPyBeginAllowThreads();
34501 result = (wxDragResult)(arg1)->GetDefaultAction();
34502 wxPyEndAllowThreads(__tstate);
34503 if (PyErr_Occurred()) SWIG_fail;
34504 }
34505 resultobj = SWIG_From_int(static_cast< int >(result));
34506 return resultobj;
34507 fail:
34508 return NULL;
34509 }
34510
34511
34512 SWIGINTERN PyObject *DropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34513 PyObject *obj;
34514 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34515 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropTarget, SWIG_NewClientData(obj));
34516 return SWIG_Py_Void();
34517 }
34518
34519 SWIGINTERN PyObject *DropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34520 return SWIG_Python_InitShadowInstance(args);
34521 }
34522
34523 SWIGINTERN PyObject *_wrap_new_TextDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34524 PyObject *resultobj = 0;
34525 wxPyTextDropTarget *result = 0 ;
34526
34527 if (!SWIG_Python_UnpackTuple(args,"new_TextDropTarget",0,0,0)) SWIG_fail;
34528 {
34529 PyThreadState* __tstate = wxPyBeginAllowThreads();
34530 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
34531 wxPyEndAllowThreads(__tstate);
34532 if (PyErr_Occurred()) SWIG_fail;
34533 }
34534 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_NEW | 0 );
34535 return resultobj;
34536 fail:
34537 return NULL;
34538 }
34539
34540
34541 SWIGINTERN PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34542 PyObject *resultobj = 0;
34543 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34544 PyObject *arg2 = (PyObject *) 0 ;
34545 PyObject *arg3 = (PyObject *) 0 ;
34546 void *argp1 = 0 ;
34547 int res1 = 0 ;
34548 PyObject * obj0 = 0 ;
34549 PyObject * obj1 = 0 ;
34550 PyObject * obj2 = 0 ;
34551 char * kwnames[] = {
34552 (char *) "self",(char *) "self",(char *) "_class", NULL
34553 };
34554
34555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34556 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34557 if (!SWIG_IsOK(res1)) {
34558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34559 }
34560 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34561 arg2 = obj1;
34562 arg3 = obj2;
34563 {
34564 PyThreadState* __tstate = wxPyBeginAllowThreads();
34565 (arg1)->_setCallbackInfo(arg2,arg3);
34566 wxPyEndAllowThreads(__tstate);
34567 if (PyErr_Occurred()) SWIG_fail;
34568 }
34569 resultobj = SWIG_Py_Void();
34570 return resultobj;
34571 fail:
34572 return NULL;
34573 }
34574
34575
34576 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDropText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34577 PyObject *resultobj = 0;
34578 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34579 int arg2 ;
34580 int arg3 ;
34581 wxString *arg4 = 0 ;
34582 bool result;
34583 void *argp1 = 0 ;
34584 int res1 = 0 ;
34585 int val2 ;
34586 int ecode2 = 0 ;
34587 int val3 ;
34588 int ecode3 = 0 ;
34589 bool temp4 = false ;
34590 PyObject * obj0 = 0 ;
34591 PyObject * obj1 = 0 ;
34592 PyObject * obj2 = 0 ;
34593 PyObject * obj3 = 0 ;
34594 char * kwnames[] = {
34595 (char *) "self",(char *) "x",(char *) "y",(char *) "text", NULL
34596 };
34597
34598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDropText",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34599 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34600 if (!SWIG_IsOK(res1)) {
34601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDropText" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34602 }
34603 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34604 ecode2 = SWIG_AsVal_int(obj1, &val2);
34605 if (!SWIG_IsOK(ecode2)) {
34606 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDropText" "', expected argument " "2"" of type '" "int""'");
34607 }
34608 arg2 = static_cast< int >(val2);
34609 ecode3 = SWIG_AsVal_int(obj2, &val3);
34610 if (!SWIG_IsOK(ecode3)) {
34611 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDropText" "', expected argument " "3"" of type '" "int""'");
34612 }
34613 arg3 = static_cast< int >(val3);
34614 {
34615 arg4 = wxString_in_helper(obj3);
34616 if (arg4 == NULL) SWIG_fail;
34617 temp4 = true;
34618 }
34619 {
34620 PyThreadState* __tstate = wxPyBeginAllowThreads();
34621 result = (bool)(arg1)->OnDropText(arg2,arg3,(wxString const &)*arg4);
34622 wxPyEndAllowThreads(__tstate);
34623 if (PyErr_Occurred()) SWIG_fail;
34624 }
34625 {
34626 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34627 }
34628 {
34629 if (temp4)
34630 delete arg4;
34631 }
34632 return resultobj;
34633 fail:
34634 {
34635 if (temp4)
34636 delete arg4;
34637 }
34638 return NULL;
34639 }
34640
34641
34642 SWIGINTERN PyObject *_wrap_TextDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34643 PyObject *resultobj = 0;
34644 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34645 int arg2 ;
34646 int arg3 ;
34647 wxDragResult arg4 ;
34648 wxDragResult result;
34649 void *argp1 = 0 ;
34650 int res1 = 0 ;
34651 int val2 ;
34652 int ecode2 = 0 ;
34653 int val3 ;
34654 int ecode3 = 0 ;
34655 int val4 ;
34656 int ecode4 = 0 ;
34657 PyObject * obj0 = 0 ;
34658 PyObject * obj1 = 0 ;
34659 PyObject * obj2 = 0 ;
34660 PyObject * obj3 = 0 ;
34661 char * kwnames[] = {
34662 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34663 };
34664
34665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34666 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34667 if (!SWIG_IsOK(res1)) {
34668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34669 }
34670 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34671 ecode2 = SWIG_AsVal_int(obj1, &val2);
34672 if (!SWIG_IsOK(ecode2)) {
34673 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
34674 }
34675 arg2 = static_cast< int >(val2);
34676 ecode3 = SWIG_AsVal_int(obj2, &val3);
34677 if (!SWIG_IsOK(ecode3)) {
34678 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
34679 }
34680 arg3 = static_cast< int >(val3);
34681 ecode4 = SWIG_AsVal_int(obj3, &val4);
34682 if (!SWIG_IsOK(ecode4)) {
34683 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
34684 }
34685 arg4 = static_cast< wxDragResult >(val4);
34686 {
34687 PyThreadState* __tstate = wxPyBeginAllowThreads();
34688 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
34689 wxPyEndAllowThreads(__tstate);
34690 if (PyErr_Occurred()) SWIG_fail;
34691 }
34692 resultobj = SWIG_From_int(static_cast< int >(result));
34693 return resultobj;
34694 fail:
34695 return NULL;
34696 }
34697
34698
34699 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34700 PyObject *resultobj = 0;
34701 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34702 int arg2 ;
34703 int arg3 ;
34704 wxDragResult arg4 ;
34705 wxDragResult result;
34706 void *argp1 = 0 ;
34707 int res1 = 0 ;
34708 int val2 ;
34709 int ecode2 = 0 ;
34710 int val3 ;
34711 int ecode3 = 0 ;
34712 int val4 ;
34713 int ecode4 = 0 ;
34714 PyObject * obj0 = 0 ;
34715 PyObject * obj1 = 0 ;
34716 PyObject * obj2 = 0 ;
34717 PyObject * obj3 = 0 ;
34718 char * kwnames[] = {
34719 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34720 };
34721
34722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34723 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34724 if (!SWIG_IsOK(res1)) {
34725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34726 }
34727 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34728 ecode2 = SWIG_AsVal_int(obj1, &val2);
34729 if (!SWIG_IsOK(ecode2)) {
34730 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
34731 }
34732 arg2 = static_cast< int >(val2);
34733 ecode3 = SWIG_AsVal_int(obj2, &val3);
34734 if (!SWIG_IsOK(ecode3)) {
34735 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
34736 }
34737 arg3 = static_cast< int >(val3);
34738 ecode4 = SWIG_AsVal_int(obj3, &val4);
34739 if (!SWIG_IsOK(ecode4)) {
34740 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
34741 }
34742 arg4 = static_cast< wxDragResult >(val4);
34743 {
34744 PyThreadState* __tstate = wxPyBeginAllowThreads();
34745 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
34746 wxPyEndAllowThreads(__tstate);
34747 if (PyErr_Occurred()) SWIG_fail;
34748 }
34749 resultobj = SWIG_From_int(static_cast< int >(result));
34750 return resultobj;
34751 fail:
34752 return NULL;
34753 }
34754
34755
34756 SWIGINTERN PyObject *_wrap_TextDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34757 PyObject *resultobj = 0;
34758 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34759 void *argp1 = 0 ;
34760 int res1 = 0 ;
34761 PyObject *swig_obj[1] ;
34762
34763 if (!args) SWIG_fail;
34764 swig_obj[0] = args;
34765 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34766 if (!SWIG_IsOK(res1)) {
34767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34768 }
34769 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34770 {
34771 PyThreadState* __tstate = wxPyBeginAllowThreads();
34772 (arg1)->OnLeave();
34773 wxPyEndAllowThreads(__tstate);
34774 if (PyErr_Occurred()) SWIG_fail;
34775 }
34776 resultobj = SWIG_Py_Void();
34777 return resultobj;
34778 fail:
34779 return NULL;
34780 }
34781
34782
34783 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34784 PyObject *resultobj = 0;
34785 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34786 int arg2 ;
34787 int arg3 ;
34788 bool result;
34789 void *argp1 = 0 ;
34790 int res1 = 0 ;
34791 int val2 ;
34792 int ecode2 = 0 ;
34793 int val3 ;
34794 int ecode3 = 0 ;
34795 PyObject * obj0 = 0 ;
34796 PyObject * obj1 = 0 ;
34797 PyObject * obj2 = 0 ;
34798 char * kwnames[] = {
34799 (char *) "self",(char *) "x",(char *) "y", NULL
34800 };
34801
34802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34803 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34804 if (!SWIG_IsOK(res1)) {
34805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34806 }
34807 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34808 ecode2 = SWIG_AsVal_int(obj1, &val2);
34809 if (!SWIG_IsOK(ecode2)) {
34810 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
34811 }
34812 arg2 = static_cast< int >(val2);
34813 ecode3 = SWIG_AsVal_int(obj2, &val3);
34814 if (!SWIG_IsOK(ecode3)) {
34815 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
34816 }
34817 arg3 = static_cast< int >(val3);
34818 {
34819 PyThreadState* __tstate = wxPyBeginAllowThreads();
34820 result = (bool)(arg1)->OnDrop(arg2,arg3);
34821 wxPyEndAllowThreads(__tstate);
34822 if (PyErr_Occurred()) SWIG_fail;
34823 }
34824 {
34825 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34826 }
34827 return resultobj;
34828 fail:
34829 return NULL;
34830 }
34831
34832
34833 SWIGINTERN PyObject *_wrap_TextDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34834 PyObject *resultobj = 0;
34835 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34836 int arg2 ;
34837 int arg3 ;
34838 wxDragResult arg4 ;
34839 wxDragResult result;
34840 void *argp1 = 0 ;
34841 int res1 = 0 ;
34842 int val2 ;
34843 int ecode2 = 0 ;
34844 int val3 ;
34845 int ecode3 = 0 ;
34846 int val4 ;
34847 int ecode4 = 0 ;
34848 PyObject * obj0 = 0 ;
34849 PyObject * obj1 = 0 ;
34850 PyObject * obj2 = 0 ;
34851 PyObject * obj3 = 0 ;
34852 char * kwnames[] = {
34853 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34854 };
34855
34856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34857 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34858 if (!SWIG_IsOK(res1)) {
34859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34860 }
34861 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34862 ecode2 = SWIG_AsVal_int(obj1, &val2);
34863 if (!SWIG_IsOK(ecode2)) {
34864 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
34865 }
34866 arg2 = static_cast< int >(val2);
34867 ecode3 = SWIG_AsVal_int(obj2, &val3);
34868 if (!SWIG_IsOK(ecode3)) {
34869 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
34870 }
34871 arg3 = static_cast< int >(val3);
34872 ecode4 = SWIG_AsVal_int(obj3, &val4);
34873 if (!SWIG_IsOK(ecode4)) {
34874 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
34875 }
34876 arg4 = static_cast< wxDragResult >(val4);
34877 {
34878 PyThreadState* __tstate = wxPyBeginAllowThreads();
34879 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
34880 wxPyEndAllowThreads(__tstate);
34881 if (PyErr_Occurred()) SWIG_fail;
34882 }
34883 resultobj = SWIG_From_int(static_cast< int >(result));
34884 return resultobj;
34885 fail:
34886 return NULL;
34887 }
34888
34889
34890 SWIGINTERN PyObject *TextDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34891 PyObject *obj;
34892 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34893 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDropTarget, SWIG_NewClientData(obj));
34894 return SWIG_Py_Void();
34895 }
34896
34897 SWIGINTERN PyObject *TextDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34898 return SWIG_Python_InitShadowInstance(args);
34899 }
34900
34901 SWIGINTERN PyObject *_wrap_new_FileDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34902 PyObject *resultobj = 0;
34903 wxPyFileDropTarget *result = 0 ;
34904
34905 if (!SWIG_Python_UnpackTuple(args,"new_FileDropTarget",0,0,0)) SWIG_fail;
34906 {
34907 PyThreadState* __tstate = wxPyBeginAllowThreads();
34908 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
34909 wxPyEndAllowThreads(__tstate);
34910 if (PyErr_Occurred()) SWIG_fail;
34911 }
34912 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_NEW | 0 );
34913 return resultobj;
34914 fail:
34915 return NULL;
34916 }
34917
34918
34919 SWIGINTERN PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34920 PyObject *resultobj = 0;
34921 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
34922 PyObject *arg2 = (PyObject *) 0 ;
34923 PyObject *arg3 = (PyObject *) 0 ;
34924 void *argp1 = 0 ;
34925 int res1 = 0 ;
34926 PyObject * obj0 = 0 ;
34927 PyObject * obj1 = 0 ;
34928 PyObject * obj2 = 0 ;
34929 char * kwnames[] = {
34930 (char *) "self",(char *) "self",(char *) "_class", NULL
34931 };
34932
34933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34934 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
34935 if (!SWIG_IsOK(res1)) {
34936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
34937 }
34938 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
34939 arg2 = obj1;
34940 arg3 = obj2;
34941 {
34942 PyThreadState* __tstate = wxPyBeginAllowThreads();
34943 (arg1)->_setCallbackInfo(arg2,arg3);
34944 wxPyEndAllowThreads(__tstate);
34945 if (PyErr_Occurred()) SWIG_fail;
34946 }
34947 resultobj = SWIG_Py_Void();
34948 return resultobj;
34949 fail:
34950 return NULL;
34951 }
34952
34953
34954 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDropFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34955 PyObject *resultobj = 0;
34956 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
34957 int arg2 ;
34958 int arg3 ;
34959 wxArrayString *arg4 = 0 ;
34960 bool result;
34961 void *argp1 = 0 ;
34962 int res1 = 0 ;
34963 int val2 ;
34964 int ecode2 = 0 ;
34965 int val3 ;
34966 int ecode3 = 0 ;
34967 bool temp4 = false ;
34968 PyObject * obj0 = 0 ;
34969 PyObject * obj1 = 0 ;
34970 PyObject * obj2 = 0 ;
34971 PyObject * obj3 = 0 ;
34972 char * kwnames[] = {
34973 (char *) "self",(char *) "x",(char *) "y",(char *) "filenames", NULL
34974 };
34975
34976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDropFiles",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34977 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
34978 if (!SWIG_IsOK(res1)) {
34979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
34980 }
34981 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
34982 ecode2 = SWIG_AsVal_int(obj1, &val2);
34983 if (!SWIG_IsOK(ecode2)) {
34984 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "2"" of type '" "int""'");
34985 }
34986 arg2 = static_cast< int >(val2);
34987 ecode3 = SWIG_AsVal_int(obj2, &val3);
34988 if (!SWIG_IsOK(ecode3)) {
34989 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "3"" of type '" "int""'");
34990 }
34991 arg3 = static_cast< int >(val3);
34992 {
34993 if (! PySequence_Check(obj3)) {
34994 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
34995 SWIG_fail;
34996 }
34997 arg4 = new wxArrayString;
34998 temp4 = true;
34999 int i, len=PySequence_Length(obj3);
35000 for (i=0; i<len; i++) {
35001 PyObject* item = PySequence_GetItem(obj3, i);
35002 wxString* s = wxString_in_helper(item);
35003 if (PyErr_Occurred()) SWIG_fail;
35004 arg4->Add(*s);
35005 delete s;
35006 Py_DECREF(item);
35007 }
35008 }
35009 {
35010 PyThreadState* __tstate = wxPyBeginAllowThreads();
35011 result = (bool)(arg1)->OnDropFiles(arg2,arg3,(wxArrayString const &)*arg4);
35012 wxPyEndAllowThreads(__tstate);
35013 if (PyErr_Occurred()) SWIG_fail;
35014 }
35015 {
35016 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35017 }
35018 {
35019 if (temp4) delete arg4;
35020 }
35021 return resultobj;
35022 fail:
35023 {
35024 if (temp4) delete arg4;
35025 }
35026 return NULL;
35027 }
35028
35029
35030 SWIGINTERN PyObject *_wrap_FileDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35031 PyObject *resultobj = 0;
35032 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35033 int arg2 ;
35034 int arg3 ;
35035 wxDragResult arg4 ;
35036 wxDragResult result;
35037 void *argp1 = 0 ;
35038 int res1 = 0 ;
35039 int val2 ;
35040 int ecode2 = 0 ;
35041 int val3 ;
35042 int ecode3 = 0 ;
35043 int val4 ;
35044 int ecode4 = 0 ;
35045 PyObject * obj0 = 0 ;
35046 PyObject * obj1 = 0 ;
35047 PyObject * obj2 = 0 ;
35048 PyObject * obj3 = 0 ;
35049 char * kwnames[] = {
35050 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
35051 };
35052
35053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35055 if (!SWIG_IsOK(res1)) {
35056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35057 }
35058 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35059 ecode2 = SWIG_AsVal_int(obj1, &val2);
35060 if (!SWIG_IsOK(ecode2)) {
35061 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
35062 }
35063 arg2 = static_cast< int >(val2);
35064 ecode3 = SWIG_AsVal_int(obj2, &val3);
35065 if (!SWIG_IsOK(ecode3)) {
35066 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
35067 }
35068 arg3 = static_cast< int >(val3);
35069 ecode4 = SWIG_AsVal_int(obj3, &val4);
35070 if (!SWIG_IsOK(ecode4)) {
35071 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
35072 }
35073 arg4 = static_cast< wxDragResult >(val4);
35074 {
35075 PyThreadState* __tstate = wxPyBeginAllowThreads();
35076 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
35077 wxPyEndAllowThreads(__tstate);
35078 if (PyErr_Occurred()) SWIG_fail;
35079 }
35080 resultobj = SWIG_From_int(static_cast< int >(result));
35081 return resultobj;
35082 fail:
35083 return NULL;
35084 }
35085
35086
35087 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35088 PyObject *resultobj = 0;
35089 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35090 int arg2 ;
35091 int arg3 ;
35092 wxDragResult arg4 ;
35093 wxDragResult result;
35094 void *argp1 = 0 ;
35095 int res1 = 0 ;
35096 int val2 ;
35097 int ecode2 = 0 ;
35098 int val3 ;
35099 int ecode3 = 0 ;
35100 int val4 ;
35101 int ecode4 = 0 ;
35102 PyObject * obj0 = 0 ;
35103 PyObject * obj1 = 0 ;
35104 PyObject * obj2 = 0 ;
35105 PyObject * obj3 = 0 ;
35106 char * kwnames[] = {
35107 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
35108 };
35109
35110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35111 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35112 if (!SWIG_IsOK(res1)) {
35113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35114 }
35115 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35116 ecode2 = SWIG_AsVal_int(obj1, &val2);
35117 if (!SWIG_IsOK(ecode2)) {
35118 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
35119 }
35120 arg2 = static_cast< int >(val2);
35121 ecode3 = SWIG_AsVal_int(obj2, &val3);
35122 if (!SWIG_IsOK(ecode3)) {
35123 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
35124 }
35125 arg3 = static_cast< int >(val3);
35126 ecode4 = SWIG_AsVal_int(obj3, &val4);
35127 if (!SWIG_IsOK(ecode4)) {
35128 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
35129 }
35130 arg4 = static_cast< wxDragResult >(val4);
35131 {
35132 PyThreadState* __tstate = wxPyBeginAllowThreads();
35133 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
35134 wxPyEndAllowThreads(__tstate);
35135 if (PyErr_Occurred()) SWIG_fail;
35136 }
35137 resultobj = SWIG_From_int(static_cast< int >(result));
35138 return resultobj;
35139 fail:
35140 return NULL;
35141 }
35142
35143
35144 SWIGINTERN PyObject *_wrap_FileDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35145 PyObject *resultobj = 0;
35146 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35147 void *argp1 = 0 ;
35148 int res1 = 0 ;
35149 PyObject *swig_obj[1] ;
35150
35151 if (!args) SWIG_fail;
35152 swig_obj[0] = args;
35153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35154 if (!SWIG_IsOK(res1)) {
35155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35156 }
35157 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35158 {
35159 PyThreadState* __tstate = wxPyBeginAllowThreads();
35160 (arg1)->OnLeave();
35161 wxPyEndAllowThreads(__tstate);
35162 if (PyErr_Occurred()) SWIG_fail;
35163 }
35164 resultobj = SWIG_Py_Void();
35165 return resultobj;
35166 fail:
35167 return NULL;
35168 }
35169
35170
35171 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35172 PyObject *resultobj = 0;
35173 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35174 int arg2 ;
35175 int arg3 ;
35176 bool result;
35177 void *argp1 = 0 ;
35178 int res1 = 0 ;
35179 int val2 ;
35180 int ecode2 = 0 ;
35181 int val3 ;
35182 int ecode3 = 0 ;
35183 PyObject * obj0 = 0 ;
35184 PyObject * obj1 = 0 ;
35185 PyObject * obj2 = 0 ;
35186 char * kwnames[] = {
35187 (char *) "self",(char *) "x",(char *) "y", NULL
35188 };
35189
35190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35191 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35192 if (!SWIG_IsOK(res1)) {
35193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35194 }
35195 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35196 ecode2 = SWIG_AsVal_int(obj1, &val2);
35197 if (!SWIG_IsOK(ecode2)) {
35198 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
35199 }
35200 arg2 = static_cast< int >(val2);
35201 ecode3 = SWIG_AsVal_int(obj2, &val3);
35202 if (!SWIG_IsOK(ecode3)) {
35203 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
35204 }
35205 arg3 = static_cast< int >(val3);
35206 {
35207 PyThreadState* __tstate = wxPyBeginAllowThreads();
35208 result = (bool)(arg1)->OnDrop(arg2,arg3);
35209 wxPyEndAllowThreads(__tstate);
35210 if (PyErr_Occurred()) SWIG_fail;
35211 }
35212 {
35213 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35214 }
35215 return resultobj;
35216 fail:
35217 return NULL;
35218 }
35219
35220
35221 SWIGINTERN PyObject *_wrap_FileDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35222 PyObject *resultobj = 0;
35223 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35224 int arg2 ;
35225 int arg3 ;
35226 wxDragResult arg4 ;
35227 wxDragResult result;
35228 void *argp1 = 0 ;
35229 int res1 = 0 ;
35230 int val2 ;
35231 int ecode2 = 0 ;
35232 int val3 ;
35233 int ecode3 = 0 ;
35234 int val4 ;
35235 int ecode4 = 0 ;
35236 PyObject * obj0 = 0 ;
35237 PyObject * obj1 = 0 ;
35238 PyObject * obj2 = 0 ;
35239 PyObject * obj3 = 0 ;
35240 char * kwnames[] = {
35241 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
35242 };
35243
35244 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35245 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35246 if (!SWIG_IsOK(res1)) {
35247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35248 }
35249 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35250 ecode2 = SWIG_AsVal_int(obj1, &val2);
35251 if (!SWIG_IsOK(ecode2)) {
35252 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
35253 }
35254 arg2 = static_cast< int >(val2);
35255 ecode3 = SWIG_AsVal_int(obj2, &val3);
35256 if (!SWIG_IsOK(ecode3)) {
35257 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
35258 }
35259 arg3 = static_cast< int >(val3);
35260 ecode4 = SWIG_AsVal_int(obj3, &val4);
35261 if (!SWIG_IsOK(ecode4)) {
35262 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
35263 }
35264 arg4 = static_cast< wxDragResult >(val4);
35265 {
35266 PyThreadState* __tstate = wxPyBeginAllowThreads();
35267 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
35268 wxPyEndAllowThreads(__tstate);
35269 if (PyErr_Occurred()) SWIG_fail;
35270 }
35271 resultobj = SWIG_From_int(static_cast< int >(result));
35272 return resultobj;
35273 fail:
35274 return NULL;
35275 }
35276
35277
35278 SWIGINTERN PyObject *FileDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35279 PyObject *obj;
35280 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35281 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileDropTarget, SWIG_NewClientData(obj));
35282 return SWIG_Py_Void();
35283 }
35284
35285 SWIGINTERN PyObject *FileDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35286 return SWIG_Python_InitShadowInstance(args);
35287 }
35288
35289 SWIGINTERN PyObject *_wrap_new_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35290 PyObject *resultobj = 0;
35291 wxClipboard *result = 0 ;
35292
35293 if (!SWIG_Python_UnpackTuple(args,"new_Clipboard",0,0,0)) SWIG_fail;
35294 {
35295 PyThreadState* __tstate = wxPyBeginAllowThreads();
35296 result = (wxClipboard *)new wxClipboard();
35297 wxPyEndAllowThreads(__tstate);
35298 if (PyErr_Occurred()) SWIG_fail;
35299 }
35300 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, SWIG_POINTER_NEW | 0 );
35301 return resultobj;
35302 fail:
35303 return NULL;
35304 }
35305
35306
35307 SWIGINTERN PyObject *_wrap_delete_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35308 PyObject *resultobj = 0;
35309 wxClipboard *arg1 = (wxClipboard *) 0 ;
35310 void *argp1 = 0 ;
35311 int res1 = 0 ;
35312 PyObject *swig_obj[1] ;
35313
35314 if (!args) SWIG_fail;
35315 swig_obj[0] = args;
35316 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, SWIG_POINTER_DISOWN | 0 );
35317 if (!SWIG_IsOK(res1)) {
35318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Clipboard" "', expected argument " "1"" of type '" "wxClipboard *""'");
35319 }
35320 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35321 {
35322 PyThreadState* __tstate = wxPyBeginAllowThreads();
35323 delete arg1;
35324
35325 wxPyEndAllowThreads(__tstate);
35326 if (PyErr_Occurred()) SWIG_fail;
35327 }
35328 resultobj = SWIG_Py_Void();
35329 return resultobj;
35330 fail:
35331 return NULL;
35332 }
35333
35334
35335 SWIGINTERN PyObject *_wrap_Clipboard_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35336 PyObject *resultobj = 0;
35337 wxClipboard *arg1 = (wxClipboard *) 0 ;
35338 bool result;
35339 void *argp1 = 0 ;
35340 int res1 = 0 ;
35341 PyObject *swig_obj[1] ;
35342
35343 if (!args) SWIG_fail;
35344 swig_obj[0] = args;
35345 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35346 if (!SWIG_IsOK(res1)) {
35347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Open" "', expected argument " "1"" of type '" "wxClipboard *""'");
35348 }
35349 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35350 {
35351 PyThreadState* __tstate = wxPyBeginAllowThreads();
35352 result = (bool)(arg1)->Open();
35353 wxPyEndAllowThreads(__tstate);
35354 if (PyErr_Occurred()) SWIG_fail;
35355 }
35356 {
35357 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35358 }
35359 return resultobj;
35360 fail:
35361 return NULL;
35362 }
35363
35364
35365 SWIGINTERN PyObject *_wrap_Clipboard_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35366 PyObject *resultobj = 0;
35367 wxClipboard *arg1 = (wxClipboard *) 0 ;
35368 void *argp1 = 0 ;
35369 int res1 = 0 ;
35370 PyObject *swig_obj[1] ;
35371
35372 if (!args) SWIG_fail;
35373 swig_obj[0] = args;
35374 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35375 if (!SWIG_IsOK(res1)) {
35376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Close" "', expected argument " "1"" of type '" "wxClipboard *""'");
35377 }
35378 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35379 {
35380 PyThreadState* __tstate = wxPyBeginAllowThreads();
35381 (arg1)->Close();
35382 wxPyEndAllowThreads(__tstate);
35383 if (PyErr_Occurred()) SWIG_fail;
35384 }
35385 resultobj = SWIG_Py_Void();
35386 return resultobj;
35387 fail:
35388 return NULL;
35389 }
35390
35391
35392 SWIGINTERN PyObject *_wrap_Clipboard_IsOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35393 PyObject *resultobj = 0;
35394 wxClipboard *arg1 = (wxClipboard *) 0 ;
35395 bool result;
35396 void *argp1 = 0 ;
35397 int res1 = 0 ;
35398 PyObject *swig_obj[1] ;
35399
35400 if (!args) SWIG_fail;
35401 swig_obj[0] = args;
35402 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35403 if (!SWIG_IsOK(res1)) {
35404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsOpened" "', expected argument " "1"" of type '" "wxClipboard const *""'");
35405 }
35406 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35407 {
35408 PyThreadState* __tstate = wxPyBeginAllowThreads();
35409 result = (bool)((wxClipboard const *)arg1)->IsOpened();
35410 wxPyEndAllowThreads(__tstate);
35411 if (PyErr_Occurred()) SWIG_fail;
35412 }
35413 {
35414 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35415 }
35416 return resultobj;
35417 fail:
35418 return NULL;
35419 }
35420
35421
35422 SWIGINTERN PyObject *_wrap_Clipboard_AddData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35423 PyObject *resultobj = 0;
35424 wxClipboard *arg1 = (wxClipboard *) 0 ;
35425 wxDataObject *arg2 = (wxDataObject *) 0 ;
35426 bool result;
35427 void *argp1 = 0 ;
35428 int res1 = 0 ;
35429 int res2 = 0 ;
35430 PyObject * obj0 = 0 ;
35431 PyObject * obj1 = 0 ;
35432 char * kwnames[] = {
35433 (char *) "self",(char *) "data", NULL
35434 };
35435
35436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) SWIG_fail;
35437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35438 if (!SWIG_IsOK(res1)) {
35439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_AddData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35440 }
35441 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35442 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
35443 if (!SWIG_IsOK(res2)) {
35444 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_AddData" "', expected argument " "2"" of type '" "wxDataObject *""'");
35445 }
35446 {
35447 PyThreadState* __tstate = wxPyBeginAllowThreads();
35448 result = (bool)(arg1)->AddData(arg2);
35449 wxPyEndAllowThreads(__tstate);
35450 if (PyErr_Occurred()) SWIG_fail;
35451 }
35452 {
35453 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35454 }
35455 return resultobj;
35456 fail:
35457 return NULL;
35458 }
35459
35460
35461 SWIGINTERN PyObject *_wrap_Clipboard_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35462 PyObject *resultobj = 0;
35463 wxClipboard *arg1 = (wxClipboard *) 0 ;
35464 wxDataObject *arg2 = (wxDataObject *) 0 ;
35465 bool result;
35466 void *argp1 = 0 ;
35467 int res1 = 0 ;
35468 int res2 = 0 ;
35469 PyObject * obj0 = 0 ;
35470 PyObject * obj1 = 0 ;
35471 char * kwnames[] = {
35472 (char *) "self",(char *) "data", NULL
35473 };
35474
35475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
35476 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35477 if (!SWIG_IsOK(res1)) {
35478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_SetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35479 }
35480 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35481 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
35482 if (!SWIG_IsOK(res2)) {
35483 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_SetData" "', expected argument " "2"" of type '" "wxDataObject *""'");
35484 }
35485 {
35486 PyThreadState* __tstate = wxPyBeginAllowThreads();
35487 result = (bool)(arg1)->SetData(arg2);
35488 wxPyEndAllowThreads(__tstate);
35489 if (PyErr_Occurred()) SWIG_fail;
35490 }
35491 {
35492 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35493 }
35494 return resultobj;
35495 fail:
35496 return NULL;
35497 }
35498
35499
35500 SWIGINTERN PyObject *_wrap_Clipboard_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35501 PyObject *resultobj = 0;
35502 wxClipboard *arg1 = (wxClipboard *) 0 ;
35503 wxDataFormat *arg2 = 0 ;
35504 bool result;
35505 void *argp1 = 0 ;
35506 int res1 = 0 ;
35507 void *argp2 = 0 ;
35508 int res2 = 0 ;
35509 PyObject * obj0 = 0 ;
35510 PyObject * obj1 = 0 ;
35511 char * kwnames[] = {
35512 (char *) "self",(char *) "format", NULL
35513 };
35514
35515 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) SWIG_fail;
35516 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35517 if (!SWIG_IsOK(res1)) {
35518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsSupported" "', expected argument " "1"" of type '" "wxClipboard *""'");
35519 }
35520 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35521 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
35522 if (!SWIG_IsOK(res2)) {
35523 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
35524 }
35525 if (!argp2) {
35526 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
35527 }
35528 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
35529 {
35530 PyThreadState* __tstate = wxPyBeginAllowThreads();
35531 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
35532 wxPyEndAllowThreads(__tstate);
35533 if (PyErr_Occurred()) SWIG_fail;
35534 }
35535 {
35536 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35537 }
35538 return resultobj;
35539 fail:
35540 return NULL;
35541 }
35542
35543
35544 SWIGINTERN PyObject *_wrap_Clipboard_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35545 PyObject *resultobj = 0;
35546 wxClipboard *arg1 = (wxClipboard *) 0 ;
35547 wxDataObject *arg2 = 0 ;
35548 bool result;
35549 void *argp1 = 0 ;
35550 int res1 = 0 ;
35551 void *argp2 = 0 ;
35552 int res2 = 0 ;
35553 PyObject * obj0 = 0 ;
35554 PyObject * obj1 = 0 ;
35555 char * kwnames[] = {
35556 (char *) "self",(char *) "data", NULL
35557 };
35558
35559 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) SWIG_fail;
35560 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35561 if (!SWIG_IsOK(res1)) {
35562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_GetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35563 }
35564 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35565 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
35566 if (!SWIG_IsOK(res2)) {
35567 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
35568 }
35569 if (!argp2) {
35570 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
35571 }
35572 arg2 = reinterpret_cast< wxDataObject * >(argp2);
35573 {
35574 PyThreadState* __tstate = wxPyBeginAllowThreads();
35575 result = (bool)(arg1)->GetData(*arg2);
35576 wxPyEndAllowThreads(__tstate);
35577 if (PyErr_Occurred()) SWIG_fail;
35578 }
35579 {
35580 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35581 }
35582 return resultobj;
35583 fail:
35584 return NULL;
35585 }
35586
35587
35588 SWIGINTERN PyObject *_wrap_Clipboard_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35589 PyObject *resultobj = 0;
35590 wxClipboard *arg1 = (wxClipboard *) 0 ;
35591 void *argp1 = 0 ;
35592 int res1 = 0 ;
35593 PyObject *swig_obj[1] ;
35594
35595 if (!args) SWIG_fail;
35596 swig_obj[0] = args;
35597 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35598 if (!SWIG_IsOK(res1)) {
35599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Clear" "', expected argument " "1"" of type '" "wxClipboard *""'");
35600 }
35601 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35602 {
35603 PyThreadState* __tstate = wxPyBeginAllowThreads();
35604 (arg1)->Clear();
35605 wxPyEndAllowThreads(__tstate);
35606 if (PyErr_Occurred()) SWIG_fail;
35607 }
35608 resultobj = SWIG_Py_Void();
35609 return resultobj;
35610 fail:
35611 return NULL;
35612 }
35613
35614
35615 SWIGINTERN PyObject *_wrap_Clipboard_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35616 PyObject *resultobj = 0;
35617 wxClipboard *arg1 = (wxClipboard *) 0 ;
35618 bool result;
35619 void *argp1 = 0 ;
35620 int res1 = 0 ;
35621 PyObject *swig_obj[1] ;
35622
35623 if (!args) SWIG_fail;
35624 swig_obj[0] = args;
35625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35626 if (!SWIG_IsOK(res1)) {
35627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Flush" "', expected argument " "1"" of type '" "wxClipboard *""'");
35628 }
35629 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35630 {
35631 PyThreadState* __tstate = wxPyBeginAllowThreads();
35632 result = (bool)(arg1)->Flush();
35633 wxPyEndAllowThreads(__tstate);
35634 if (PyErr_Occurred()) SWIG_fail;
35635 }
35636 {
35637 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35638 }
35639 return resultobj;
35640 fail:
35641 return NULL;
35642 }
35643
35644
35645 SWIGINTERN PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35646 PyObject *resultobj = 0;
35647 wxClipboard *arg1 = (wxClipboard *) 0 ;
35648 bool arg2 = (bool) true ;
35649 void *argp1 = 0 ;
35650 int res1 = 0 ;
35651 bool val2 ;
35652 int ecode2 = 0 ;
35653 PyObject * obj0 = 0 ;
35654 PyObject * obj1 = 0 ;
35655 char * kwnames[] = {
35656 (char *) "self",(char *) "primary", NULL
35657 };
35658
35659 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) SWIG_fail;
35660 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35661 if (!SWIG_IsOK(res1)) {
35662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "1"" of type '" "wxClipboard *""'");
35663 }
35664 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35665 if (obj1) {
35666 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35667 if (!SWIG_IsOK(ecode2)) {
35668 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "2"" of type '" "bool""'");
35669 }
35670 arg2 = static_cast< bool >(val2);
35671 }
35672 {
35673 PyThreadState* __tstate = wxPyBeginAllowThreads();
35674 (arg1)->UsePrimarySelection(arg2);
35675 wxPyEndAllowThreads(__tstate);
35676 if (PyErr_Occurred()) SWIG_fail;
35677 }
35678 resultobj = SWIG_Py_Void();
35679 return resultobj;
35680 fail:
35681 return NULL;
35682 }
35683
35684
35685 SWIGINTERN PyObject *_wrap_Clipboard_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35686 PyObject *resultobj = 0;
35687 wxClipboard *result = 0 ;
35688
35689 if (!SWIG_Python_UnpackTuple(args,"Clipboard_Get",0,0,0)) SWIG_fail;
35690 {
35691 PyThreadState* __tstate = wxPyBeginAllowThreads();
35692 result = (wxClipboard *)wxClipboard::Get();
35693 wxPyEndAllowThreads(__tstate);
35694 if (PyErr_Occurred()) SWIG_fail;
35695 }
35696 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, 0 | 0 );
35697 return resultobj;
35698 fail:
35699 return NULL;
35700 }
35701
35702
35703 SWIGINTERN PyObject *Clipboard_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35704 PyObject *obj;
35705 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35706 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboard, SWIG_NewClientData(obj));
35707 return SWIG_Py_Void();
35708 }
35709
35710 SWIGINTERN PyObject *Clipboard_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35711 return SWIG_Python_InitShadowInstance(args);
35712 }
35713
35714 SWIGINTERN PyObject *_wrap_new_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35715 PyObject *resultobj = 0;
35716 wxClipboard *arg1 = (wxClipboard *) NULL ;
35717 wxClipboardLocker *result = 0 ;
35718 void *argp1 = 0 ;
35719 int res1 = 0 ;
35720 PyObject * obj0 = 0 ;
35721 char * kwnames[] = {
35722 (char *) "clipboard", NULL
35723 };
35724
35725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) SWIG_fail;
35726 if (obj0) {
35727 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35728 if (!SWIG_IsOK(res1)) {
35729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboard *""'");
35730 }
35731 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35732 }
35733 {
35734 PyThreadState* __tstate = wxPyBeginAllowThreads();
35735 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
35736 wxPyEndAllowThreads(__tstate);
35737 if (PyErr_Occurred()) SWIG_fail;
35738 }
35739 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_NEW | 0 );
35740 return resultobj;
35741 fail:
35742 return NULL;
35743 }
35744
35745
35746 SWIGINTERN PyObject *_wrap_delete_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35747 PyObject *resultobj = 0;
35748 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
35749 void *argp1 = 0 ;
35750 int res1 = 0 ;
35751 PyObject *swig_obj[1] ;
35752
35753 if (!args) SWIG_fail;
35754 swig_obj[0] = args;
35755 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_DISOWN | 0 );
35756 if (!SWIG_IsOK(res1)) {
35757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
35758 }
35759 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
35760 {
35761 PyThreadState* __tstate = wxPyBeginAllowThreads();
35762 delete arg1;
35763
35764 wxPyEndAllowThreads(__tstate);
35765 if (PyErr_Occurred()) SWIG_fail;
35766 }
35767 resultobj = SWIG_Py_Void();
35768 return resultobj;
35769 fail:
35770 return NULL;
35771 }
35772
35773
35774 SWIGINTERN PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35775 PyObject *resultobj = 0;
35776 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
35777 bool result;
35778 void *argp1 = 0 ;
35779 int res1 = 0 ;
35780 PyObject *swig_obj[1] ;
35781
35782 if (!args) SWIG_fail;
35783 swig_obj[0] = args;
35784 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, 0 | 0 );
35785 if (!SWIG_IsOK(res1)) {
35786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClipboardLocker___nonzero__" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
35787 }
35788 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
35789 {
35790 PyThreadState* __tstate = wxPyBeginAllowThreads();
35791 result = (bool)wxClipboardLocker___nonzero__(arg1);
35792 wxPyEndAllowThreads(__tstate);
35793 if (PyErr_Occurred()) SWIG_fail;
35794 }
35795 {
35796 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35797 }
35798 return resultobj;
35799 fail:
35800 return NULL;
35801 }
35802
35803
35804 SWIGINTERN PyObject *ClipboardLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35805 PyObject *obj;
35806 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35807 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardLocker, SWIG_NewClientData(obj));
35808 return SWIG_Py_Void();
35809 }
35810
35811 SWIGINTERN PyObject *ClipboardLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35812 return SWIG_Python_InitShadowInstance(args);
35813 }
35814
35815 SWIGINTERN PyObject *_wrap_new_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35816 PyObject *resultobj = 0;
35817 int arg1 = (int) 0 ;
35818 int arg2 = (int) 0 ;
35819 int arg3 = (int) 0 ;
35820 int arg4 = (int) 0 ;
35821 wxVideoMode *result = 0 ;
35822 int val1 ;
35823 int ecode1 = 0 ;
35824 int val2 ;
35825 int ecode2 = 0 ;
35826 int val3 ;
35827 int ecode3 = 0 ;
35828 int val4 ;
35829 int ecode4 = 0 ;
35830 PyObject * obj0 = 0 ;
35831 PyObject * obj1 = 0 ;
35832 PyObject * obj2 = 0 ;
35833 PyObject * obj3 = 0 ;
35834 char * kwnames[] = {
35835 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
35836 };
35837
35838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35839 if (obj0) {
35840 ecode1 = SWIG_AsVal_int(obj0, &val1);
35841 if (!SWIG_IsOK(ecode1)) {
35842 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VideoMode" "', expected argument " "1"" of type '" "int""'");
35843 }
35844 arg1 = static_cast< int >(val1);
35845 }
35846 if (obj1) {
35847 ecode2 = SWIG_AsVal_int(obj1, &val2);
35848 if (!SWIG_IsOK(ecode2)) {
35849 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VideoMode" "', expected argument " "2"" of type '" "int""'");
35850 }
35851 arg2 = static_cast< int >(val2);
35852 }
35853 if (obj2) {
35854 ecode3 = SWIG_AsVal_int(obj2, &val3);
35855 if (!SWIG_IsOK(ecode3)) {
35856 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_VideoMode" "', expected argument " "3"" of type '" "int""'");
35857 }
35858 arg3 = static_cast< int >(val3);
35859 }
35860 if (obj3) {
35861 ecode4 = SWIG_AsVal_int(obj3, &val4);
35862 if (!SWIG_IsOK(ecode4)) {
35863 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_VideoMode" "', expected argument " "4"" of type '" "int""'");
35864 }
35865 arg4 = static_cast< int >(val4);
35866 }
35867 {
35868 PyThreadState* __tstate = wxPyBeginAllowThreads();
35869 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
35870 wxPyEndAllowThreads(__tstate);
35871 if (PyErr_Occurred()) SWIG_fail;
35872 }
35873 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_NEW | 0 );
35874 return resultobj;
35875 fail:
35876 return NULL;
35877 }
35878
35879
35880 SWIGINTERN PyObject *_wrap_delete_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35881 PyObject *resultobj = 0;
35882 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35883 void *argp1 = 0 ;
35884 int res1 = 0 ;
35885 PyObject *swig_obj[1] ;
35886
35887 if (!args) SWIG_fail;
35888 swig_obj[0] = args;
35889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, SWIG_POINTER_DISOWN | 0 );
35890 if (!SWIG_IsOK(res1)) {
35891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VideoMode" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35892 }
35893 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35894 {
35895 PyThreadState* __tstate = wxPyBeginAllowThreads();
35896 delete arg1;
35897
35898 wxPyEndAllowThreads(__tstate);
35899 if (PyErr_Occurred()) SWIG_fail;
35900 }
35901 resultobj = SWIG_Py_Void();
35902 return resultobj;
35903 fail:
35904 return NULL;
35905 }
35906
35907
35908 SWIGINTERN PyObject *_wrap_VideoMode_Matches(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35909 PyObject *resultobj = 0;
35910 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35911 wxVideoMode *arg2 = 0 ;
35912 bool result;
35913 void *argp1 = 0 ;
35914 int res1 = 0 ;
35915 void *argp2 = 0 ;
35916 int res2 = 0 ;
35917 PyObject * obj0 = 0 ;
35918 PyObject * obj1 = 0 ;
35919 char * kwnames[] = {
35920 (char *) "self",(char *) "other", NULL
35921 };
35922
35923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) SWIG_fail;
35924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35925 if (!SWIG_IsOK(res1)) {
35926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_Matches" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
35927 }
35928 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35929 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
35930 if (!SWIG_IsOK(res2)) {
35931 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35932 }
35933 if (!argp2) {
35934 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35935 }
35936 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
35937 {
35938 PyThreadState* __tstate = wxPyBeginAllowThreads();
35939 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
35940 wxPyEndAllowThreads(__tstate);
35941 if (PyErr_Occurred()) SWIG_fail;
35942 }
35943 {
35944 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35945 }
35946 return resultobj;
35947 fail:
35948 return NULL;
35949 }
35950
35951
35952 SWIGINTERN PyObject *_wrap_VideoMode_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35953 PyObject *resultobj = 0;
35954 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35955 int result;
35956 void *argp1 = 0 ;
35957 int res1 = 0 ;
35958 PyObject *swig_obj[1] ;
35959
35960 if (!args) SWIG_fail;
35961 swig_obj[0] = args;
35962 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35963 if (!SWIG_IsOK(res1)) {
35964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetWidth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
35965 }
35966 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35967 {
35968 PyThreadState* __tstate = wxPyBeginAllowThreads();
35969 result = (int)((wxVideoMode const *)arg1)->GetWidth();
35970 wxPyEndAllowThreads(__tstate);
35971 if (PyErr_Occurred()) SWIG_fail;
35972 }
35973 resultobj = SWIG_From_int(static_cast< int >(result));
35974 return resultobj;
35975 fail:
35976 return NULL;
35977 }
35978
35979
35980 SWIGINTERN PyObject *_wrap_VideoMode_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35981 PyObject *resultobj = 0;
35982 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35983 int result;
35984 void *argp1 = 0 ;
35985 int res1 = 0 ;
35986 PyObject *swig_obj[1] ;
35987
35988 if (!args) SWIG_fail;
35989 swig_obj[0] = args;
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_GetHeight" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
35993 }
35994 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35995 {
35996 PyThreadState* __tstate = wxPyBeginAllowThreads();
35997 result = (int)((wxVideoMode const *)arg1)->GetHeight();
35998 wxPyEndAllowThreads(__tstate);
35999 if (PyErr_Occurred()) SWIG_fail;
36000 }
36001 resultobj = SWIG_From_int(static_cast< int >(result));
36002 return resultobj;
36003 fail:
36004 return NULL;
36005 }
36006
36007
36008 SWIGINTERN PyObject *_wrap_VideoMode_GetDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36009 PyObject *resultobj = 0;
36010 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36011 int result;
36012 void *argp1 = 0 ;
36013 int res1 = 0 ;
36014 PyObject *swig_obj[1] ;
36015
36016 if (!args) SWIG_fail;
36017 swig_obj[0] = args;
36018 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36019 if (!SWIG_IsOK(res1)) {
36020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetDepth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
36021 }
36022 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36023 {
36024 PyThreadState* __tstate = wxPyBeginAllowThreads();
36025 result = (int)((wxVideoMode const *)arg1)->GetDepth();
36026 wxPyEndAllowThreads(__tstate);
36027 if (PyErr_Occurred()) SWIG_fail;
36028 }
36029 resultobj = SWIG_From_int(static_cast< int >(result));
36030 return resultobj;
36031 fail:
36032 return NULL;
36033 }
36034
36035
36036 SWIGINTERN PyObject *_wrap_VideoMode_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36037 PyObject *resultobj = 0;
36038 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36039 bool result;
36040 void *argp1 = 0 ;
36041 int res1 = 0 ;
36042 PyObject *swig_obj[1] ;
36043
36044 if (!args) SWIG_fail;
36045 swig_obj[0] = args;
36046 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36047 if (!SWIG_IsOK(res1)) {
36048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_IsOk" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
36049 }
36050 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36051 {
36052 PyThreadState* __tstate = wxPyBeginAllowThreads();
36053 result = (bool)((wxVideoMode const *)arg1)->IsOk();
36054 wxPyEndAllowThreads(__tstate);
36055 if (PyErr_Occurred()) SWIG_fail;
36056 }
36057 {
36058 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36059 }
36060 return resultobj;
36061 fail:
36062 return NULL;
36063 }
36064
36065
36066 SWIGINTERN PyObject *_wrap_VideoMode___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36067 PyObject *resultobj = 0;
36068 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36069 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
36070 bool result;
36071 void *argp1 = 0 ;
36072 int res1 = 0 ;
36073 void *argp2 = 0 ;
36074 int res2 = 0 ;
36075 PyObject * obj0 = 0 ;
36076 PyObject * obj1 = 0 ;
36077 char * kwnames[] = {
36078 (char *) "self",(char *) "other", NULL
36079 };
36080
36081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
36082 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36083 if (!SWIG_IsOK(res1)) {
36084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___eq__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36085 }
36086 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36087 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36088 if (!SWIG_IsOK(res2)) {
36089 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___eq__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
36090 }
36091 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36092 {
36093 PyThreadState* __tstate = wxPyBeginAllowThreads();
36094 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
36095 wxPyEndAllowThreads(__tstate);
36096 if (PyErr_Occurred()) SWIG_fail;
36097 }
36098 {
36099 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36100 }
36101 return resultobj;
36102 fail:
36103 return NULL;
36104 }
36105
36106
36107 SWIGINTERN PyObject *_wrap_VideoMode___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36108 PyObject *resultobj = 0;
36109 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36110 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
36111 bool result;
36112 void *argp1 = 0 ;
36113 int res1 = 0 ;
36114 void *argp2 = 0 ;
36115 int res2 = 0 ;
36116 PyObject * obj0 = 0 ;
36117 PyObject * obj1 = 0 ;
36118 char * kwnames[] = {
36119 (char *) "self",(char *) "other", NULL
36120 };
36121
36122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
36123 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36124 if (!SWIG_IsOK(res1)) {
36125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___ne__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36126 }
36127 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36128 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36129 if (!SWIG_IsOK(res2)) {
36130 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___ne__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
36131 }
36132 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36133 {
36134 PyThreadState* __tstate = wxPyBeginAllowThreads();
36135 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
36136 wxPyEndAllowThreads(__tstate);
36137 if (PyErr_Occurred()) SWIG_fail;
36138 }
36139 {
36140 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36141 }
36142 return resultobj;
36143 fail:
36144 return NULL;
36145 }
36146
36147
36148 SWIGINTERN PyObject *_wrap_VideoMode_w_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36149 PyObject *resultobj = 0;
36150 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36151 int arg2 ;
36152 void *argp1 = 0 ;
36153 int res1 = 0 ;
36154 int val2 ;
36155 int ecode2 = 0 ;
36156 PyObject *swig_obj[2] ;
36157
36158 if (!SWIG_Python_UnpackTuple(args,"VideoMode_w_set",2,2,swig_obj)) SWIG_fail;
36159 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36160 if (!SWIG_IsOK(res1)) {
36161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36162 }
36163 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36164 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36165 if (!SWIG_IsOK(ecode2)) {
36166 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_w_set" "', expected argument " "2"" of type '" "int""'");
36167 }
36168 arg2 = static_cast< int >(val2);
36169 if (arg1) (arg1)->w = arg2;
36170
36171 resultobj = SWIG_Py_Void();
36172 return resultobj;
36173 fail:
36174 return NULL;
36175 }
36176
36177
36178 SWIGINTERN PyObject *_wrap_VideoMode_w_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36179 PyObject *resultobj = 0;
36180 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36181 int result;
36182 void *argp1 = 0 ;
36183 int res1 = 0 ;
36184 PyObject *swig_obj[1] ;
36185
36186 if (!args) SWIG_fail;
36187 swig_obj[0] = args;
36188 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36189 if (!SWIG_IsOK(res1)) {
36190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36191 }
36192 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36193 result = (int) ((arg1)->w);
36194 resultobj = SWIG_From_int(static_cast< int >(result));
36195 return resultobj;
36196 fail:
36197 return NULL;
36198 }
36199
36200
36201 SWIGINTERN PyObject *_wrap_VideoMode_h_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36202 PyObject *resultobj = 0;
36203 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36204 int arg2 ;
36205 void *argp1 = 0 ;
36206 int res1 = 0 ;
36207 int val2 ;
36208 int ecode2 = 0 ;
36209 PyObject *swig_obj[2] ;
36210
36211 if (!SWIG_Python_UnpackTuple(args,"VideoMode_h_set",2,2,swig_obj)) SWIG_fail;
36212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36213 if (!SWIG_IsOK(res1)) {
36214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36215 }
36216 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36217 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36218 if (!SWIG_IsOK(ecode2)) {
36219 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_h_set" "', expected argument " "2"" of type '" "int""'");
36220 }
36221 arg2 = static_cast< int >(val2);
36222 if (arg1) (arg1)->h = arg2;
36223
36224 resultobj = SWIG_Py_Void();
36225 return resultobj;
36226 fail:
36227 return NULL;
36228 }
36229
36230
36231 SWIGINTERN PyObject *_wrap_VideoMode_h_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36232 PyObject *resultobj = 0;
36233 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36234 int result;
36235 void *argp1 = 0 ;
36236 int res1 = 0 ;
36237 PyObject *swig_obj[1] ;
36238
36239 if (!args) SWIG_fail;
36240 swig_obj[0] = args;
36241 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36242 if (!SWIG_IsOK(res1)) {
36243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36244 }
36245 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36246 result = (int) ((arg1)->h);
36247 resultobj = SWIG_From_int(static_cast< int >(result));
36248 return resultobj;
36249 fail:
36250 return NULL;
36251 }
36252
36253
36254 SWIGINTERN PyObject *_wrap_VideoMode_bpp_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36255 PyObject *resultobj = 0;
36256 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36257 int arg2 ;
36258 void *argp1 = 0 ;
36259 int res1 = 0 ;
36260 int val2 ;
36261 int ecode2 = 0 ;
36262 PyObject *swig_obj[2] ;
36263
36264 if (!SWIG_Python_UnpackTuple(args,"VideoMode_bpp_set",2,2,swig_obj)) SWIG_fail;
36265 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36266 if (!SWIG_IsOK(res1)) {
36267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36268 }
36269 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36270 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36271 if (!SWIG_IsOK(ecode2)) {
36272 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_bpp_set" "', expected argument " "2"" of type '" "int""'");
36273 }
36274 arg2 = static_cast< int >(val2);
36275 if (arg1) (arg1)->bpp = arg2;
36276
36277 resultobj = SWIG_Py_Void();
36278 return resultobj;
36279 fail:
36280 return NULL;
36281 }
36282
36283
36284 SWIGINTERN PyObject *_wrap_VideoMode_bpp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36285 PyObject *resultobj = 0;
36286 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36287 int result;
36288 void *argp1 = 0 ;
36289 int res1 = 0 ;
36290 PyObject *swig_obj[1] ;
36291
36292 if (!args) SWIG_fail;
36293 swig_obj[0] = args;
36294 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36295 if (!SWIG_IsOK(res1)) {
36296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36297 }
36298 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36299 result = (int) ((arg1)->bpp);
36300 resultobj = SWIG_From_int(static_cast< int >(result));
36301 return resultobj;
36302 fail:
36303 return NULL;
36304 }
36305
36306
36307 SWIGINTERN PyObject *_wrap_VideoMode_refresh_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36308 PyObject *resultobj = 0;
36309 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36310 int arg2 ;
36311 void *argp1 = 0 ;
36312 int res1 = 0 ;
36313 int val2 ;
36314 int ecode2 = 0 ;
36315 PyObject *swig_obj[2] ;
36316
36317 if (!SWIG_Python_UnpackTuple(args,"VideoMode_refresh_set",2,2,swig_obj)) SWIG_fail;
36318 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36319 if (!SWIG_IsOK(res1)) {
36320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36321 }
36322 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36323 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36324 if (!SWIG_IsOK(ecode2)) {
36325 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_refresh_set" "', expected argument " "2"" of type '" "int""'");
36326 }
36327 arg2 = static_cast< int >(val2);
36328 if (arg1) (arg1)->refresh = arg2;
36329
36330 resultobj = SWIG_Py_Void();
36331 return resultobj;
36332 fail:
36333 return NULL;
36334 }
36335
36336
36337 SWIGINTERN PyObject *_wrap_VideoMode_refresh_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36338 PyObject *resultobj = 0;
36339 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36340 int result;
36341 void *argp1 = 0 ;
36342 int res1 = 0 ;
36343 PyObject *swig_obj[1] ;
36344
36345 if (!args) SWIG_fail;
36346 swig_obj[0] = args;
36347 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36348 if (!SWIG_IsOK(res1)) {
36349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36350 }
36351 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36352 result = (int) ((arg1)->refresh);
36353 resultobj = SWIG_From_int(static_cast< int >(result));
36354 return resultobj;
36355 fail:
36356 return NULL;
36357 }
36358
36359
36360 SWIGINTERN PyObject *VideoMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36361 PyObject *obj;
36362 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
36363 SWIG_TypeNewClientData(SWIGTYPE_p_wxVideoMode, SWIG_NewClientData(obj));
36364 return SWIG_Py_Void();
36365 }
36366
36367 SWIGINTERN PyObject *VideoMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36368 return SWIG_Python_InitShadowInstance(args);
36369 }
36370
36371 SWIGINTERN int DefaultVideoMode_set(PyObject *) {
36372 SWIG_Error(SWIG_AttributeError,"Variable DefaultVideoMode is read-only.");
36373 return 1;
36374 }
36375
36376
36377 SWIGINTERN PyObject *DefaultVideoMode_get(void) {
36378 PyObject *pyobj = 0;
36379
36380 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0 );
36381 return pyobj;
36382 }
36383
36384
36385 SWIGINTERN PyObject *_wrap_new_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36386 PyObject *resultobj = 0;
36387 unsigned int arg1 = (unsigned int) 0 ;
36388 wxDisplay *result = 0 ;
36389 unsigned int val1 ;
36390 int ecode1 = 0 ;
36391 PyObject * obj0 = 0 ;
36392 char * kwnames[] = {
36393 (char *) "index", NULL
36394 };
36395
36396 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) SWIG_fail;
36397 if (obj0) {
36398 ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
36399 if (!SWIG_IsOK(ecode1)) {
36400 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Display" "', expected argument " "1"" of type '" "unsigned int""'");
36401 }
36402 arg1 = static_cast< unsigned int >(val1);
36403 }
36404 {
36405 PyThreadState* __tstate = wxPyBeginAllowThreads();
36406 result = (wxDisplay *)new wxDisplay(arg1);
36407 wxPyEndAllowThreads(__tstate);
36408 if (PyErr_Occurred()) SWIG_fail;
36409 }
36410 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplay, SWIG_POINTER_NEW | 0 );
36411 return resultobj;
36412 fail:
36413 return NULL;
36414 }
36415
36416
36417 SWIGINTERN PyObject *_wrap_delete_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36418 PyObject *resultobj = 0;
36419 wxDisplay *arg1 = (wxDisplay *) 0 ;
36420 void *argp1 = 0 ;
36421 int res1 = 0 ;
36422 PyObject *swig_obj[1] ;
36423
36424 if (!args) SWIG_fail;
36425 swig_obj[0] = args;
36426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, SWIG_POINTER_DISOWN | 0 );
36427 if (!SWIG_IsOK(res1)) {
36428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Display" "', expected argument " "1"" of type '" "wxDisplay *""'");
36429 }
36430 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36431 {
36432 PyThreadState* __tstate = wxPyBeginAllowThreads();
36433 delete arg1;
36434
36435 wxPyEndAllowThreads(__tstate);
36436 if (PyErr_Occurred()) SWIG_fail;
36437 }
36438 resultobj = SWIG_Py_Void();
36439 return resultobj;
36440 fail:
36441 return NULL;
36442 }
36443
36444
36445 SWIGINTERN PyObject *_wrap_Display_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36446 PyObject *resultobj = 0;
36447 unsigned int result;
36448
36449 if (!SWIG_Python_UnpackTuple(args,"Display_GetCount",0,0,0)) SWIG_fail;
36450 {
36451 PyThreadState* __tstate = wxPyBeginAllowThreads();
36452 result = (unsigned int)wxDisplay::GetCount();
36453 wxPyEndAllowThreads(__tstate);
36454 if (PyErr_Occurred()) SWIG_fail;
36455 }
36456 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
36457 return resultobj;
36458 fail:
36459 return NULL;
36460 }
36461
36462
36463 SWIGINTERN PyObject *_wrap_Display_GetFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36464 PyObject *resultobj = 0;
36465 wxPoint *arg1 = 0 ;
36466 int result;
36467 wxPoint temp1 ;
36468 PyObject * obj0 = 0 ;
36469 char * kwnames[] = {
36470 (char *) "pt", NULL
36471 };
36472
36473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) SWIG_fail;
36474 {
36475 arg1 = &temp1;
36476 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
36477 }
36478 {
36479 PyThreadState* __tstate = wxPyBeginAllowThreads();
36480 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
36481 wxPyEndAllowThreads(__tstate);
36482 if (PyErr_Occurred()) SWIG_fail;
36483 }
36484 resultobj = SWIG_From_int(static_cast< int >(result));
36485 return resultobj;
36486 fail:
36487 return NULL;
36488 }
36489
36490
36491 SWIGINTERN PyObject *_wrap_Display_GetFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36492 PyObject *resultobj = 0;
36493 wxWindow *arg1 = (wxWindow *) 0 ;
36494 int result;
36495 void *argp1 = 0 ;
36496 int res1 = 0 ;
36497 PyObject * obj0 = 0 ;
36498 char * kwnames[] = {
36499 (char *) "window", NULL
36500 };
36501
36502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) SWIG_fail;
36503 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36504 if (!SWIG_IsOK(res1)) {
36505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36506 }
36507 arg1 = reinterpret_cast< wxWindow * >(argp1);
36508 {
36509 PyThreadState* __tstate = wxPyBeginAllowThreads();
36510 result = (int)wxDisplay::GetFromWindow(arg1);
36511 wxPyEndAllowThreads(__tstate);
36512 if (PyErr_Occurred()) SWIG_fail;
36513 }
36514 resultobj = SWIG_From_int(static_cast< int >(result));
36515 return resultobj;
36516 fail:
36517 return NULL;
36518 }
36519
36520
36521 SWIGINTERN PyObject *_wrap_Display_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36522 PyObject *resultobj = 0;
36523 wxDisplay *arg1 = (wxDisplay *) 0 ;
36524 bool result;
36525 void *argp1 = 0 ;
36526 int res1 = 0 ;
36527 PyObject *swig_obj[1] ;
36528
36529 if (!args) SWIG_fail;
36530 swig_obj[0] = args;
36531 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36532 if (!SWIG_IsOK(res1)) {
36533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsOk" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36534 }
36535 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36536 {
36537 PyThreadState* __tstate = wxPyBeginAllowThreads();
36538 result = (bool)((wxDisplay const *)arg1)->IsOk();
36539 wxPyEndAllowThreads(__tstate);
36540 if (PyErr_Occurred()) SWIG_fail;
36541 }
36542 {
36543 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36544 }
36545 return resultobj;
36546 fail:
36547 return NULL;
36548 }
36549
36550
36551 SWIGINTERN PyObject *_wrap_Display_GetGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36552 PyObject *resultobj = 0;
36553 wxDisplay *arg1 = (wxDisplay *) 0 ;
36554 wxRect result;
36555 void *argp1 = 0 ;
36556 int res1 = 0 ;
36557 PyObject *swig_obj[1] ;
36558
36559 if (!args) SWIG_fail;
36560 swig_obj[0] = args;
36561 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36562 if (!SWIG_IsOK(res1)) {
36563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetGeometry" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36564 }
36565 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36566 {
36567 PyThreadState* __tstate = wxPyBeginAllowThreads();
36568 result = ((wxDisplay const *)arg1)->GetGeometry();
36569 wxPyEndAllowThreads(__tstate);
36570 if (PyErr_Occurred()) SWIG_fail;
36571 }
36572 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
36573 return resultobj;
36574 fail:
36575 return NULL;
36576 }
36577
36578
36579 SWIGINTERN PyObject *_wrap_Display_GetClientArea(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36580 PyObject *resultobj = 0;
36581 wxDisplay *arg1 = (wxDisplay *) 0 ;
36582 wxRect result;
36583 void *argp1 = 0 ;
36584 int res1 = 0 ;
36585 PyObject *swig_obj[1] ;
36586
36587 if (!args) SWIG_fail;
36588 swig_obj[0] = args;
36589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36590 if (!SWIG_IsOK(res1)) {
36591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetClientArea" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36592 }
36593 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36594 {
36595 PyThreadState* __tstate = wxPyBeginAllowThreads();
36596 result = ((wxDisplay const *)arg1)->GetClientArea();
36597 wxPyEndAllowThreads(__tstate);
36598 if (PyErr_Occurred()) SWIG_fail;
36599 }
36600 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
36601 return resultobj;
36602 fail:
36603 return NULL;
36604 }
36605
36606
36607 SWIGINTERN PyObject *_wrap_Display_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36608 PyObject *resultobj = 0;
36609 wxDisplay *arg1 = (wxDisplay *) 0 ;
36610 wxString result;
36611 void *argp1 = 0 ;
36612 int res1 = 0 ;
36613 PyObject *swig_obj[1] ;
36614
36615 if (!args) SWIG_fail;
36616 swig_obj[0] = args;
36617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36618 if (!SWIG_IsOK(res1)) {
36619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetName" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36620 }
36621 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36622 {
36623 PyThreadState* __tstate = wxPyBeginAllowThreads();
36624 result = ((wxDisplay const *)arg1)->GetName();
36625 wxPyEndAllowThreads(__tstate);
36626 if (PyErr_Occurred()) SWIG_fail;
36627 }
36628 {
36629 #if wxUSE_UNICODE
36630 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36631 #else
36632 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36633 #endif
36634 }
36635 return resultobj;
36636 fail:
36637 return NULL;
36638 }
36639
36640
36641 SWIGINTERN PyObject *_wrap_Display_IsPrimary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36642 PyObject *resultobj = 0;
36643 wxDisplay *arg1 = (wxDisplay *) 0 ;
36644 bool result;
36645 void *argp1 = 0 ;
36646 int res1 = 0 ;
36647 PyObject *swig_obj[1] ;
36648
36649 if (!args) SWIG_fail;
36650 swig_obj[0] = args;
36651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36652 if (!SWIG_IsOK(res1)) {
36653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsPrimary" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36654 }
36655 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36656 {
36657 PyThreadState* __tstate = wxPyBeginAllowThreads();
36658 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
36659 wxPyEndAllowThreads(__tstate);
36660 if (PyErr_Occurred()) SWIG_fail;
36661 }
36662 {
36663 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36664 }
36665 return resultobj;
36666 fail:
36667 return NULL;
36668 }
36669
36670
36671 SWIGINTERN PyObject *_wrap_Display_GetModes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36672 PyObject *resultobj = 0;
36673 wxDisplay *arg1 = (wxDisplay *) 0 ;
36674 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
36675 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
36676 PyObject *result = 0 ;
36677 void *argp1 = 0 ;
36678 int res1 = 0 ;
36679 void *argp2 = 0 ;
36680 int res2 = 0 ;
36681 PyObject * obj0 = 0 ;
36682 PyObject * obj1 = 0 ;
36683 char * kwnames[] = {
36684 (char *) "self",(char *) "mode", NULL
36685 };
36686
36687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) SWIG_fail;
36688 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36689 if (!SWIG_IsOK(res1)) {
36690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetModes" "', expected argument " "1"" of type '" "wxDisplay *""'");
36691 }
36692 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36693 if (obj1) {
36694 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
36695 if (!SWIG_IsOK(res2)) {
36696 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36697 }
36698 if (!argp2) {
36699 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36700 }
36701 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36702 }
36703 {
36704 PyThreadState* __tstate = wxPyBeginAllowThreads();
36705 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
36706 wxPyEndAllowThreads(__tstate);
36707 if (PyErr_Occurred()) SWIG_fail;
36708 }
36709 resultobj = result;
36710 return resultobj;
36711 fail:
36712 return NULL;
36713 }
36714
36715
36716 SWIGINTERN PyObject *_wrap_Display_GetCurrentMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36717 PyObject *resultobj = 0;
36718 wxDisplay *arg1 = (wxDisplay *) 0 ;
36719 wxVideoMode result;
36720 void *argp1 = 0 ;
36721 int res1 = 0 ;
36722 PyObject *swig_obj[1] ;
36723
36724 if (!args) SWIG_fail;
36725 swig_obj[0] = args;
36726 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36727 if (!SWIG_IsOK(res1)) {
36728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetCurrentMode" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36729 }
36730 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36731 {
36732 PyThreadState* __tstate = wxPyBeginAllowThreads();
36733 result = wxDisplay_GetCurrentMode((wxDisplay const *)arg1);
36734 wxPyEndAllowThreads(__tstate);
36735 if (PyErr_Occurred()) SWIG_fail;
36736 }
36737 resultobj = SWIG_NewPointerObj((new wxVideoMode(static_cast< const wxVideoMode& >(result))), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_OWN | 0 );
36738 return resultobj;
36739 fail:
36740 return NULL;
36741 }
36742
36743
36744 SWIGINTERN PyObject *_wrap_Display_ChangeMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36745 PyObject *resultobj = 0;
36746 wxDisplay *arg1 = (wxDisplay *) 0 ;
36747 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
36748 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
36749 bool result;
36750 void *argp1 = 0 ;
36751 int res1 = 0 ;
36752 void *argp2 = 0 ;
36753 int res2 = 0 ;
36754 PyObject * obj0 = 0 ;
36755 PyObject * obj1 = 0 ;
36756 char * kwnames[] = {
36757 (char *) "self",(char *) "mode", NULL
36758 };
36759
36760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) SWIG_fail;
36761 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36762 if (!SWIG_IsOK(res1)) {
36763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ChangeMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
36764 }
36765 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36766 if (obj1) {
36767 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
36768 if (!SWIG_IsOK(res2)) {
36769 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36770 }
36771 if (!argp2) {
36772 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36773 }
36774 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36775 }
36776 {
36777 PyThreadState* __tstate = wxPyBeginAllowThreads();
36778 result = (bool)wxDisplay_ChangeMode(arg1,(wxVideoMode const &)*arg2);
36779 wxPyEndAllowThreads(__tstate);
36780 if (PyErr_Occurred()) SWIG_fail;
36781 }
36782 {
36783 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36784 }
36785 return resultobj;
36786 fail:
36787 return NULL;
36788 }
36789
36790
36791 SWIGINTERN PyObject *_wrap_Display_ResetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36792 PyObject *resultobj = 0;
36793 wxDisplay *arg1 = (wxDisplay *) 0 ;
36794 void *argp1 = 0 ;
36795 int res1 = 0 ;
36796 PyObject *swig_obj[1] ;
36797
36798 if (!args) SWIG_fail;
36799 swig_obj[0] = args;
36800 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36801 if (!SWIG_IsOK(res1)) {
36802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ResetMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
36803 }
36804 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36805 {
36806 PyThreadState* __tstate = wxPyBeginAllowThreads();
36807 wxDisplay_ResetMode(arg1);
36808 wxPyEndAllowThreads(__tstate);
36809 if (PyErr_Occurred()) SWIG_fail;
36810 }
36811 resultobj = SWIG_Py_Void();
36812 return resultobj;
36813 fail:
36814 return NULL;
36815 }
36816
36817
36818 SWIGINTERN PyObject *Display_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36819 PyObject *obj;
36820 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
36821 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplay, SWIG_NewClientData(obj));
36822 return SWIG_Py_Void();
36823 }
36824
36825 SWIGINTERN PyObject *Display_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36826 return SWIG_Python_InitShadowInstance(args);
36827 }
36828
36829 SWIGINTERN PyObject *_wrap_StandardPaths_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36830 PyObject *resultobj = 0;
36831 wxStandardPaths *result = 0 ;
36832
36833 if (!SWIG_Python_UnpackTuple(args,"StandardPaths_Get",0,0,0)) SWIG_fail;
36834 {
36835 PyThreadState* __tstate = wxPyBeginAllowThreads();
36836 result = (wxStandardPaths *)wxStandardPaths_Get();
36837 wxPyEndAllowThreads(__tstate);
36838 if (PyErr_Occurred()) SWIG_fail;
36839 }
36840 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36841 return resultobj;
36842 fail:
36843 return NULL;
36844 }
36845
36846
36847 SWIGINTERN PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36848 PyObject *resultobj = 0;
36849 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36850 wxString result;
36851 void *argp1 = 0 ;
36852 int res1 = 0 ;
36853 PyObject *swig_obj[1] ;
36854
36855 if (!args) SWIG_fail;
36856 swig_obj[0] = args;
36857 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36858 if (!SWIG_IsOK(res1)) {
36859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36860 }
36861 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36862 {
36863 PyThreadState* __tstate = wxPyBeginAllowThreads();
36864 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
36865 wxPyEndAllowThreads(__tstate);
36866 if (PyErr_Occurred()) SWIG_fail;
36867 }
36868 {
36869 #if wxUSE_UNICODE
36870 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36871 #else
36872 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36873 #endif
36874 }
36875 return resultobj;
36876 fail:
36877 return NULL;
36878 }
36879
36880
36881 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36882 PyObject *resultobj = 0;
36883 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36884 wxString result;
36885 void *argp1 = 0 ;
36886 int res1 = 0 ;
36887 PyObject *swig_obj[1] ;
36888
36889 if (!args) SWIG_fail;
36890 swig_obj[0] = args;
36891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36892 if (!SWIG_IsOK(res1)) {
36893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36894 }
36895 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36896 {
36897 PyThreadState* __tstate = wxPyBeginAllowThreads();
36898 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
36899 wxPyEndAllowThreads(__tstate);
36900 if (PyErr_Occurred()) SWIG_fail;
36901 }
36902 {
36903 #if wxUSE_UNICODE
36904 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36905 #else
36906 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36907 #endif
36908 }
36909 return resultobj;
36910 fail:
36911 return NULL;
36912 }
36913
36914
36915 SWIGINTERN PyObject *_wrap_StandardPaths_GetDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36916 PyObject *resultobj = 0;
36917 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36918 wxString result;
36919 void *argp1 = 0 ;
36920 int res1 = 0 ;
36921 PyObject *swig_obj[1] ;
36922
36923 if (!args) SWIG_fail;
36924 swig_obj[0] = args;
36925 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36926 if (!SWIG_IsOK(res1)) {
36927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36928 }
36929 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36930 {
36931 PyThreadState* __tstate = wxPyBeginAllowThreads();
36932 result = ((wxStandardPaths const *)arg1)->GetDataDir();
36933 wxPyEndAllowThreads(__tstate);
36934 if (PyErr_Occurred()) SWIG_fail;
36935 }
36936 {
36937 #if wxUSE_UNICODE
36938 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36939 #else
36940 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36941 #endif
36942 }
36943 return resultobj;
36944 fail:
36945 return NULL;
36946 }
36947
36948
36949 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36950 PyObject *resultobj = 0;
36951 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36952 wxString result;
36953 void *argp1 = 0 ;
36954 int res1 = 0 ;
36955 PyObject *swig_obj[1] ;
36956
36957 if (!args) SWIG_fail;
36958 swig_obj[0] = args;
36959 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36960 if (!SWIG_IsOK(res1)) {
36961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36962 }
36963 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36964 {
36965 PyThreadState* __tstate = wxPyBeginAllowThreads();
36966 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
36967 wxPyEndAllowThreads(__tstate);
36968 if (PyErr_Occurred()) SWIG_fail;
36969 }
36970 {
36971 #if wxUSE_UNICODE
36972 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36973 #else
36974 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36975 #endif
36976 }
36977 return resultobj;
36978 fail:
36979 return NULL;
36980 }
36981
36982
36983 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36984 PyObject *resultobj = 0;
36985 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36986 wxString result;
36987 void *argp1 = 0 ;
36988 int res1 = 0 ;
36989 PyObject *swig_obj[1] ;
36990
36991 if (!args) SWIG_fail;
36992 swig_obj[0] = args;
36993 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36994 if (!SWIG_IsOK(res1)) {
36995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36996 }
36997 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36998 {
36999 PyThreadState* __tstate = wxPyBeginAllowThreads();
37000 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
37001 wxPyEndAllowThreads(__tstate);
37002 if (PyErr_Occurred()) SWIG_fail;
37003 }
37004 {
37005 #if wxUSE_UNICODE
37006 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37007 #else
37008 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37009 #endif
37010 }
37011 return resultobj;
37012 fail:
37013 return NULL;
37014 }
37015
37016
37017 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37018 PyObject *resultobj = 0;
37019 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37020 wxString result;
37021 void *argp1 = 0 ;
37022 int res1 = 0 ;
37023 PyObject *swig_obj[1] ;
37024
37025 if (!args) SWIG_fail;
37026 swig_obj[0] = args;
37027 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37028 if (!SWIG_IsOK(res1)) {
37029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37030 }
37031 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37032 {
37033 PyThreadState* __tstate = wxPyBeginAllowThreads();
37034 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
37035 wxPyEndAllowThreads(__tstate);
37036 if (PyErr_Occurred()) SWIG_fail;
37037 }
37038 {
37039 #if wxUSE_UNICODE
37040 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37041 #else
37042 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37043 #endif
37044 }
37045 return resultobj;
37046 fail:
37047 return NULL;
37048 }
37049
37050
37051 SWIGINTERN PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37052 PyObject *resultobj = 0;
37053 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37054 wxString result;
37055 void *argp1 = 0 ;
37056 int res1 = 0 ;
37057 PyObject *swig_obj[1] ;
37058
37059 if (!args) SWIG_fail;
37060 swig_obj[0] = args;
37061 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37062 if (!SWIG_IsOK(res1)) {
37063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetPluginsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37064 }
37065 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37066 {
37067 PyThreadState* __tstate = wxPyBeginAllowThreads();
37068 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
37069 wxPyEndAllowThreads(__tstate);
37070 if (PyErr_Occurred()) SWIG_fail;
37071 }
37072 {
37073 #if wxUSE_UNICODE
37074 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37075 #else
37076 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37077 #endif
37078 }
37079 return resultobj;
37080 fail:
37081 return NULL;
37082 }
37083
37084
37085 SWIGINTERN PyObject *_wrap_StandardPaths_GetResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37086 PyObject *resultobj = 0;
37087 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37088 wxString result;
37089 void *argp1 = 0 ;
37090 int res1 = 0 ;
37091 PyObject *swig_obj[1] ;
37092
37093 if (!args) SWIG_fail;
37094 swig_obj[0] = args;
37095 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37096 if (!SWIG_IsOK(res1)) {
37097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37098 }
37099 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37100 {
37101 PyThreadState* __tstate = wxPyBeginAllowThreads();
37102 result = ((wxStandardPaths const *)arg1)->GetResourcesDir();
37103 wxPyEndAllowThreads(__tstate);
37104 if (PyErr_Occurred()) SWIG_fail;
37105 }
37106 {
37107 #if wxUSE_UNICODE
37108 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37109 #else
37110 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37111 #endif
37112 }
37113 return resultobj;
37114 fail:
37115 return NULL;
37116 }
37117
37118
37119 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalizedResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37120 PyObject *resultobj = 0;
37121 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37122 wxString *arg2 = 0 ;
37123 wxStandardPaths::ResourceCat arg3 = (wxStandardPaths::ResourceCat) wxStandardPaths::ResourceCat_None ;
37124 wxString result;
37125 void *argp1 = 0 ;
37126 int res1 = 0 ;
37127 bool temp2 = false ;
37128 int val3 ;
37129 int ecode3 = 0 ;
37130 PyObject * obj0 = 0 ;
37131 PyObject * obj1 = 0 ;
37132 PyObject * obj2 = 0 ;
37133 char * kwnames[] = {
37134 (char *) "self",(char *) "lang",(char *) "category", NULL
37135 };
37136
37137 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:StandardPaths_GetLocalizedResourcesDir",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37138 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37139 if (!SWIG_IsOK(res1)) {
37140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37141 }
37142 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37143 {
37144 arg2 = wxString_in_helper(obj1);
37145 if (arg2 == NULL) SWIG_fail;
37146 temp2 = true;
37147 }
37148 if (obj2) {
37149 ecode3 = SWIG_AsVal_int(obj2, &val3);
37150 if (!SWIG_IsOK(ecode3)) {
37151 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "3"" of type '" "wxStandardPaths::ResourceCat""'");
37152 }
37153 arg3 = static_cast< wxStandardPaths::ResourceCat >(val3);
37154 }
37155 {
37156 PyThreadState* __tstate = wxPyBeginAllowThreads();
37157 result = ((wxStandardPaths const *)arg1)->GetLocalizedResourcesDir((wxString const &)*arg2,arg3);
37158 wxPyEndAllowThreads(__tstate);
37159 if (PyErr_Occurred()) SWIG_fail;
37160 }
37161 {
37162 #if wxUSE_UNICODE
37163 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37164 #else
37165 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37166 #endif
37167 }
37168 {
37169 if (temp2)
37170 delete arg2;
37171 }
37172 return resultobj;
37173 fail:
37174 {
37175 if (temp2)
37176 delete arg2;
37177 }
37178 return NULL;
37179 }
37180
37181
37182 SWIGINTERN PyObject *_wrap_StandardPaths_GetDocumentsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37183 PyObject *resultobj = 0;
37184 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37185 wxString result;
37186 void *argp1 = 0 ;
37187 int res1 = 0 ;
37188 PyObject *swig_obj[1] ;
37189
37190 if (!args) SWIG_fail;
37191 swig_obj[0] = args;
37192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37193 if (!SWIG_IsOK(res1)) {
37194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDocumentsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37195 }
37196 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37197 {
37198 PyThreadState* __tstate = wxPyBeginAllowThreads();
37199 result = ((wxStandardPaths const *)arg1)->GetDocumentsDir();
37200 wxPyEndAllowThreads(__tstate);
37201 if (PyErr_Occurred()) SWIG_fail;
37202 }
37203 {
37204 #if wxUSE_UNICODE
37205 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37206 #else
37207 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37208 #endif
37209 }
37210 return resultobj;
37211 fail:
37212 return NULL;
37213 }
37214
37215
37216 SWIGINTERN PyObject *_wrap_StandardPaths_GetTempDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37217 PyObject *resultobj = 0;
37218 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37219 wxString result;
37220 void *argp1 = 0 ;
37221 int res1 = 0 ;
37222 PyObject *swig_obj[1] ;
37223
37224 if (!args) SWIG_fail;
37225 swig_obj[0] = args;
37226 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37227 if (!SWIG_IsOK(res1)) {
37228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetTempDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37229 }
37230 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37231 {
37232 PyThreadState* __tstate = wxPyBeginAllowThreads();
37233 result = ((wxStandardPaths const *)arg1)->GetTempDir();
37234 wxPyEndAllowThreads(__tstate);
37235 if (PyErr_Occurred()) SWIG_fail;
37236 }
37237 {
37238 #if wxUSE_UNICODE
37239 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37240 #else
37241 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37242 #endif
37243 }
37244 return resultobj;
37245 fail:
37246 return NULL;
37247 }
37248
37249
37250 SWIGINTERN PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37251 PyObject *resultobj = 0;
37252 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37253 wxString *arg2 = 0 ;
37254 void *argp1 = 0 ;
37255 int res1 = 0 ;
37256 bool temp2 = false ;
37257 PyObject * obj0 = 0 ;
37258 PyObject * obj1 = 0 ;
37259 char * kwnames[] = {
37260 (char *) "self",(char *) "prefix", NULL
37261 };
37262
37263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) SWIG_fail;
37264 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37265 if (!SWIG_IsOK(res1)) {
37266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_SetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths *""'");
37267 }
37268 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37269 {
37270 arg2 = wxString_in_helper(obj1);
37271 if (arg2 == NULL) SWIG_fail;
37272 temp2 = true;
37273 }
37274 {
37275 PyThreadState* __tstate = wxPyBeginAllowThreads();
37276 wxStandardPaths_SetInstallPrefix(arg1,(wxString const &)*arg2);
37277 wxPyEndAllowThreads(__tstate);
37278 if (PyErr_Occurred()) SWIG_fail;
37279 }
37280 resultobj = SWIG_Py_Void();
37281 {
37282 if (temp2)
37283 delete arg2;
37284 }
37285 return resultobj;
37286 fail:
37287 {
37288 if (temp2)
37289 delete arg2;
37290 }
37291 return NULL;
37292 }
37293
37294
37295 SWIGINTERN PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37296 PyObject *resultobj = 0;
37297 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37298 wxString result;
37299 void *argp1 = 0 ;
37300 int res1 = 0 ;
37301 PyObject *swig_obj[1] ;
37302
37303 if (!args) SWIG_fail;
37304 swig_obj[0] = args;
37305 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37306 if (!SWIG_IsOK(res1)) {
37307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths *""'");
37308 }
37309 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37310 {
37311 PyThreadState* __tstate = wxPyBeginAllowThreads();
37312 result = wxStandardPaths_GetInstallPrefix(arg1);
37313 wxPyEndAllowThreads(__tstate);
37314 if (PyErr_Occurred()) SWIG_fail;
37315 }
37316 {
37317 #if wxUSE_UNICODE
37318 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37319 #else
37320 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37321 #endif
37322 }
37323 return resultobj;
37324 fail:
37325 return NULL;
37326 }
37327
37328
37329 SWIGINTERN PyObject *StandardPaths_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37330 PyObject *obj;
37331 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37332 SWIG_TypeNewClientData(SWIGTYPE_p_wxStandardPaths, SWIG_NewClientData(obj));
37333 return SWIG_Py_Void();
37334 }
37335
37336 SWIGINTERN PyObject *_wrap_new_PowerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37337 PyObject *resultobj = 0;
37338 wxEventType arg1 ;
37339 wxPowerEvent *result = 0 ;
37340 int val1 ;
37341 int ecode1 = 0 ;
37342 PyObject * obj0 = 0 ;
37343 char * kwnames[] = {
37344 (char *) "evtType", NULL
37345 };
37346
37347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PowerEvent",kwnames,&obj0)) SWIG_fail;
37348 ecode1 = SWIG_AsVal_int(obj0, &val1);
37349 if (!SWIG_IsOK(ecode1)) {
37350 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PowerEvent" "', expected argument " "1"" of type '" "wxEventType""'");
37351 }
37352 arg1 = static_cast< wxEventType >(val1);
37353 {
37354 PyThreadState* __tstate = wxPyBeginAllowThreads();
37355 result = (wxPowerEvent *)new wxPowerEvent(arg1);
37356 wxPyEndAllowThreads(__tstate);
37357 if (PyErr_Occurred()) SWIG_fail;
37358 }
37359 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPowerEvent, SWIG_POINTER_NEW | 0 );
37360 return resultobj;
37361 fail:
37362 return NULL;
37363 }
37364
37365
37366 SWIGINTERN PyObject *_wrap_PowerEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37367 PyObject *resultobj = 0;
37368 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
37369 void *argp1 = 0 ;
37370 int res1 = 0 ;
37371 PyObject *swig_obj[1] ;
37372
37373 if (!args) SWIG_fail;
37374 swig_obj[0] = args;
37375 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPowerEvent, 0 | 0 );
37376 if (!SWIG_IsOK(res1)) {
37377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_Veto" "', expected argument " "1"" of type '" "wxPowerEvent *""'");
37378 }
37379 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
37380 {
37381 PyThreadState* __tstate = wxPyBeginAllowThreads();
37382 (arg1)->Veto();
37383 wxPyEndAllowThreads(__tstate);
37384 if (PyErr_Occurred()) SWIG_fail;
37385 }
37386 resultobj = SWIG_Py_Void();
37387 return resultobj;
37388 fail:
37389 return NULL;
37390 }
37391
37392
37393 SWIGINTERN PyObject *_wrap_PowerEvent_IsVetoed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37394 PyObject *resultobj = 0;
37395 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
37396 bool result;
37397 void *argp1 = 0 ;
37398 int res1 = 0 ;
37399 PyObject *swig_obj[1] ;
37400
37401 if (!args) SWIG_fail;
37402 swig_obj[0] = args;
37403 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPowerEvent, 0 | 0 );
37404 if (!SWIG_IsOK(res1)) {
37405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_IsVetoed" "', expected argument " "1"" of type '" "wxPowerEvent const *""'");
37406 }
37407 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
37408 {
37409 PyThreadState* __tstate = wxPyBeginAllowThreads();
37410 result = (bool)((wxPowerEvent const *)arg1)->IsVetoed();
37411 wxPyEndAllowThreads(__tstate);
37412 if (PyErr_Occurred()) SWIG_fail;
37413 }
37414 {
37415 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37416 }
37417 return resultobj;
37418 fail:
37419 return NULL;
37420 }
37421
37422
37423 SWIGINTERN PyObject *PowerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37424 PyObject *obj;
37425 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37426 SWIG_TypeNewClientData(SWIGTYPE_p_wxPowerEvent, SWIG_NewClientData(obj));
37427 return SWIG_Py_Void();
37428 }
37429
37430 SWIGINTERN PyObject *PowerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37431 return SWIG_Python_InitShadowInstance(args);
37432 }
37433
37434 SWIGINTERN PyObject *_wrap_GetPowerType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37435 PyObject *resultobj = 0;
37436 wxPowerType result;
37437
37438 if (!SWIG_Python_UnpackTuple(args,"GetPowerType",0,0,0)) SWIG_fail;
37439 {
37440 PyThreadState* __tstate = wxPyBeginAllowThreads();
37441 result = (wxPowerType)wxGetPowerType();
37442 wxPyEndAllowThreads(__tstate);
37443 if (PyErr_Occurred()) SWIG_fail;
37444 }
37445 resultobj = SWIG_From_int(static_cast< int >(result));
37446 return resultobj;
37447 fail:
37448 return NULL;
37449 }
37450
37451
37452 SWIGINTERN PyObject *_wrap_GetBatteryState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37453 PyObject *resultobj = 0;
37454 wxBatteryState result;
37455
37456 if (!SWIG_Python_UnpackTuple(args,"GetBatteryState",0,0,0)) SWIG_fail;
37457 {
37458 PyThreadState* __tstate = wxPyBeginAllowThreads();
37459 result = (wxBatteryState)wxGetBatteryState();
37460 wxPyEndAllowThreads(__tstate);
37461 if (PyErr_Occurred()) SWIG_fail;
37462 }
37463 resultobj = SWIG_From_int(static_cast< int >(result));
37464 return resultobj;
37465 fail:
37466 return NULL;
37467 }
37468
37469
37470 SWIGINTERN PyObject *_wrap_new_AboutDialogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37471 PyObject *resultobj = 0;
37472 wxAboutDialogInfo *result = 0 ;
37473
37474 if (!SWIG_Python_UnpackTuple(args,"new_AboutDialogInfo",0,0,0)) SWIG_fail;
37475 {
37476 PyThreadState* __tstate = wxPyBeginAllowThreads();
37477 result = (wxAboutDialogInfo *)new wxAboutDialogInfo();
37478 wxPyEndAllowThreads(__tstate);
37479 if (PyErr_Occurred()) SWIG_fail;
37480 }
37481 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAboutDialogInfo, SWIG_POINTER_NEW | 0 );
37482 return resultobj;
37483 fail:
37484 return NULL;
37485 }
37486
37487
37488 SWIGINTERN PyObject *_wrap_delete_AboutDialogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37489 PyObject *resultobj = 0;
37490 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37491 void *argp1 = 0 ;
37492 int res1 = 0 ;
37493 PyObject *swig_obj[1] ;
37494
37495 if (!args) SWIG_fail;
37496 swig_obj[0] = args;
37497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, SWIG_POINTER_DISOWN | 0 );
37498 if (!SWIG_IsOK(res1)) {
37499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AboutDialogInfo" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37500 }
37501 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37502 {
37503 PyThreadState* __tstate = wxPyBeginAllowThreads();
37504 delete arg1;
37505
37506 wxPyEndAllowThreads(__tstate);
37507 if (PyErr_Occurred()) SWIG_fail;
37508 }
37509 resultobj = SWIG_Py_Void();
37510 return resultobj;
37511 fail:
37512 return NULL;
37513 }
37514
37515
37516 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37517 PyObject *resultobj = 0;
37518 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37519 wxString *arg2 = 0 ;
37520 void *argp1 = 0 ;
37521 int res1 = 0 ;
37522 bool temp2 = false ;
37523 PyObject * obj0 = 0 ;
37524 PyObject * obj1 = 0 ;
37525 char * kwnames[] = {
37526 (char *) "self",(char *) "name", NULL
37527 };
37528
37529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
37530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37531 if (!SWIG_IsOK(res1)) {
37532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetName" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37533 }
37534 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37535 {
37536 arg2 = wxString_in_helper(obj1);
37537 if (arg2 == NULL) SWIG_fail;
37538 temp2 = true;
37539 }
37540 {
37541 PyThreadState* __tstate = wxPyBeginAllowThreads();
37542 (arg1)->SetName((wxString const &)*arg2);
37543 wxPyEndAllowThreads(__tstate);
37544 if (PyErr_Occurred()) SWIG_fail;
37545 }
37546 resultobj = SWIG_Py_Void();
37547 {
37548 if (temp2)
37549 delete arg2;
37550 }
37551 return resultobj;
37552 fail:
37553 {
37554 if (temp2)
37555 delete arg2;
37556 }
37557 return NULL;
37558 }
37559
37560
37561 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37562 PyObject *resultobj = 0;
37563 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37564 wxString result;
37565 void *argp1 = 0 ;
37566 int res1 = 0 ;
37567 PyObject *swig_obj[1] ;
37568
37569 if (!args) SWIG_fail;
37570 swig_obj[0] = args;
37571 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37572 if (!SWIG_IsOK(res1)) {
37573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetName" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37574 }
37575 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37576 {
37577 PyThreadState* __tstate = wxPyBeginAllowThreads();
37578 result = ((wxAboutDialogInfo const *)arg1)->GetName();
37579 wxPyEndAllowThreads(__tstate);
37580 if (PyErr_Occurred()) SWIG_fail;
37581 }
37582 {
37583 #if wxUSE_UNICODE
37584 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37585 #else
37586 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37587 #endif
37588 }
37589 return resultobj;
37590 fail:
37591 return NULL;
37592 }
37593
37594
37595 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37596 PyObject *resultobj = 0;
37597 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37598 wxString *arg2 = 0 ;
37599 void *argp1 = 0 ;
37600 int res1 = 0 ;
37601 bool temp2 = false ;
37602 PyObject * obj0 = 0 ;
37603 PyObject * obj1 = 0 ;
37604 char * kwnames[] = {
37605 (char *) "self",(char *) "version", NULL
37606 };
37607
37608 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetVersion",kwnames,&obj0,&obj1)) SWIG_fail;
37609 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37610 if (!SWIG_IsOK(res1)) {
37611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetVersion" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37612 }
37613 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37614 {
37615 arg2 = wxString_in_helper(obj1);
37616 if (arg2 == NULL) SWIG_fail;
37617 temp2 = true;
37618 }
37619 {
37620 PyThreadState* __tstate = wxPyBeginAllowThreads();
37621 (arg1)->SetVersion((wxString const &)*arg2);
37622 wxPyEndAllowThreads(__tstate);
37623 if (PyErr_Occurred()) SWIG_fail;
37624 }
37625 resultobj = SWIG_Py_Void();
37626 {
37627 if (temp2)
37628 delete arg2;
37629 }
37630 return resultobj;
37631 fail:
37632 {
37633 if (temp2)
37634 delete arg2;
37635 }
37636 return NULL;
37637 }
37638
37639
37640 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37641 PyObject *resultobj = 0;
37642 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37643 bool result;
37644 void *argp1 = 0 ;
37645 int res1 = 0 ;
37646 PyObject *swig_obj[1] ;
37647
37648 if (!args) SWIG_fail;
37649 swig_obj[0] = args;
37650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37651 if (!SWIG_IsOK(res1)) {
37652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasVersion" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37653 }
37654 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37655 {
37656 PyThreadState* __tstate = wxPyBeginAllowThreads();
37657 result = (bool)((wxAboutDialogInfo const *)arg1)->HasVersion();
37658 wxPyEndAllowThreads(__tstate);
37659 if (PyErr_Occurred()) SWIG_fail;
37660 }
37661 {
37662 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37663 }
37664 return resultobj;
37665 fail:
37666 return NULL;
37667 }
37668
37669
37670 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37671 PyObject *resultobj = 0;
37672 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37673 wxString result;
37674 void *argp1 = 0 ;
37675 int res1 = 0 ;
37676 PyObject *swig_obj[1] ;
37677
37678 if (!args) SWIG_fail;
37679 swig_obj[0] = args;
37680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37681 if (!SWIG_IsOK(res1)) {
37682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetVersion" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37683 }
37684 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37685 {
37686 PyThreadState* __tstate = wxPyBeginAllowThreads();
37687 result = ((wxAboutDialogInfo const *)arg1)->GetVersion();
37688 wxPyEndAllowThreads(__tstate);
37689 if (PyErr_Occurred()) SWIG_fail;
37690 }
37691 {
37692 #if wxUSE_UNICODE
37693 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37694 #else
37695 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37696 #endif
37697 }
37698 return resultobj;
37699 fail:
37700 return NULL;
37701 }
37702
37703
37704 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37705 PyObject *resultobj = 0;
37706 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37707 wxString *arg2 = 0 ;
37708 void *argp1 = 0 ;
37709 int res1 = 0 ;
37710 bool temp2 = false ;
37711 PyObject * obj0 = 0 ;
37712 PyObject * obj1 = 0 ;
37713 char * kwnames[] = {
37714 (char *) "self",(char *) "desc", NULL
37715 };
37716
37717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetDescription",kwnames,&obj0,&obj1)) SWIG_fail;
37718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37719 if (!SWIG_IsOK(res1)) {
37720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37721 }
37722 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37723 {
37724 arg2 = wxString_in_helper(obj1);
37725 if (arg2 == NULL) SWIG_fail;
37726 temp2 = true;
37727 }
37728 {
37729 PyThreadState* __tstate = wxPyBeginAllowThreads();
37730 (arg1)->SetDescription((wxString const &)*arg2);
37731 wxPyEndAllowThreads(__tstate);
37732 if (PyErr_Occurred()) SWIG_fail;
37733 }
37734 resultobj = SWIG_Py_Void();
37735 {
37736 if (temp2)
37737 delete arg2;
37738 }
37739 return resultobj;
37740 fail:
37741 {
37742 if (temp2)
37743 delete arg2;
37744 }
37745 return NULL;
37746 }
37747
37748
37749 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37750 PyObject *resultobj = 0;
37751 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37752 bool result;
37753 void *argp1 = 0 ;
37754 int res1 = 0 ;
37755 PyObject *swig_obj[1] ;
37756
37757 if (!args) SWIG_fail;
37758 swig_obj[0] = args;
37759 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37760 if (!SWIG_IsOK(res1)) {
37761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37762 }
37763 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37764 {
37765 PyThreadState* __tstate = wxPyBeginAllowThreads();
37766 result = (bool)((wxAboutDialogInfo const *)arg1)->HasDescription();
37767 wxPyEndAllowThreads(__tstate);
37768 if (PyErr_Occurred()) SWIG_fail;
37769 }
37770 {
37771 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37772 }
37773 return resultobj;
37774 fail:
37775 return NULL;
37776 }
37777
37778
37779 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37780 PyObject *resultobj = 0;
37781 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37782 wxString result;
37783 void *argp1 = 0 ;
37784 int res1 = 0 ;
37785 PyObject *swig_obj[1] ;
37786
37787 if (!args) SWIG_fail;
37788 swig_obj[0] = args;
37789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37790 if (!SWIG_IsOK(res1)) {
37791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37792 }
37793 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37794 {
37795 PyThreadState* __tstate = wxPyBeginAllowThreads();
37796 result = ((wxAboutDialogInfo const *)arg1)->GetDescription();
37797 wxPyEndAllowThreads(__tstate);
37798 if (PyErr_Occurred()) SWIG_fail;
37799 }
37800 {
37801 #if wxUSE_UNICODE
37802 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37803 #else
37804 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37805 #endif
37806 }
37807 return resultobj;
37808 fail:
37809 return NULL;
37810 }
37811
37812
37813 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetCopyright(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37814 PyObject *resultobj = 0;
37815 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37816 wxString *arg2 = 0 ;
37817 void *argp1 = 0 ;
37818 int res1 = 0 ;
37819 bool temp2 = false ;
37820 PyObject * obj0 = 0 ;
37821 PyObject * obj1 = 0 ;
37822 char * kwnames[] = {
37823 (char *) "self",(char *) "copyright", NULL
37824 };
37825
37826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetCopyright",kwnames,&obj0,&obj1)) SWIG_fail;
37827 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37828 if (!SWIG_IsOK(res1)) {
37829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetCopyright" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37830 }
37831 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37832 {
37833 arg2 = wxString_in_helper(obj1);
37834 if (arg2 == NULL) SWIG_fail;
37835 temp2 = true;
37836 }
37837 {
37838 PyThreadState* __tstate = wxPyBeginAllowThreads();
37839 (arg1)->SetCopyright((wxString const &)*arg2);
37840 wxPyEndAllowThreads(__tstate);
37841 if (PyErr_Occurred()) SWIG_fail;
37842 }
37843 resultobj = SWIG_Py_Void();
37844 {
37845 if (temp2)
37846 delete arg2;
37847 }
37848 return resultobj;
37849 fail:
37850 {
37851 if (temp2)
37852 delete arg2;
37853 }
37854 return NULL;
37855 }
37856
37857
37858 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasCopyright(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37859 PyObject *resultobj = 0;
37860 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37861 bool result;
37862 void *argp1 = 0 ;
37863 int res1 = 0 ;
37864 PyObject *swig_obj[1] ;
37865
37866 if (!args) SWIG_fail;
37867 swig_obj[0] = args;
37868 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37869 if (!SWIG_IsOK(res1)) {
37870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasCopyright" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37871 }
37872 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37873 {
37874 PyThreadState* __tstate = wxPyBeginAllowThreads();
37875 result = (bool)((wxAboutDialogInfo const *)arg1)->HasCopyright();
37876 wxPyEndAllowThreads(__tstate);
37877 if (PyErr_Occurred()) SWIG_fail;
37878 }
37879 {
37880 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37881 }
37882 return resultobj;
37883 fail:
37884 return NULL;
37885 }
37886
37887
37888 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetCopyright(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37889 PyObject *resultobj = 0;
37890 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37891 wxString result;
37892 void *argp1 = 0 ;
37893 int res1 = 0 ;
37894 PyObject *swig_obj[1] ;
37895
37896 if (!args) SWIG_fail;
37897 swig_obj[0] = args;
37898 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37899 if (!SWIG_IsOK(res1)) {
37900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetCopyright" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37901 }
37902 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37903 {
37904 PyThreadState* __tstate = wxPyBeginAllowThreads();
37905 result = ((wxAboutDialogInfo const *)arg1)->GetCopyright();
37906 wxPyEndAllowThreads(__tstate);
37907 if (PyErr_Occurred()) SWIG_fail;
37908 }
37909 {
37910 #if wxUSE_UNICODE
37911 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37912 #else
37913 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37914 #endif
37915 }
37916 return resultobj;
37917 fail:
37918 return NULL;
37919 }
37920
37921
37922 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetLicence(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37923 PyObject *resultobj = 0;
37924 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37925 wxString *arg2 = 0 ;
37926 void *argp1 = 0 ;
37927 int res1 = 0 ;
37928 bool temp2 = false ;
37929 PyObject * obj0 = 0 ;
37930 PyObject * obj1 = 0 ;
37931 char * kwnames[] = {
37932 (char *) "self",(char *) "licence", NULL
37933 };
37934
37935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetLicence",kwnames,&obj0,&obj1)) SWIG_fail;
37936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37937 if (!SWIG_IsOK(res1)) {
37938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetLicence" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37939 }
37940 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37941 {
37942 arg2 = wxString_in_helper(obj1);
37943 if (arg2 == NULL) SWIG_fail;
37944 temp2 = true;
37945 }
37946 {
37947 PyThreadState* __tstate = wxPyBeginAllowThreads();
37948 (arg1)->SetLicence((wxString const &)*arg2);
37949 wxPyEndAllowThreads(__tstate);
37950 if (PyErr_Occurred()) SWIG_fail;
37951 }
37952 resultobj = SWIG_Py_Void();
37953 {
37954 if (temp2)
37955 delete arg2;
37956 }
37957 return resultobj;
37958 fail:
37959 {
37960 if (temp2)
37961 delete arg2;
37962 }
37963 return NULL;
37964 }
37965
37966
37967 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetLicense(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37968 PyObject *resultobj = 0;
37969 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37970 wxString *arg2 = 0 ;
37971 void *argp1 = 0 ;
37972 int res1 = 0 ;
37973 bool temp2 = false ;
37974 PyObject * obj0 = 0 ;
37975 PyObject * obj1 = 0 ;
37976 char * kwnames[] = {
37977 (char *) "self",(char *) "licence", NULL
37978 };
37979
37980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetLicense",kwnames,&obj0,&obj1)) SWIG_fail;
37981 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37982 if (!SWIG_IsOK(res1)) {
37983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetLicense" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37984 }
37985 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37986 {
37987 arg2 = wxString_in_helper(obj1);
37988 if (arg2 == NULL) SWIG_fail;
37989 temp2 = true;
37990 }
37991 {
37992 PyThreadState* __tstate = wxPyBeginAllowThreads();
37993 (arg1)->SetLicense((wxString const &)*arg2);
37994 wxPyEndAllowThreads(__tstate);
37995 if (PyErr_Occurred()) SWIG_fail;
37996 }
37997 resultobj = SWIG_Py_Void();
37998 {
37999 if (temp2)
38000 delete arg2;
38001 }
38002 return resultobj;
38003 fail:
38004 {
38005 if (temp2)
38006 delete arg2;
38007 }
38008 return NULL;
38009 }
38010
38011
38012 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasLicence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38013 PyObject *resultobj = 0;
38014 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38015 bool result;
38016 void *argp1 = 0 ;
38017 int res1 = 0 ;
38018 PyObject *swig_obj[1] ;
38019
38020 if (!args) SWIG_fail;
38021 swig_obj[0] = args;
38022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38023 if (!SWIG_IsOK(res1)) {
38024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasLicence" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38025 }
38026 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38027 {
38028 PyThreadState* __tstate = wxPyBeginAllowThreads();
38029 result = (bool)((wxAboutDialogInfo const *)arg1)->HasLicence();
38030 wxPyEndAllowThreads(__tstate);
38031 if (PyErr_Occurred()) SWIG_fail;
38032 }
38033 {
38034 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38035 }
38036 return resultobj;
38037 fail:
38038 return NULL;
38039 }
38040
38041
38042 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetLicence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38043 PyObject *resultobj = 0;
38044 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38045 wxString result;
38046 void *argp1 = 0 ;
38047 int res1 = 0 ;
38048 PyObject *swig_obj[1] ;
38049
38050 if (!args) SWIG_fail;
38051 swig_obj[0] = args;
38052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38053 if (!SWIG_IsOK(res1)) {
38054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetLicence" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38055 }
38056 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38057 {
38058 PyThreadState* __tstate = wxPyBeginAllowThreads();
38059 result = ((wxAboutDialogInfo const *)arg1)->GetLicence();
38060 wxPyEndAllowThreads(__tstate);
38061 if (PyErr_Occurred()) SWIG_fail;
38062 }
38063 {
38064 #if wxUSE_UNICODE
38065 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38066 #else
38067 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38068 #endif
38069 }
38070 return resultobj;
38071 fail:
38072 return NULL;
38073 }
38074
38075
38076 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38077 PyObject *resultobj = 0;
38078 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38079 wxIcon *arg2 = 0 ;
38080 void *argp1 = 0 ;
38081 int res1 = 0 ;
38082 void *argp2 = 0 ;
38083 int res2 = 0 ;
38084 PyObject * obj0 = 0 ;
38085 PyObject * obj1 = 0 ;
38086 char * kwnames[] = {
38087 (char *) "self",(char *) "icon", NULL
38088 };
38089
38090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetIcon",kwnames,&obj0,&obj1)) SWIG_fail;
38091 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38092 if (!SWIG_IsOK(res1)) {
38093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetIcon" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38094 }
38095 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38096 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxIcon, 0 | 0);
38097 if (!SWIG_IsOK(res2)) {
38098 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AboutDialogInfo_SetIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
38099 }
38100 if (!argp2) {
38101 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AboutDialogInfo_SetIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
38102 }
38103 arg2 = reinterpret_cast< wxIcon * >(argp2);
38104 {
38105 PyThreadState* __tstate = wxPyBeginAllowThreads();
38106 (arg1)->SetIcon((wxIcon const &)*arg2);
38107 wxPyEndAllowThreads(__tstate);
38108 if (PyErr_Occurred()) SWIG_fail;
38109 }
38110 resultobj = SWIG_Py_Void();
38111 return resultobj;
38112 fail:
38113 return NULL;
38114 }
38115
38116
38117 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38118 PyObject *resultobj = 0;
38119 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38120 bool result;
38121 void *argp1 = 0 ;
38122 int res1 = 0 ;
38123 PyObject *swig_obj[1] ;
38124
38125 if (!args) SWIG_fail;
38126 swig_obj[0] = args;
38127 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38128 if (!SWIG_IsOK(res1)) {
38129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasIcon" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38130 }
38131 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38132 {
38133 PyThreadState* __tstate = wxPyBeginAllowThreads();
38134 result = (bool)((wxAboutDialogInfo const *)arg1)->HasIcon();
38135 wxPyEndAllowThreads(__tstate);
38136 if (PyErr_Occurred()) SWIG_fail;
38137 }
38138 {
38139 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38140 }
38141 return resultobj;
38142 fail:
38143 return NULL;
38144 }
38145
38146
38147 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38148 PyObject *resultobj = 0;
38149 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38150 wxIcon result;
38151 void *argp1 = 0 ;
38152 int res1 = 0 ;
38153 PyObject *swig_obj[1] ;
38154
38155 if (!args) SWIG_fail;
38156 swig_obj[0] = args;
38157 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38158 if (!SWIG_IsOK(res1)) {
38159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetIcon" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38160 }
38161 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38162 {
38163 PyThreadState* __tstate = wxPyBeginAllowThreads();
38164 result = ((wxAboutDialogInfo const *)arg1)->GetIcon();
38165 wxPyEndAllowThreads(__tstate);
38166 if (PyErr_Occurred()) SWIG_fail;
38167 }
38168 resultobj = SWIG_NewPointerObj((new wxIcon(static_cast< const wxIcon& >(result))), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
38169 return resultobj;
38170 fail:
38171 return NULL;
38172 }
38173
38174
38175 SWIGINTERN PyObject *_wrap_AboutDialogInfo__SetWebSite(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38176 PyObject *resultobj = 0;
38177 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38178 wxString *arg2 = 0 ;
38179 wxString const &arg3_defvalue = wxEmptyString ;
38180 wxString *arg3 = (wxString *) &arg3_defvalue ;
38181 void *argp1 = 0 ;
38182 int res1 = 0 ;
38183 bool temp2 = false ;
38184 bool temp3 = false ;
38185 PyObject * obj0 = 0 ;
38186 PyObject * obj1 = 0 ;
38187 PyObject * obj2 = 0 ;
38188 char * kwnames[] = {
38189 (char *) "self",(char *) "url",(char *) "desc", NULL
38190 };
38191
38192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:AboutDialogInfo__SetWebSite",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38193 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38194 if (!SWIG_IsOK(res1)) {
38195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo__SetWebSite" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38196 }
38197 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38198 {
38199 arg2 = wxString_in_helper(obj1);
38200 if (arg2 == NULL) SWIG_fail;
38201 temp2 = true;
38202 }
38203 if (obj2) {
38204 {
38205 arg3 = wxString_in_helper(obj2);
38206 if (arg3 == NULL) SWIG_fail;
38207 temp3 = true;
38208 }
38209 }
38210 {
38211 PyThreadState* __tstate = wxPyBeginAllowThreads();
38212 (arg1)->SetWebSite((wxString const &)*arg2,(wxString const &)*arg3);
38213 wxPyEndAllowThreads(__tstate);
38214 if (PyErr_Occurred()) SWIG_fail;
38215 }
38216 resultobj = SWIG_Py_Void();
38217 {
38218 if (temp2)
38219 delete arg2;
38220 }
38221 {
38222 if (temp3)
38223 delete arg3;
38224 }
38225 return resultobj;
38226 fail:
38227 {
38228 if (temp2)
38229 delete arg2;
38230 }
38231 {
38232 if (temp3)
38233 delete arg3;
38234 }
38235 return NULL;
38236 }
38237
38238
38239 SWIGINTERN PyObject *_wrap_AboutDialogInfo__GetWebSiteURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38240 PyObject *resultobj = 0;
38241 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38242 wxString result;
38243 void *argp1 = 0 ;
38244 int res1 = 0 ;
38245 PyObject *swig_obj[1] ;
38246
38247 if (!args) SWIG_fail;
38248 swig_obj[0] = args;
38249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38250 if (!SWIG_IsOK(res1)) {
38251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo__GetWebSiteURL" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38252 }
38253 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38254 {
38255 PyThreadState* __tstate = wxPyBeginAllowThreads();
38256 result = ((wxAboutDialogInfo const *)arg1)->GetWebSiteURL();
38257 wxPyEndAllowThreads(__tstate);
38258 if (PyErr_Occurred()) SWIG_fail;
38259 }
38260 {
38261 #if wxUSE_UNICODE
38262 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38263 #else
38264 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38265 #endif
38266 }
38267 return resultobj;
38268 fail:
38269 return NULL;
38270 }
38271
38272
38273 SWIGINTERN PyObject *_wrap_AboutDialogInfo__GetWebSiteDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38274 PyObject *resultobj = 0;
38275 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38276 wxString result;
38277 void *argp1 = 0 ;
38278 int res1 = 0 ;
38279 PyObject *swig_obj[1] ;
38280
38281 if (!args) SWIG_fail;
38282 swig_obj[0] = args;
38283 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38284 if (!SWIG_IsOK(res1)) {
38285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo__GetWebSiteDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38286 }
38287 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38288 {
38289 PyThreadState* __tstate = wxPyBeginAllowThreads();
38290 result = ((wxAboutDialogInfo const *)arg1)->GetWebSiteDescription();
38291 wxPyEndAllowThreads(__tstate);
38292 if (PyErr_Occurred()) SWIG_fail;
38293 }
38294 {
38295 #if wxUSE_UNICODE
38296 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38297 #else
38298 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38299 #endif
38300 }
38301 return resultobj;
38302 fail:
38303 return NULL;
38304 }
38305
38306
38307 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasWebSite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38308 PyObject *resultobj = 0;
38309 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38310 bool result;
38311 void *argp1 = 0 ;
38312 int res1 = 0 ;
38313 PyObject *swig_obj[1] ;
38314
38315 if (!args) SWIG_fail;
38316 swig_obj[0] = args;
38317 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38318 if (!SWIG_IsOK(res1)) {
38319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasWebSite" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38320 }
38321 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38322 {
38323 PyThreadState* __tstate = wxPyBeginAllowThreads();
38324 result = (bool)((wxAboutDialogInfo const *)arg1)->HasWebSite();
38325 wxPyEndAllowThreads(__tstate);
38326 if (PyErr_Occurred()) SWIG_fail;
38327 }
38328 {
38329 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38330 }
38331 return resultobj;
38332 fail:
38333 return NULL;
38334 }
38335
38336
38337 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetDevelopers(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38338 PyObject *resultobj = 0;
38339 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38340 wxArrayString *arg2 = 0 ;
38341 void *argp1 = 0 ;
38342 int res1 = 0 ;
38343 bool temp2 = false ;
38344 PyObject * obj0 = 0 ;
38345 PyObject * obj1 = 0 ;
38346 char * kwnames[] = {
38347 (char *) "self",(char *) "developers", NULL
38348 };
38349
38350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetDevelopers",kwnames,&obj0,&obj1)) SWIG_fail;
38351 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38352 if (!SWIG_IsOK(res1)) {
38353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetDevelopers" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38354 }
38355 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38356 {
38357 if (! PySequence_Check(obj1)) {
38358 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38359 SWIG_fail;
38360 }
38361 arg2 = new wxArrayString;
38362 temp2 = true;
38363 int i, len=PySequence_Length(obj1);
38364 for (i=0; i<len; i++) {
38365 PyObject* item = PySequence_GetItem(obj1, i);
38366 wxString* s = wxString_in_helper(item);
38367 if (PyErr_Occurred()) SWIG_fail;
38368 arg2->Add(*s);
38369 delete s;
38370 Py_DECREF(item);
38371 }
38372 }
38373 {
38374 PyThreadState* __tstate = wxPyBeginAllowThreads();
38375 (arg1)->SetDevelopers((wxArrayString const &)*arg2);
38376 wxPyEndAllowThreads(__tstate);
38377 if (PyErr_Occurred()) SWIG_fail;
38378 }
38379 resultobj = SWIG_Py_Void();
38380 {
38381 if (temp2) delete arg2;
38382 }
38383 return resultobj;
38384 fail:
38385 {
38386 if (temp2) delete arg2;
38387 }
38388 return NULL;
38389 }
38390
38391
38392 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddDeveloper(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38393 PyObject *resultobj = 0;
38394 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38395 wxString *arg2 = 0 ;
38396 void *argp1 = 0 ;
38397 int res1 = 0 ;
38398 bool temp2 = false ;
38399 PyObject * obj0 = 0 ;
38400 PyObject * obj1 = 0 ;
38401 char * kwnames[] = {
38402 (char *) "self",(char *) "developer", NULL
38403 };
38404
38405 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddDeveloper",kwnames,&obj0,&obj1)) SWIG_fail;
38406 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38407 if (!SWIG_IsOK(res1)) {
38408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddDeveloper" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38409 }
38410 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38411 {
38412 arg2 = wxString_in_helper(obj1);
38413 if (arg2 == NULL) SWIG_fail;
38414 temp2 = true;
38415 }
38416 {
38417 PyThreadState* __tstate = wxPyBeginAllowThreads();
38418 (arg1)->AddDeveloper((wxString const &)*arg2);
38419 wxPyEndAllowThreads(__tstate);
38420 if (PyErr_Occurred()) SWIG_fail;
38421 }
38422 resultobj = SWIG_Py_Void();
38423 {
38424 if (temp2)
38425 delete arg2;
38426 }
38427 return resultobj;
38428 fail:
38429 {
38430 if (temp2)
38431 delete arg2;
38432 }
38433 return NULL;
38434 }
38435
38436
38437 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasDevelopers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38438 PyObject *resultobj = 0;
38439 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38440 bool result;
38441 void *argp1 = 0 ;
38442 int res1 = 0 ;
38443 PyObject *swig_obj[1] ;
38444
38445 if (!args) SWIG_fail;
38446 swig_obj[0] = args;
38447 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38448 if (!SWIG_IsOK(res1)) {
38449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasDevelopers" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38450 }
38451 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38452 {
38453 PyThreadState* __tstate = wxPyBeginAllowThreads();
38454 result = (bool)((wxAboutDialogInfo const *)arg1)->HasDevelopers();
38455 wxPyEndAllowThreads(__tstate);
38456 if (PyErr_Occurred()) SWIG_fail;
38457 }
38458 {
38459 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38460 }
38461 return resultobj;
38462 fail:
38463 return NULL;
38464 }
38465
38466
38467 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDevelopers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38468 PyObject *resultobj = 0;
38469 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38470 wxArrayString *result = 0 ;
38471 void *argp1 = 0 ;
38472 int res1 = 0 ;
38473 PyObject *swig_obj[1] ;
38474
38475 if (!args) SWIG_fail;
38476 swig_obj[0] = args;
38477 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38478 if (!SWIG_IsOK(res1)) {
38479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDevelopers" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38480 }
38481 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38482 {
38483 PyThreadState* __tstate = wxPyBeginAllowThreads();
38484 {
38485 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetDevelopers();
38486 result = (wxArrayString *) &_result_ref;
38487 }
38488 wxPyEndAllowThreads(__tstate);
38489 if (PyErr_Occurred()) SWIG_fail;
38490 }
38491 {
38492 resultobj = wxArrayString2PyList_helper(*result);
38493 }
38494 return resultobj;
38495 fail:
38496 return NULL;
38497 }
38498
38499
38500 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetDocWriters(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38501 PyObject *resultobj = 0;
38502 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38503 wxArrayString *arg2 = 0 ;
38504 void *argp1 = 0 ;
38505 int res1 = 0 ;
38506 bool temp2 = false ;
38507 PyObject * obj0 = 0 ;
38508 PyObject * obj1 = 0 ;
38509 char * kwnames[] = {
38510 (char *) "self",(char *) "docwriters", NULL
38511 };
38512
38513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetDocWriters",kwnames,&obj0,&obj1)) SWIG_fail;
38514 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38515 if (!SWIG_IsOK(res1)) {
38516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetDocWriters" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38517 }
38518 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38519 {
38520 if (! PySequence_Check(obj1)) {
38521 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38522 SWIG_fail;
38523 }
38524 arg2 = new wxArrayString;
38525 temp2 = true;
38526 int i, len=PySequence_Length(obj1);
38527 for (i=0; i<len; i++) {
38528 PyObject* item = PySequence_GetItem(obj1, i);
38529 wxString* s = wxString_in_helper(item);
38530 if (PyErr_Occurred()) SWIG_fail;
38531 arg2->Add(*s);
38532 delete s;
38533 Py_DECREF(item);
38534 }
38535 }
38536 {
38537 PyThreadState* __tstate = wxPyBeginAllowThreads();
38538 (arg1)->SetDocWriters((wxArrayString const &)*arg2);
38539 wxPyEndAllowThreads(__tstate);
38540 if (PyErr_Occurred()) SWIG_fail;
38541 }
38542 resultobj = SWIG_Py_Void();
38543 {
38544 if (temp2) delete arg2;
38545 }
38546 return resultobj;
38547 fail:
38548 {
38549 if (temp2) delete arg2;
38550 }
38551 return NULL;
38552 }
38553
38554
38555 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddDocWriter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38556 PyObject *resultobj = 0;
38557 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38558 wxString *arg2 = 0 ;
38559 void *argp1 = 0 ;
38560 int res1 = 0 ;
38561 bool temp2 = false ;
38562 PyObject * obj0 = 0 ;
38563 PyObject * obj1 = 0 ;
38564 char * kwnames[] = {
38565 (char *) "self",(char *) "docwriter", NULL
38566 };
38567
38568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddDocWriter",kwnames,&obj0,&obj1)) SWIG_fail;
38569 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38570 if (!SWIG_IsOK(res1)) {
38571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddDocWriter" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38572 }
38573 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38574 {
38575 arg2 = wxString_in_helper(obj1);
38576 if (arg2 == NULL) SWIG_fail;
38577 temp2 = true;
38578 }
38579 {
38580 PyThreadState* __tstate = wxPyBeginAllowThreads();
38581 (arg1)->AddDocWriter((wxString const &)*arg2);
38582 wxPyEndAllowThreads(__tstate);
38583 if (PyErr_Occurred()) SWIG_fail;
38584 }
38585 resultobj = SWIG_Py_Void();
38586 {
38587 if (temp2)
38588 delete arg2;
38589 }
38590 return resultobj;
38591 fail:
38592 {
38593 if (temp2)
38594 delete arg2;
38595 }
38596 return NULL;
38597 }
38598
38599
38600 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasDocWriters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38601 PyObject *resultobj = 0;
38602 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38603 bool result;
38604 void *argp1 = 0 ;
38605 int res1 = 0 ;
38606 PyObject *swig_obj[1] ;
38607
38608 if (!args) SWIG_fail;
38609 swig_obj[0] = args;
38610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38611 if (!SWIG_IsOK(res1)) {
38612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasDocWriters" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38613 }
38614 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38615 {
38616 PyThreadState* __tstate = wxPyBeginAllowThreads();
38617 result = (bool)((wxAboutDialogInfo const *)arg1)->HasDocWriters();
38618 wxPyEndAllowThreads(__tstate);
38619 if (PyErr_Occurred()) SWIG_fail;
38620 }
38621 {
38622 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38623 }
38624 return resultobj;
38625 fail:
38626 return NULL;
38627 }
38628
38629
38630 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDocWriters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38631 PyObject *resultobj = 0;
38632 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38633 wxArrayString *result = 0 ;
38634 void *argp1 = 0 ;
38635 int res1 = 0 ;
38636 PyObject *swig_obj[1] ;
38637
38638 if (!args) SWIG_fail;
38639 swig_obj[0] = args;
38640 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38641 if (!SWIG_IsOK(res1)) {
38642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDocWriters" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38643 }
38644 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38645 {
38646 PyThreadState* __tstate = wxPyBeginAllowThreads();
38647 {
38648 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetDocWriters();
38649 result = (wxArrayString *) &_result_ref;
38650 }
38651 wxPyEndAllowThreads(__tstate);
38652 if (PyErr_Occurred()) SWIG_fail;
38653 }
38654 {
38655 resultobj = wxArrayString2PyList_helper(*result);
38656 }
38657 return resultobj;
38658 fail:
38659 return NULL;
38660 }
38661
38662
38663 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetArtists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38664 PyObject *resultobj = 0;
38665 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38666 wxArrayString *arg2 = 0 ;
38667 void *argp1 = 0 ;
38668 int res1 = 0 ;
38669 bool temp2 = false ;
38670 PyObject * obj0 = 0 ;
38671 PyObject * obj1 = 0 ;
38672 char * kwnames[] = {
38673 (char *) "self",(char *) "artists", NULL
38674 };
38675
38676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetArtists",kwnames,&obj0,&obj1)) SWIG_fail;
38677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38678 if (!SWIG_IsOK(res1)) {
38679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetArtists" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38680 }
38681 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38682 {
38683 if (! PySequence_Check(obj1)) {
38684 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38685 SWIG_fail;
38686 }
38687 arg2 = new wxArrayString;
38688 temp2 = true;
38689 int i, len=PySequence_Length(obj1);
38690 for (i=0; i<len; i++) {
38691 PyObject* item = PySequence_GetItem(obj1, i);
38692 wxString* s = wxString_in_helper(item);
38693 if (PyErr_Occurred()) SWIG_fail;
38694 arg2->Add(*s);
38695 delete s;
38696 Py_DECREF(item);
38697 }
38698 }
38699 {
38700 PyThreadState* __tstate = wxPyBeginAllowThreads();
38701 (arg1)->SetArtists((wxArrayString const &)*arg2);
38702 wxPyEndAllowThreads(__tstate);
38703 if (PyErr_Occurred()) SWIG_fail;
38704 }
38705 resultobj = SWIG_Py_Void();
38706 {
38707 if (temp2) delete arg2;
38708 }
38709 return resultobj;
38710 fail:
38711 {
38712 if (temp2) delete arg2;
38713 }
38714 return NULL;
38715 }
38716
38717
38718 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddArtist(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38719 PyObject *resultobj = 0;
38720 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38721 wxString *arg2 = 0 ;
38722 void *argp1 = 0 ;
38723 int res1 = 0 ;
38724 bool temp2 = false ;
38725 PyObject * obj0 = 0 ;
38726 PyObject * obj1 = 0 ;
38727 char * kwnames[] = {
38728 (char *) "self",(char *) "artist", NULL
38729 };
38730
38731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddArtist",kwnames,&obj0,&obj1)) SWIG_fail;
38732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38733 if (!SWIG_IsOK(res1)) {
38734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddArtist" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38735 }
38736 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38737 {
38738 arg2 = wxString_in_helper(obj1);
38739 if (arg2 == NULL) SWIG_fail;
38740 temp2 = true;
38741 }
38742 {
38743 PyThreadState* __tstate = wxPyBeginAllowThreads();
38744 (arg1)->AddArtist((wxString const &)*arg2);
38745 wxPyEndAllowThreads(__tstate);
38746 if (PyErr_Occurred()) SWIG_fail;
38747 }
38748 resultobj = SWIG_Py_Void();
38749 {
38750 if (temp2)
38751 delete arg2;
38752 }
38753 return resultobj;
38754 fail:
38755 {
38756 if (temp2)
38757 delete arg2;
38758 }
38759 return NULL;
38760 }
38761
38762
38763 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasArtists(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38764 PyObject *resultobj = 0;
38765 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38766 bool result;
38767 void *argp1 = 0 ;
38768 int res1 = 0 ;
38769 PyObject *swig_obj[1] ;
38770
38771 if (!args) SWIG_fail;
38772 swig_obj[0] = args;
38773 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38774 if (!SWIG_IsOK(res1)) {
38775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasArtists" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38776 }
38777 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38778 {
38779 PyThreadState* __tstate = wxPyBeginAllowThreads();
38780 result = (bool)((wxAboutDialogInfo const *)arg1)->HasArtists();
38781 wxPyEndAllowThreads(__tstate);
38782 if (PyErr_Occurred()) SWIG_fail;
38783 }
38784 {
38785 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38786 }
38787 return resultobj;
38788 fail:
38789 return NULL;
38790 }
38791
38792
38793 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetArtists(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38794 PyObject *resultobj = 0;
38795 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38796 wxArrayString *result = 0 ;
38797 void *argp1 = 0 ;
38798 int res1 = 0 ;
38799 PyObject *swig_obj[1] ;
38800
38801 if (!args) SWIG_fail;
38802 swig_obj[0] = args;
38803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38804 if (!SWIG_IsOK(res1)) {
38805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetArtists" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38806 }
38807 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38808 {
38809 PyThreadState* __tstate = wxPyBeginAllowThreads();
38810 {
38811 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetArtists();
38812 result = (wxArrayString *) &_result_ref;
38813 }
38814 wxPyEndAllowThreads(__tstate);
38815 if (PyErr_Occurred()) SWIG_fail;
38816 }
38817 {
38818 resultobj = wxArrayString2PyList_helper(*result);
38819 }
38820 return resultobj;
38821 fail:
38822 return NULL;
38823 }
38824
38825
38826 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetTranslators(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38827 PyObject *resultobj = 0;
38828 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38829 wxArrayString *arg2 = 0 ;
38830 void *argp1 = 0 ;
38831 int res1 = 0 ;
38832 bool temp2 = false ;
38833 PyObject * obj0 = 0 ;
38834 PyObject * obj1 = 0 ;
38835 char * kwnames[] = {
38836 (char *) "self",(char *) "translators", NULL
38837 };
38838
38839 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetTranslators",kwnames,&obj0,&obj1)) SWIG_fail;
38840 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38841 if (!SWIG_IsOK(res1)) {
38842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetTranslators" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38843 }
38844 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38845 {
38846 if (! PySequence_Check(obj1)) {
38847 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38848 SWIG_fail;
38849 }
38850 arg2 = new wxArrayString;
38851 temp2 = true;
38852 int i, len=PySequence_Length(obj1);
38853 for (i=0; i<len; i++) {
38854 PyObject* item = PySequence_GetItem(obj1, i);
38855 wxString* s = wxString_in_helper(item);
38856 if (PyErr_Occurred()) SWIG_fail;
38857 arg2->Add(*s);
38858 delete s;
38859 Py_DECREF(item);
38860 }
38861 }
38862 {
38863 PyThreadState* __tstate = wxPyBeginAllowThreads();
38864 (arg1)->SetTranslators((wxArrayString const &)*arg2);
38865 wxPyEndAllowThreads(__tstate);
38866 if (PyErr_Occurred()) SWIG_fail;
38867 }
38868 resultobj = SWIG_Py_Void();
38869 {
38870 if (temp2) delete arg2;
38871 }
38872 return resultobj;
38873 fail:
38874 {
38875 if (temp2) delete arg2;
38876 }
38877 return NULL;
38878 }
38879
38880
38881 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddTranslator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38882 PyObject *resultobj = 0;
38883 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38884 wxString *arg2 = 0 ;
38885 void *argp1 = 0 ;
38886 int res1 = 0 ;
38887 bool temp2 = false ;
38888 PyObject * obj0 = 0 ;
38889 PyObject * obj1 = 0 ;
38890 char * kwnames[] = {
38891 (char *) "self",(char *) "translator", NULL
38892 };
38893
38894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddTranslator",kwnames,&obj0,&obj1)) SWIG_fail;
38895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38896 if (!SWIG_IsOK(res1)) {
38897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddTranslator" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38898 }
38899 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38900 {
38901 arg2 = wxString_in_helper(obj1);
38902 if (arg2 == NULL) SWIG_fail;
38903 temp2 = true;
38904 }
38905 {
38906 PyThreadState* __tstate = wxPyBeginAllowThreads();
38907 (arg1)->AddTranslator((wxString const &)*arg2);
38908 wxPyEndAllowThreads(__tstate);
38909 if (PyErr_Occurred()) SWIG_fail;
38910 }
38911 resultobj = SWIG_Py_Void();
38912 {
38913 if (temp2)
38914 delete arg2;
38915 }
38916 return resultobj;
38917 fail:
38918 {
38919 if (temp2)
38920 delete arg2;
38921 }
38922 return NULL;
38923 }
38924
38925
38926 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasTranslators(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38927 PyObject *resultobj = 0;
38928 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38929 bool result;
38930 void *argp1 = 0 ;
38931 int res1 = 0 ;
38932 PyObject *swig_obj[1] ;
38933
38934 if (!args) SWIG_fail;
38935 swig_obj[0] = args;
38936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38937 if (!SWIG_IsOK(res1)) {
38938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasTranslators" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38939 }
38940 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38941 {
38942 PyThreadState* __tstate = wxPyBeginAllowThreads();
38943 result = (bool)((wxAboutDialogInfo const *)arg1)->HasTranslators();
38944 wxPyEndAllowThreads(__tstate);
38945 if (PyErr_Occurred()) SWIG_fail;
38946 }
38947 {
38948 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38949 }
38950 return resultobj;
38951 fail:
38952 return NULL;
38953 }
38954
38955
38956 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetTranslators(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38957 PyObject *resultobj = 0;
38958 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38959 wxArrayString *result = 0 ;
38960 void *argp1 = 0 ;
38961 int res1 = 0 ;
38962 PyObject *swig_obj[1] ;
38963
38964 if (!args) SWIG_fail;
38965 swig_obj[0] = args;
38966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38967 if (!SWIG_IsOK(res1)) {
38968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetTranslators" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38969 }
38970 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38971 {
38972 PyThreadState* __tstate = wxPyBeginAllowThreads();
38973 {
38974 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetTranslators();
38975 result = (wxArrayString *) &_result_ref;
38976 }
38977 wxPyEndAllowThreads(__tstate);
38978 if (PyErr_Occurred()) SWIG_fail;
38979 }
38980 {
38981 resultobj = wxArrayString2PyList_helper(*result);
38982 }
38983 return resultobj;
38984 fail:
38985 return NULL;
38986 }
38987
38988
38989 SWIGINTERN PyObject *_wrap_AboutDialogInfo_IsSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38990 PyObject *resultobj = 0;
38991 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38992 bool result;
38993 void *argp1 = 0 ;
38994 int res1 = 0 ;
38995 PyObject *swig_obj[1] ;
38996
38997 if (!args) SWIG_fail;
38998 swig_obj[0] = args;
38999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
39000 if (!SWIG_IsOK(res1)) {
39001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_IsSimple" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
39002 }
39003 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39004 {
39005 PyThreadState* __tstate = wxPyBeginAllowThreads();
39006 result = (bool)((wxAboutDialogInfo const *)arg1)->IsSimple();
39007 wxPyEndAllowThreads(__tstate);
39008 if (PyErr_Occurred()) SWIG_fail;
39009 }
39010 {
39011 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39012 }
39013 return resultobj;
39014 fail:
39015 return NULL;
39016 }
39017
39018
39019 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDescriptionAndCredits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39020 PyObject *resultobj = 0;
39021 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
39022 wxString result;
39023 void *argp1 = 0 ;
39024 int res1 = 0 ;
39025 PyObject *swig_obj[1] ;
39026
39027 if (!args) SWIG_fail;
39028 swig_obj[0] = args;
39029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
39030 if (!SWIG_IsOK(res1)) {
39031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDescriptionAndCredits" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
39032 }
39033 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39034 {
39035 PyThreadState* __tstate = wxPyBeginAllowThreads();
39036 result = ((wxAboutDialogInfo const *)arg1)->GetDescriptionAndCredits();
39037 wxPyEndAllowThreads(__tstate);
39038 if (PyErr_Occurred()) SWIG_fail;
39039 }
39040 {
39041 #if wxUSE_UNICODE
39042 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
39043 #else
39044 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
39045 #endif
39046 }
39047 return resultobj;
39048 fail:
39049 return NULL;
39050 }
39051
39052
39053 SWIGINTERN PyObject *AboutDialogInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39054 PyObject *obj;
39055 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
39056 SWIG_TypeNewClientData(SWIGTYPE_p_wxAboutDialogInfo, SWIG_NewClientData(obj));
39057 return SWIG_Py_Void();
39058 }
39059
39060 SWIGINTERN PyObject *AboutDialogInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39061 return SWIG_Python_InitShadowInstance(args);
39062 }
39063
39064 SWIGINTERN PyObject *_wrap_AboutBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39065 PyObject *resultobj = 0;
39066 wxAboutDialogInfo *arg1 = 0 ;
39067 void *argp1 = 0 ;
39068 int res1 = 0 ;
39069 PyObject * obj0 = 0 ;
39070 char * kwnames[] = {
39071 (char *) "info", NULL
39072 };
39073
39074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AboutBox",kwnames,&obj0)) SWIG_fail;
39075 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxAboutDialogInfo, 0 | 0);
39076 if (!SWIG_IsOK(res1)) {
39077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutBox" "', expected argument " "1"" of type '" "wxAboutDialogInfo const &""'");
39078 }
39079 if (!argp1) {
39080 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AboutBox" "', expected argument " "1"" of type '" "wxAboutDialogInfo const &""'");
39081 }
39082 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39083 {
39084 PyThreadState* __tstate = wxPyBeginAllowThreads();
39085 wxAboutBox((wxAboutDialogInfo const &)*arg1);
39086 wxPyEndAllowThreads(__tstate);
39087 if (PyErr_Occurred()) SWIG_fail;
39088 }
39089 resultobj = SWIG_Py_Void();
39090 return resultobj;
39091 fail:
39092 return NULL;
39093 }
39094
39095
39096 static PyMethodDef SwigMethods[] = {
39097 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
39098 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
39099 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
39100 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
39101 { (char *)"SystemSettings_GetScreenType", (PyCFunction)_wrap_SystemSettings_GetScreenType, METH_NOARGS, NULL},
39102 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
39103 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
39104 { (char *)"new_SystemOptions", (PyCFunction)_wrap_new_SystemOptions, METH_NOARGS, NULL},
39105 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
39106 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
39107 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
39108 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
39109 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
39110 { (char *)"SystemOptions_IsFalse", (PyCFunction) _wrap_SystemOptions_IsFalse, METH_VARARGS | METH_KEYWORDS, NULL},
39111 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
39112 { (char *)"SystemOptions_swiginit", SystemOptions_swiginit, METH_VARARGS, NULL},
39113 { (char *)"NewId", (PyCFunction)_wrap_NewId, METH_NOARGS, NULL},
39114 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
39115 { (char *)"GetCurrentId", (PyCFunction)_wrap_GetCurrentId, METH_NOARGS, NULL},
39116 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
39117 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
39118 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
39119 { (char *)"GetStockHelpString", (PyCFunction) _wrap_GetStockHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
39120 { (char *)"Bell", (PyCFunction)_wrap_Bell, METH_NOARGS, NULL},
39121 { (char *)"EndBusyCursor", (PyCFunction)_wrap_EndBusyCursor, METH_NOARGS, NULL},
39122 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
39123 { (char *)"IsBusy", (PyCFunction)_wrap_IsBusy, METH_NOARGS, NULL},
39124 { (char *)"Now", (PyCFunction)_wrap_Now, METH_NOARGS, NULL},
39125 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
39126 { (char *)"StartTimer", (PyCFunction)_wrap_StartTimer, METH_NOARGS, NULL},
39127 { (char *)"GetOsVersion", (PyCFunction)_wrap_GetOsVersion, METH_NOARGS, NULL},
39128 { (char *)"GetOsDescription", (PyCFunction)_wrap_GetOsDescription, METH_NOARGS, NULL},
39129 { (char *)"IsPlatformLittleEndian", (PyCFunction)_wrap_IsPlatformLittleEndian, METH_NOARGS, NULL},
39130 { (char *)"IsPlatform64Bit", (PyCFunction)_wrap_IsPlatform64Bit, METH_NOARGS, NULL},
39131 { (char *)"GetFreeMemory", (PyCFunction)_wrap_GetFreeMemory, METH_NOARGS, NULL},
39132 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
39133 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
39134 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
39135 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
39136 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
39137 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
39138 { (char *)"GetEmailAddress", (PyCFunction)_wrap_GetEmailAddress, METH_NOARGS, NULL},
39139 { (char *)"GetHostName", (PyCFunction)_wrap_GetHostName, METH_NOARGS, NULL},
39140 { (char *)"GetFullHostName", (PyCFunction)_wrap_GetFullHostName, METH_NOARGS, NULL},
39141 { (char *)"GetUserId", (PyCFunction)_wrap_GetUserId, METH_NOARGS, NULL},
39142 { (char *)"GetUserName", (PyCFunction)_wrap_GetUserName, METH_NOARGS, NULL},
39143 { (char *)"GetHomeDir", (PyCFunction)_wrap_GetHomeDir, METH_NOARGS, NULL},
39144 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
39145 { (char *)"GetProcessId", (PyCFunction)_wrap_GetProcessId, METH_NOARGS, NULL},
39146 { (char *)"Trap", (PyCFunction)_wrap_Trap, METH_NOARGS, NULL},
39147 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39148 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39149 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39150 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39151 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
39152 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
39153 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
39154 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
39155 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
39156 { (char *)"GetNumberFromUser", (PyCFunction) _wrap_GetNumberFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
39157 { (char *)"ColourDisplay", (PyCFunction)_wrap_ColourDisplay, METH_NOARGS, NULL},
39158 { (char *)"DisplayDepth", (PyCFunction)_wrap_DisplayDepth, METH_NOARGS, NULL},
39159 { (char *)"GetDisplayDepth", (PyCFunction)_wrap_GetDisplayDepth, METH_NOARGS, NULL},
39160 { (char *)"DisplaySize", (PyCFunction)_wrap_DisplaySize, METH_NOARGS, NULL},
39161 { (char *)"GetDisplaySize", (PyCFunction)_wrap_GetDisplaySize, METH_NOARGS, NULL},
39162 { (char *)"DisplaySizeMM", (PyCFunction)_wrap_DisplaySizeMM, METH_NOARGS, NULL},
39163 { (char *)"GetDisplaySizeMM", (PyCFunction)_wrap_GetDisplaySizeMM, METH_NOARGS, NULL},
39164 { (char *)"ClientDisplayRect", (PyCFunction)_wrap_ClientDisplayRect, METH_NOARGS, NULL},
39165 { (char *)"GetClientDisplayRect", (PyCFunction)_wrap_GetClientDisplayRect, METH_NOARGS, NULL},
39166 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
39167 { (char *)"GetXDisplay", (PyCFunction)_wrap_GetXDisplay, METH_NOARGS, NULL},
39168 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
39169 { (char *)"GetMousePosition", (PyCFunction)_wrap_GetMousePosition, METH_NOARGS, NULL},
39170 { (char *)"FindWindowAtPointer", (PyCFunction)_wrap_FindWindowAtPointer, METH_NOARGS, NULL},
39171 { (char *)"GetActiveWindow", (PyCFunction)_wrap_GetActiveWindow, METH_NOARGS, NULL},
39172 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
39173 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
39174 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
39175 { (char *)"LaunchDefaultBrowser", (PyCFunction) _wrap_LaunchDefaultBrowser, METH_VARARGS | METH_KEYWORDS, NULL},
39176 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
39177 { (char *)"new_MouseState", (PyCFunction)_wrap_new_MouseState, METH_NOARGS, NULL},
39178 { (char *)"delete_MouseState", (PyCFunction)_wrap_delete_MouseState, METH_O, NULL},
39179 { (char *)"MouseState_GetX", (PyCFunction)_wrap_MouseState_GetX, METH_O, NULL},
39180 { (char *)"MouseState_GetY", (PyCFunction)_wrap_MouseState_GetY, METH_O, NULL},
39181 { (char *)"MouseState_LeftDown", (PyCFunction)_wrap_MouseState_LeftDown, METH_O, NULL},
39182 { (char *)"MouseState_MiddleDown", (PyCFunction)_wrap_MouseState_MiddleDown, METH_O, NULL},
39183 { (char *)"MouseState_RightDown", (PyCFunction)_wrap_MouseState_RightDown, METH_O, NULL},
39184 { (char *)"MouseState_ControlDown", (PyCFunction)_wrap_MouseState_ControlDown, METH_O, NULL},
39185 { (char *)"MouseState_ShiftDown", (PyCFunction)_wrap_MouseState_ShiftDown, METH_O, NULL},
39186 { (char *)"MouseState_AltDown", (PyCFunction)_wrap_MouseState_AltDown, METH_O, NULL},
39187 { (char *)"MouseState_MetaDown", (PyCFunction)_wrap_MouseState_MetaDown, METH_O, NULL},
39188 { (char *)"MouseState_CmdDown", (PyCFunction)_wrap_MouseState_CmdDown, METH_O, NULL},
39189 { (char *)"MouseState_SetX", (PyCFunction) _wrap_MouseState_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
39190 { (char *)"MouseState_SetY", (PyCFunction) _wrap_MouseState_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
39191 { (char *)"MouseState_SetLeftDown", (PyCFunction) _wrap_MouseState_SetLeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
39192 { (char *)"MouseState_SetMiddleDown", (PyCFunction) _wrap_MouseState_SetMiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
39193 { (char *)"MouseState_SetRightDown", (PyCFunction) _wrap_MouseState_SetRightDown, METH_VARARGS | METH_KEYWORDS, NULL},
39194 { (char *)"MouseState_SetControlDown", (PyCFunction) _wrap_MouseState_SetControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
39195 { (char *)"MouseState_SetShiftDown", (PyCFunction) _wrap_MouseState_SetShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
39196 { (char *)"MouseState_SetAltDown", (PyCFunction) _wrap_MouseState_SetAltDown, METH_VARARGS | METH_KEYWORDS, NULL},
39197 { (char *)"MouseState_SetMetaDown", (PyCFunction) _wrap_MouseState_SetMetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
39198 { (char *)"MouseState_swigregister", MouseState_swigregister, METH_VARARGS, NULL},
39199 { (char *)"MouseState_swiginit", MouseState_swiginit, METH_VARARGS, NULL},
39200 { (char *)"GetMouseState", (PyCFunction)_wrap_GetMouseState, METH_NOARGS, NULL},
39201 { (char *)"WakeUpMainThread", (PyCFunction)_wrap_WakeUpMainThread, METH_NOARGS, NULL},
39202 { (char *)"MutexGuiEnter", (PyCFunction)_wrap_MutexGuiEnter, METH_NOARGS, NULL},
39203 { (char *)"MutexGuiLeave", (PyCFunction)_wrap_MutexGuiLeave, METH_NOARGS, NULL},
39204 { (char *)"new_MutexGuiLocker", (PyCFunction)_wrap_new_MutexGuiLocker, METH_NOARGS, NULL},
39205 { (char *)"delete_MutexGuiLocker", (PyCFunction)_wrap_delete_MutexGuiLocker, METH_O, NULL},
39206 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
39207 { (char *)"MutexGuiLocker_swiginit", MutexGuiLocker_swiginit, METH_VARARGS, NULL},
39208 { (char *)"Thread_IsMain", (PyCFunction)_wrap_Thread_IsMain, METH_NOARGS, NULL},
39209 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
39210 { (char *)"delete_ToolTip", (PyCFunction)_wrap_delete_ToolTip, METH_O, NULL},
39211 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
39212 { (char *)"ToolTip_GetTip", (PyCFunction)_wrap_ToolTip_GetTip, METH_O, NULL},
39213 { (char *)"ToolTip_GetWindow", (PyCFunction)_wrap_ToolTip_GetWindow, METH_O, NULL},
39214 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
39215 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
39216 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
39217 { (char *)"ToolTip_swiginit", ToolTip_swiginit, METH_VARARGS, NULL},
39218 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
39219 { (char *)"delete_Caret", (PyCFunction)_wrap_delete_Caret, METH_O, NULL},
39220 { (char *)"Caret_Destroy", (PyCFunction)_wrap_Caret_Destroy, METH_O, NULL},
39221 { (char *)"Caret_IsOk", (PyCFunction)_wrap_Caret_IsOk, METH_O, NULL},
39222 { (char *)"Caret_IsVisible", (PyCFunction)_wrap_Caret_IsVisible, METH_O, NULL},
39223 { (char *)"Caret_GetPosition", (PyCFunction)_wrap_Caret_GetPosition, METH_O, NULL},
39224 { (char *)"Caret_GetPositionTuple", (PyCFunction)_wrap_Caret_GetPositionTuple, METH_O, NULL},
39225 { (char *)"Caret_GetSize", (PyCFunction)_wrap_Caret_GetSize, METH_O, NULL},
39226 { (char *)"Caret_GetSizeTuple", (PyCFunction)_wrap_Caret_GetSizeTuple, METH_O, NULL},
39227 { (char *)"Caret_GetWindow", (PyCFunction)_wrap_Caret_GetWindow, METH_O, NULL},
39228 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
39229 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
39230 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
39231 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
39232 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
39233 { (char *)"Caret_Hide", (PyCFunction)_wrap_Caret_Hide, METH_O, NULL},
39234 { (char *)"Caret_GetBlinkTime", (PyCFunction)_wrap_Caret_GetBlinkTime, METH_NOARGS, NULL},
39235 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
39236 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
39237 { (char *)"Caret_swiginit", Caret_swiginit, METH_VARARGS, NULL},
39238 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
39239 { (char *)"delete_BusyCursor", (PyCFunction)_wrap_delete_BusyCursor, METH_O, NULL},
39240 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
39241 { (char *)"BusyCursor_swiginit", BusyCursor_swiginit, METH_VARARGS, NULL},
39242 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
39243 { (char *)"delete_WindowDisabler", (PyCFunction)_wrap_delete_WindowDisabler, METH_O, NULL},
39244 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
39245 { (char *)"WindowDisabler_swiginit", WindowDisabler_swiginit, METH_VARARGS, NULL},
39246 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39247 { (char *)"delete_BusyInfo", (PyCFunction)_wrap_delete_BusyInfo, METH_O, NULL},
39248 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
39249 { (char *)"BusyInfo_swiginit", BusyInfo_swiginit, METH_VARARGS, NULL},
39250 { (char *)"new_StopWatch", (PyCFunction)_wrap_new_StopWatch, METH_NOARGS, NULL},
39251 { (char *)"delete_StopWatch", (PyCFunction)_wrap_delete_StopWatch, METH_O, NULL},
39252 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
39253 { (char *)"StopWatch_Pause", (PyCFunction)_wrap_StopWatch_Pause, METH_O, NULL},
39254 { (char *)"StopWatch_Resume", (PyCFunction)_wrap_StopWatch_Resume, METH_O, NULL},
39255 { (char *)"StopWatch_Time", (PyCFunction)_wrap_StopWatch_Time, METH_O, NULL},
39256 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
39257 { (char *)"StopWatch_swiginit", StopWatch_swiginit, METH_VARARGS, NULL},
39258 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
39259 { (char *)"delete_FileHistory", (PyCFunction)_wrap_delete_FileHistory, METH_O, NULL},
39260 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
39261 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
39262 { (char *)"FileHistory_GetMaxFiles", (PyCFunction)_wrap_FileHistory_GetMaxFiles, METH_O, NULL},
39263 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
39264 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
39265 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
39266 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
39267 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction)_wrap_FileHistory_AddFilesToMenu, METH_O, NULL},
39268 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
39269 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
39270 { (char *)"FileHistory_GetCount", (PyCFunction)_wrap_FileHistory_GetCount, METH_O, NULL},
39271 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
39272 { (char *)"FileHistory_swiginit", FileHistory_swiginit, METH_VARARGS, NULL},
39273 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
39274 { (char *)"new_PreSingleInstanceChecker", (PyCFunction)_wrap_new_PreSingleInstanceChecker, METH_NOARGS, NULL},
39275 { (char *)"delete_SingleInstanceChecker", (PyCFunction)_wrap_delete_SingleInstanceChecker, METH_O, NULL},
39276 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
39277 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction)_wrap_SingleInstanceChecker_IsAnotherRunning, METH_O, NULL},
39278 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
39279 { (char *)"SingleInstanceChecker_swiginit", SingleInstanceChecker_swiginit, METH_VARARGS, NULL},
39280 { (char *)"new_PlatformInformation", (PyCFunction)_wrap_new_PlatformInformation, METH_NOARGS, NULL},
39281 { (char *)"PlatformInformation___eq__", (PyCFunction) _wrap_PlatformInformation___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39282 { (char *)"PlatformInformation___ne__", (PyCFunction) _wrap_PlatformInformation___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39283 { (char *)"PlatformInformation_GetOSMajorVersion", (PyCFunction)_wrap_PlatformInformation_GetOSMajorVersion, METH_O, NULL},
39284 { (char *)"PlatformInformation_GetOSMinorVersion", (PyCFunction)_wrap_PlatformInformation_GetOSMinorVersion, METH_O, NULL},
39285 { (char *)"PlatformInformation_CheckOSVersion", (PyCFunction) _wrap_PlatformInformation_CheckOSVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39286 { (char *)"PlatformInformation_GetToolkitMajorVersion", (PyCFunction)_wrap_PlatformInformation_GetToolkitMajorVersion, METH_O, NULL},
39287 { (char *)"PlatformInformation_GetToolkitMinorVersion", (PyCFunction)_wrap_PlatformInformation_GetToolkitMinorVersion, METH_O, NULL},
39288 { (char *)"PlatformInformation_CheckToolkitVersion", (PyCFunction) _wrap_PlatformInformation_CheckToolkitVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39289 { (char *)"PlatformInformation_IsUsingUniversalWidgets", (PyCFunction)_wrap_PlatformInformation_IsUsingUniversalWidgets, METH_O, NULL},
39290 { (char *)"PlatformInformation_GetOperatingSystemId", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemId, METH_O, NULL},
39291 { (char *)"PlatformInformation_GetPortId", (PyCFunction)_wrap_PlatformInformation_GetPortId, METH_O, NULL},
39292 { (char *)"PlatformInformation_GetArchitecture", (PyCFunction)_wrap_PlatformInformation_GetArchitecture, METH_O, NULL},
39293 { (char *)"PlatformInformation_GetEndianness", (PyCFunction)_wrap_PlatformInformation_GetEndianness, METH_O, NULL},
39294 { (char *)"PlatformInformation_GetOperatingSystemFamilyName", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemFamilyName, METH_O, NULL},
39295 { (char *)"PlatformInformation_GetOperatingSystemIdName", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemIdName, METH_O, NULL},
39296 { (char *)"PlatformInformation_GetPortIdName", (PyCFunction)_wrap_PlatformInformation_GetPortIdName, METH_O, NULL},
39297 { (char *)"PlatformInformation_GetPortIdShortName", (PyCFunction)_wrap_PlatformInformation_GetPortIdShortName, METH_O, NULL},
39298 { (char *)"PlatformInformation_GetArchName", (PyCFunction)_wrap_PlatformInformation_GetArchName, METH_O, NULL},
39299 { (char *)"PlatformInformation_GetEndiannessName", (PyCFunction)_wrap_PlatformInformation_GetEndiannessName, METH_O, NULL},
39300 { (char *)"PlatformInformation_SetOSVersion", (PyCFunction) _wrap_PlatformInformation_SetOSVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39301 { (char *)"PlatformInformation_SetToolkitVersion", (PyCFunction) _wrap_PlatformInformation_SetToolkitVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39302 { (char *)"PlatformInformation_SetOperatingSystemId", (PyCFunction) _wrap_PlatformInformation_SetOperatingSystemId, METH_VARARGS | METH_KEYWORDS, NULL},
39303 { (char *)"PlatformInformation_SetPortId", (PyCFunction) _wrap_PlatformInformation_SetPortId, METH_VARARGS | METH_KEYWORDS, NULL},
39304 { (char *)"PlatformInformation_SetArchitecture", (PyCFunction) _wrap_PlatformInformation_SetArchitecture, METH_VARARGS | METH_KEYWORDS, NULL},
39305 { (char *)"PlatformInformation_SetEndianness", (PyCFunction) _wrap_PlatformInformation_SetEndianness, METH_VARARGS | METH_KEYWORDS, NULL},
39306 { (char *)"PlatformInformation_IsOk", (PyCFunction)_wrap_PlatformInformation_IsOk, METH_O, NULL},
39307 { (char *)"PlatformInformation_swigregister", PlatformInformation_swigregister, METH_VARARGS, NULL},
39308 { (char *)"PlatformInformation_swiginit", PlatformInformation_swiginit, METH_VARARGS, NULL},
39309 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
39310 { (char *)"delete_TipProvider", (PyCFunction)_wrap_delete_TipProvider, METH_O, NULL},
39311 { (char *)"TipProvider_GetTip", (PyCFunction)_wrap_TipProvider_GetTip, METH_O, NULL},
39312 { (char *)"TipProvider_GetCurrentTip", (PyCFunction)_wrap_TipProvider_GetCurrentTip, METH_O, NULL},
39313 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
39314 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
39315 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
39316 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39317 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
39318 { (char *)"PyTipProvider_swiginit", PyTipProvider_swiginit, METH_VARARGS, NULL},
39319 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
39320 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
39321 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
39322 { (char *)"delete_Timer", (PyCFunction)_wrap_delete_Timer, METH_O, NULL},
39323 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39324 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
39325 { (char *)"Timer_GetOwner", (PyCFunction)_wrap_Timer_GetOwner, METH_O, NULL},
39326 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
39327 { (char *)"Timer_Stop", (PyCFunction)_wrap_Timer_Stop, METH_O, NULL},
39328 { (char *)"Timer_Notify", (PyCFunction)_wrap_Timer_Notify, METH_O, NULL},
39329 { (char *)"Timer_IsRunning", (PyCFunction)_wrap_Timer_IsRunning, METH_O, NULL},
39330 { (char *)"Timer_GetInterval", (PyCFunction)_wrap_Timer_GetInterval, METH_O, NULL},
39331 { (char *)"Timer_GetId", (PyCFunction)_wrap_Timer_GetId, METH_O, NULL},
39332 { (char *)"Timer_IsOneShot", (PyCFunction)_wrap_Timer_IsOneShot, METH_O, NULL},
39333 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
39334 { (char *)"Timer_swiginit", Timer_swiginit, METH_VARARGS, NULL},
39335 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
39336 { (char *)"TimerEvent_GetInterval", (PyCFunction)_wrap_TimerEvent_GetInterval, METH_O, NULL},
39337 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
39338 { (char *)"TimerEvent_swiginit", TimerEvent_swiginit, METH_VARARGS, NULL},
39339 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
39340 { (char *)"delete_TimerRunner", (PyCFunction)_wrap_delete_TimerRunner, METH_O, NULL},
39341 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
39342 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
39343 { (char *)"TimerRunner_swiginit", TimerRunner_swiginit, METH_VARARGS, NULL},
39344 { (char *)"new_Log", (PyCFunction)_wrap_new_Log, METH_NOARGS, NULL},
39345 { (char *)"delete_Log", (PyCFunction)_wrap_delete_Log, METH_O, NULL},
39346 { (char *)"Log_IsEnabled", (PyCFunction)_wrap_Log_IsEnabled, METH_NOARGS, NULL},
39347 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
39348 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
39349 { (char *)"Log_Flush", (PyCFunction)_wrap_Log_Flush, METH_O, NULL},
39350 { (char *)"Log_FlushActive", (PyCFunction)_wrap_Log_FlushActive, METH_NOARGS, NULL},
39351 { (char *)"Log_GetActiveTarget", (PyCFunction)_wrap_Log_GetActiveTarget, METH_NOARGS, NULL},
39352 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
39353 { (char *)"Log_Suspend", (PyCFunction)_wrap_Log_Suspend, METH_NOARGS, NULL},
39354 { (char *)"Log_Resume", (PyCFunction)_wrap_Log_Resume, METH_NOARGS, NULL},
39355 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
39356 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
39357 { (char *)"Log_DontCreateOnDemand", (PyCFunction)_wrap_Log_DontCreateOnDemand, METH_NOARGS, NULL},
39358 { (char *)"Log_SetRepetitionCounting", (PyCFunction) _wrap_Log_SetRepetitionCounting, METH_VARARGS | METH_KEYWORDS, NULL},
39359 { (char *)"Log_GetRepetitionCounting", (PyCFunction)_wrap_Log_GetRepetitionCounting, METH_NOARGS, NULL},
39360 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39361 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39362 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39363 { (char *)"Log_ClearTraceMasks", (PyCFunction)_wrap_Log_ClearTraceMasks, METH_NOARGS, NULL},
39364 { (char *)"Log_GetTraceMasks", (PyCFunction)_wrap_Log_GetTraceMasks, METH_NOARGS, NULL},
39365 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
39366 { (char *)"Log_GetVerbose", (PyCFunction)_wrap_Log_GetVerbose, METH_NOARGS, NULL},
39367 { (char *)"Log_GetTraceMask", (PyCFunction)_wrap_Log_GetTraceMask, METH_NOARGS, NULL},
39368 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39369 { (char *)"Log_GetLogLevel", (PyCFunction)_wrap_Log_GetLogLevel, METH_NOARGS, NULL},
39370 { (char *)"Log_GetTimestamp", (PyCFunction)_wrap_Log_GetTimestamp, METH_NOARGS, NULL},
39371 { (char *)"Log_TimeStamp", (PyCFunction)_wrap_Log_TimeStamp, METH_NOARGS, NULL},
39372 { (char *)"Log_Destroy", (PyCFunction)_wrap_Log_Destroy, METH_O, NULL},
39373 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
39374 { (char *)"Log_swiginit", Log_swiginit, METH_VARARGS, NULL},
39375 { (char *)"new_LogStderr", (PyCFunction)_wrap_new_LogStderr, METH_NOARGS, NULL},
39376 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
39377 { (char *)"LogStderr_swiginit", LogStderr_swiginit, METH_VARARGS, NULL},
39378 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
39379 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
39380 { (char *)"LogTextCtrl_swiginit", LogTextCtrl_swiginit, METH_VARARGS, NULL},
39381 { (char *)"new_LogGui", (PyCFunction)_wrap_new_LogGui, METH_NOARGS, NULL},
39382 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
39383 { (char *)"LogGui_swiginit", LogGui_swiginit, METH_VARARGS, NULL},
39384 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
39385 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
39386 { (char *)"LogWindow_GetFrame", (PyCFunction)_wrap_LogWindow_GetFrame, METH_O, NULL},
39387 { (char *)"LogWindow_GetOldLog", (PyCFunction)_wrap_LogWindow_GetOldLog, METH_O, NULL},
39388 { (char *)"LogWindow_IsPassingMessages", (PyCFunction)_wrap_LogWindow_IsPassingMessages, METH_O, NULL},
39389 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
39390 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
39391 { (char *)"LogWindow_swiginit", LogWindow_swiginit, METH_VARARGS, NULL},
39392 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
39393 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
39394 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
39395 { (char *)"LogChain_IsPassingMessages", (PyCFunction)_wrap_LogChain_IsPassingMessages, METH_O, NULL},
39396 { (char *)"LogChain_GetOldLog", (PyCFunction)_wrap_LogChain_GetOldLog, METH_O, NULL},
39397 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
39398 { (char *)"LogChain_swiginit", LogChain_swiginit, METH_VARARGS, NULL},
39399 { (char *)"new_LogBuffer", (PyCFunction)_wrap_new_LogBuffer, METH_NOARGS, NULL},
39400 { (char *)"LogBuffer_GetBuffer", (PyCFunction)_wrap_LogBuffer_GetBuffer, METH_O, NULL},
39401 { (char *)"LogBuffer_swigregister", LogBuffer_swigregister, METH_VARARGS, NULL},
39402 { (char *)"LogBuffer_swiginit", LogBuffer_swiginit, METH_VARARGS, NULL},
39403 { (char *)"SysErrorCode", (PyCFunction)_wrap_SysErrorCode, METH_NOARGS, NULL},
39404 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
39405 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
39406 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
39407 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
39408 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
39409 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39410 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
39411 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
39412 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
39413 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
39414 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
39415 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
39416 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
39417 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
39418 { (char *)"new_LogNull", (PyCFunction)_wrap_new_LogNull, METH_NOARGS, NULL},
39419 { (char *)"delete_LogNull", (PyCFunction)_wrap_delete_LogNull, METH_O, NULL},
39420 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
39421 { (char *)"LogNull_swiginit", LogNull_swiginit, METH_VARARGS, NULL},
39422 { (char *)"new_PyLog", (PyCFunction)_wrap_new_PyLog, METH_NOARGS, NULL},
39423 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39424 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
39425 { (char *)"PyLog_swiginit", PyLog_swiginit, METH_VARARGS, NULL},
39426 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
39427 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
39428 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
39429 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
39430 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39431 { (char *)"Process_OnTerminate", (PyCFunction) _wrap_Process_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
39432 { (char *)"Process_Redirect", (PyCFunction)_wrap_Process_Redirect, METH_O, NULL},
39433 { (char *)"Process_IsRedirected", (PyCFunction)_wrap_Process_IsRedirected, METH_O, NULL},
39434 { (char *)"Process_Detach", (PyCFunction)_wrap_Process_Detach, METH_O, NULL},
39435 { (char *)"Process_GetInputStream", (PyCFunction)_wrap_Process_GetInputStream, METH_O, NULL},
39436 { (char *)"Process_GetErrorStream", (PyCFunction)_wrap_Process_GetErrorStream, METH_O, NULL},
39437 { (char *)"Process_GetOutputStream", (PyCFunction)_wrap_Process_GetOutputStream, METH_O, NULL},
39438 { (char *)"Process_CloseOutput", (PyCFunction)_wrap_Process_CloseOutput, METH_O, NULL},
39439 { (char *)"Process_IsInputOpened", (PyCFunction)_wrap_Process_IsInputOpened, METH_O, NULL},
39440 { (char *)"Process_IsInputAvailable", (PyCFunction)_wrap_Process_IsInputAvailable, METH_O, NULL},
39441 { (char *)"Process_IsErrorAvailable", (PyCFunction)_wrap_Process_IsErrorAvailable, METH_O, NULL},
39442 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
39443 { (char *)"Process_swiginit", Process_swiginit, METH_VARARGS, NULL},
39444 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
39445 { (char *)"ProcessEvent_GetPid", (PyCFunction)_wrap_ProcessEvent_GetPid, METH_O, NULL},
39446 { (char *)"ProcessEvent_GetExitCode", (PyCFunction)_wrap_ProcessEvent_GetExitCode, METH_O, NULL},
39447 { (char *)"ProcessEvent_m_pid_set", _wrap_ProcessEvent_m_pid_set, METH_VARARGS, NULL},
39448 { (char *)"ProcessEvent_m_pid_get", (PyCFunction)_wrap_ProcessEvent_m_pid_get, METH_O, NULL},
39449 { (char *)"ProcessEvent_m_exitcode_set", _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS, NULL},
39450 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction)_wrap_ProcessEvent_m_exitcode_get, METH_O, NULL},
39451 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
39452 { (char *)"ProcessEvent_swiginit", ProcessEvent_swiginit, METH_VARARGS, NULL},
39453 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
39454 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
39455 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
39456 { (char *)"delete_Joystick", (PyCFunction)_wrap_delete_Joystick, METH_O, NULL},
39457 { (char *)"Joystick_GetPosition", (PyCFunction)_wrap_Joystick_GetPosition, METH_O, NULL},
39458 { (char *)"Joystick_GetZPosition", (PyCFunction)_wrap_Joystick_GetZPosition, METH_O, NULL},
39459 { (char *)"Joystick_GetButtonState", (PyCFunction)_wrap_Joystick_GetButtonState, METH_O, NULL},
39460 { (char *)"Joystick_GetPOVPosition", (PyCFunction)_wrap_Joystick_GetPOVPosition, METH_O, NULL},
39461 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction)_wrap_Joystick_GetPOVCTSPosition, METH_O, NULL},
39462 { (char *)"Joystick_GetRudderPosition", (PyCFunction)_wrap_Joystick_GetRudderPosition, METH_O, NULL},
39463 { (char *)"Joystick_GetUPosition", (PyCFunction)_wrap_Joystick_GetUPosition, METH_O, NULL},
39464 { (char *)"Joystick_GetVPosition", (PyCFunction)_wrap_Joystick_GetVPosition, METH_O, NULL},
39465 { (char *)"Joystick_GetMovementThreshold", (PyCFunction)_wrap_Joystick_GetMovementThreshold, METH_O, NULL},
39466 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
39467 { (char *)"Joystick_IsOk", (PyCFunction)_wrap_Joystick_IsOk, METH_O, NULL},
39468 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction)_wrap_Joystick_GetNumberJoysticks, METH_O, NULL},
39469 { (char *)"Joystick_GetManufacturerId", (PyCFunction)_wrap_Joystick_GetManufacturerId, METH_O, NULL},
39470 { (char *)"Joystick_GetProductId", (PyCFunction)_wrap_Joystick_GetProductId, METH_O, NULL},
39471 { (char *)"Joystick_GetProductName", (PyCFunction)_wrap_Joystick_GetProductName, METH_O, NULL},
39472 { (char *)"Joystick_GetXMin", (PyCFunction)_wrap_Joystick_GetXMin, METH_O, NULL},
39473 { (char *)"Joystick_GetYMin", (PyCFunction)_wrap_Joystick_GetYMin, METH_O, NULL},
39474 { (char *)"Joystick_GetZMin", (PyCFunction)_wrap_Joystick_GetZMin, METH_O, NULL},
39475 { (char *)"Joystick_GetXMax", (PyCFunction)_wrap_Joystick_GetXMax, METH_O, NULL},
39476 { (char *)"Joystick_GetYMax", (PyCFunction)_wrap_Joystick_GetYMax, METH_O, NULL},
39477 { (char *)"Joystick_GetZMax", (PyCFunction)_wrap_Joystick_GetZMax, METH_O, NULL},
39478 { (char *)"Joystick_GetNumberButtons", (PyCFunction)_wrap_Joystick_GetNumberButtons, METH_O, NULL},
39479 { (char *)"Joystick_GetNumberAxes", (PyCFunction)_wrap_Joystick_GetNumberAxes, METH_O, NULL},
39480 { (char *)"Joystick_GetMaxButtons", (PyCFunction)_wrap_Joystick_GetMaxButtons, METH_O, NULL},
39481 { (char *)"Joystick_GetMaxAxes", (PyCFunction)_wrap_Joystick_GetMaxAxes, METH_O, NULL},
39482 { (char *)"Joystick_GetPollingMin", (PyCFunction)_wrap_Joystick_GetPollingMin, METH_O, NULL},
39483 { (char *)"Joystick_GetPollingMax", (PyCFunction)_wrap_Joystick_GetPollingMax, METH_O, NULL},
39484 { (char *)"Joystick_GetRudderMin", (PyCFunction)_wrap_Joystick_GetRudderMin, METH_O, NULL},
39485 { (char *)"Joystick_GetRudderMax", (PyCFunction)_wrap_Joystick_GetRudderMax, METH_O, NULL},
39486 { (char *)"Joystick_GetUMin", (PyCFunction)_wrap_Joystick_GetUMin, METH_O, NULL},
39487 { (char *)"Joystick_GetUMax", (PyCFunction)_wrap_Joystick_GetUMax, METH_O, NULL},
39488 { (char *)"Joystick_GetVMin", (PyCFunction)_wrap_Joystick_GetVMin, METH_O, NULL},
39489 { (char *)"Joystick_GetVMax", (PyCFunction)_wrap_Joystick_GetVMax, METH_O, NULL},
39490 { (char *)"Joystick_HasRudder", (PyCFunction)_wrap_Joystick_HasRudder, METH_O, NULL},
39491 { (char *)"Joystick_HasZ", (PyCFunction)_wrap_Joystick_HasZ, METH_O, NULL},
39492 { (char *)"Joystick_HasU", (PyCFunction)_wrap_Joystick_HasU, METH_O, NULL},
39493 { (char *)"Joystick_HasV", (PyCFunction)_wrap_Joystick_HasV, METH_O, NULL},
39494 { (char *)"Joystick_HasPOV", (PyCFunction)_wrap_Joystick_HasPOV, METH_O, NULL},
39495 { (char *)"Joystick_HasPOV4Dir", (PyCFunction)_wrap_Joystick_HasPOV4Dir, METH_O, NULL},
39496 { (char *)"Joystick_HasPOVCTS", (PyCFunction)_wrap_Joystick_HasPOVCTS, METH_O, NULL},
39497 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
39498 { (char *)"Joystick_ReleaseCapture", (PyCFunction)_wrap_Joystick_ReleaseCapture, METH_O, NULL},
39499 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
39500 { (char *)"Joystick_swiginit", Joystick_swiginit, METH_VARARGS, NULL},
39501 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
39502 { (char *)"JoystickEvent_GetPosition", (PyCFunction)_wrap_JoystickEvent_GetPosition, METH_O, NULL},
39503 { (char *)"JoystickEvent_GetZPosition", (PyCFunction)_wrap_JoystickEvent_GetZPosition, METH_O, NULL},
39504 { (char *)"JoystickEvent_GetButtonState", (PyCFunction)_wrap_JoystickEvent_GetButtonState, METH_O, NULL},
39505 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction)_wrap_JoystickEvent_GetButtonChange, METH_O, NULL},
39506 { (char *)"JoystickEvent_GetJoystick", (PyCFunction)_wrap_JoystickEvent_GetJoystick, METH_O, NULL},
39507 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
39508 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
39509 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
39510 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
39511 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
39512 { (char *)"JoystickEvent_IsButton", (PyCFunction)_wrap_JoystickEvent_IsButton, METH_O, NULL},
39513 { (char *)"JoystickEvent_IsMove", (PyCFunction)_wrap_JoystickEvent_IsMove, METH_O, NULL},
39514 { (char *)"JoystickEvent_IsZMove", (PyCFunction)_wrap_JoystickEvent_IsZMove, METH_O, NULL},
39515 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
39516 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
39517 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
39518 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
39519 { (char *)"JoystickEvent_swiginit", JoystickEvent_swiginit, METH_VARARGS, NULL},
39520 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
39521 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
39522 { (char *)"delete_Sound", (PyCFunction)_wrap_delete_Sound, METH_O, NULL},
39523 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
39524 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
39525 { (char *)"Sound_IsOk", (PyCFunction)_wrap_Sound_IsOk, METH_O, NULL},
39526 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
39527 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
39528 { (char *)"Sound_Stop", (PyCFunction)_wrap_Sound_Stop, METH_NOARGS, NULL},
39529 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
39530 { (char *)"Sound_swiginit", Sound_swiginit, METH_VARARGS, NULL},
39531 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39532 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
39533 { (char *)"new_NullFileTypeInfo", (PyCFunction)_wrap_new_NullFileTypeInfo, METH_NOARGS, NULL},
39534 { (char *)"FileTypeInfo_IsValid", (PyCFunction)_wrap_FileTypeInfo_IsValid, METH_O, NULL},
39535 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
39536 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
39537 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction)_wrap_FileTypeInfo_GetMimeType, METH_O, NULL},
39538 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction)_wrap_FileTypeInfo_GetOpenCommand, METH_O, NULL},
39539 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction)_wrap_FileTypeInfo_GetPrintCommand, METH_O, NULL},
39540 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction)_wrap_FileTypeInfo_GetShortDesc, METH_O, NULL},
39541 { (char *)"FileTypeInfo_GetDescription", (PyCFunction)_wrap_FileTypeInfo_GetDescription, METH_O, NULL},
39542 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction)_wrap_FileTypeInfo_GetExtensions, METH_O, NULL},
39543 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction)_wrap_FileTypeInfo_GetExtensionsCount, METH_O, NULL},
39544 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction)_wrap_FileTypeInfo_GetIconFile, METH_O, NULL},
39545 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction)_wrap_FileTypeInfo_GetIconIndex, METH_O, NULL},
39546 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
39547 { (char *)"FileTypeInfo_swiginit", FileTypeInfo_swiginit, METH_VARARGS, NULL},
39548 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
39549 { (char *)"delete_FileType", (PyCFunction)_wrap_delete_FileType, METH_O, NULL},
39550 { (char *)"FileType_GetMimeType", (PyCFunction)_wrap_FileType_GetMimeType, METH_O, NULL},
39551 { (char *)"FileType_GetMimeTypes", (PyCFunction)_wrap_FileType_GetMimeTypes, METH_O, NULL},
39552 { (char *)"FileType_GetExtensions", (PyCFunction)_wrap_FileType_GetExtensions, METH_O, NULL},
39553 { (char *)"FileType_GetIcon", (PyCFunction)_wrap_FileType_GetIcon, METH_O, NULL},
39554 { (char *)"FileType_GetIconInfo", (PyCFunction)_wrap_FileType_GetIconInfo, METH_O, NULL},
39555 { (char *)"FileType_GetDescription", (PyCFunction)_wrap_FileType_GetDescription, METH_O, NULL},
39556 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39557 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39558 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
39559 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39560 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
39561 { (char *)"FileType_Unassociate", (PyCFunction)_wrap_FileType_Unassociate, METH_O, NULL},
39562 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39563 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
39564 { (char *)"FileType_swiginit", FileType_swiginit, METH_VARARGS, NULL},
39565 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
39566 { (char *)"new_MimeTypesManager", (PyCFunction)_wrap_new_MimeTypesManager, METH_NOARGS, NULL},
39567 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
39568 { (char *)"MimeTypesManager_ClearData", (PyCFunction)_wrap_MimeTypesManager_ClearData, METH_O, NULL},
39569 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
39570 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
39571 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
39572 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
39573 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction)_wrap_MimeTypesManager_EnumAllFileTypes, METH_O, NULL},
39574 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
39575 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
39576 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
39577 { (char *)"delete_MimeTypesManager", (PyCFunction)_wrap_delete_MimeTypesManager, METH_O, NULL},
39578 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
39579 { (char *)"MimeTypesManager_swiginit", MimeTypesManager_swiginit, METH_VARARGS, NULL},
39580 { (char *)"new_ArtProvider", (PyCFunction)_wrap_new_ArtProvider, METH_NOARGS, NULL},
39581 { (char *)"delete_ArtProvider", (PyCFunction)_wrap_delete_ArtProvider, METH_O, NULL},
39582 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39583 { (char *)"ArtProvider_Push", (PyCFunction) _wrap_ArtProvider_Push, METH_VARARGS | METH_KEYWORDS, NULL},
39584 { (char *)"ArtProvider_Insert", (PyCFunction) _wrap_ArtProvider_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
39585 { (char *)"ArtProvider_Pop", (PyCFunction)_wrap_ArtProvider_Pop, METH_NOARGS, NULL},
39586 { (char *)"ArtProvider_Delete", (PyCFunction) _wrap_ArtProvider_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
39587 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
39588 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
39589 { (char *)"ArtProvider_GetSizeHint", (PyCFunction) _wrap_ArtProvider_GetSizeHint, METH_VARARGS | METH_KEYWORDS, NULL},
39590 { (char *)"ArtProvider_Destroy", (PyCFunction)_wrap_ArtProvider_Destroy, METH_O, NULL},
39591 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
39592 { (char *)"ArtProvider_swiginit", ArtProvider_swiginit, METH_VARARGS, NULL},
39593 { (char *)"delete_ConfigBase", (PyCFunction)_wrap_delete_ConfigBase, METH_O, NULL},
39594 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
39595 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
39596 { (char *)"ConfigBase_Create", (PyCFunction)_wrap_ConfigBase_Create, METH_NOARGS, NULL},
39597 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction)_wrap_ConfigBase_DontCreateOnDemand, METH_NOARGS, NULL},
39598 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
39599 { (char *)"ConfigBase_GetPath", (PyCFunction)_wrap_ConfigBase_GetPath, METH_O, NULL},
39600 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction)_wrap_ConfigBase_GetFirstGroup, METH_O, NULL},
39601 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39602 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction)_wrap_ConfigBase_GetFirstEntry, METH_O, NULL},
39603 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39604 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
39605 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
39606 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39607 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39608 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
39609 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
39610 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
39611 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
39612 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
39613 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
39614 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
39615 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
39616 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
39617 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
39618 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
39619 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39620 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39621 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39622 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39623 { (char *)"ConfigBase_DeleteAll", (PyCFunction)_wrap_ConfigBase_DeleteAll, METH_O, NULL},
39624 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
39625 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction)_wrap_ConfigBase_IsExpandingEnvVars, METH_O, NULL},
39626 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
39627 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction)_wrap_ConfigBase_IsRecordingDefaults, METH_O, NULL},
39628 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
39629 { (char *)"ConfigBase_GetAppName", (PyCFunction)_wrap_ConfigBase_GetAppName, METH_O, NULL},
39630 { (char *)"ConfigBase_GetVendorName", (PyCFunction)_wrap_ConfigBase_GetVendorName, METH_O, NULL},
39631 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
39632 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
39633 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
39634 { (char *)"ConfigBase_GetStyle", (PyCFunction)_wrap_ConfigBase_GetStyle, METH_O, NULL},
39635 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
39636 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
39637 { (char *)"delete_Config", (PyCFunction)_wrap_delete_Config, METH_O, NULL},
39638 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
39639 { (char *)"Config_swiginit", Config_swiginit, METH_VARARGS, NULL},
39640 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
39641 { (char *)"delete_FileConfig", (PyCFunction)_wrap_delete_FileConfig, METH_O, NULL},
39642 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
39643 { (char *)"FileConfig_swiginit", FileConfig_swiginit, METH_VARARGS, NULL},
39644 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
39645 { (char *)"delete_ConfigPathChanger", (PyCFunction)_wrap_delete_ConfigPathChanger, METH_O, NULL},
39646 { (char *)"ConfigPathChanger_Name", (PyCFunction)_wrap_ConfigPathChanger_Name, METH_O, NULL},
39647 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
39648 { (char *)"ConfigPathChanger_swiginit", ConfigPathChanger_swiginit, METH_VARARGS, NULL},
39649 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
39650 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
39651 { (char *)"DateTime_GetCountry", (PyCFunction)_wrap_DateTime_GetCountry, METH_NOARGS, NULL},
39652 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
39653 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
39654 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
39655 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39656 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
39657 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
39658 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
39659 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39660 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
39661 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
39662 { (char *)"DateTime_GetAmPmStrings", (PyCFunction)_wrap_DateTime_GetAmPmStrings, METH_NOARGS, NULL},
39663 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
39664 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
39665 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
39666 { (char *)"DateTime_Now", (PyCFunction)_wrap_DateTime_Now, METH_NOARGS, NULL},
39667 { (char *)"DateTime_UNow", (PyCFunction)_wrap_DateTime_UNow, METH_NOARGS, NULL},
39668 { (char *)"DateTime_Today", (PyCFunction)_wrap_DateTime_Today, METH_NOARGS, NULL},
39669 { (char *)"new_DateTime", (PyCFunction)_wrap_new_DateTime, METH_NOARGS, NULL},
39670 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
39671 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
39672 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
39673 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
39674 { (char *)"new_DateTimeFromDateTime", (PyCFunction) _wrap_new_DateTimeFromDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
39675 { (char *)"delete_DateTime", (PyCFunction)_wrap_delete_DateTime, METH_O, NULL},
39676 { (char *)"DateTime_SetToCurrent", (PyCFunction)_wrap_DateTime_SetToCurrent, METH_O, NULL},
39677 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
39678 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
39679 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
39680 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
39681 { (char *)"DateTime_ResetTime", (PyCFunction)_wrap_DateTime_ResetTime, METH_O, NULL},
39682 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
39683 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39684 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
39685 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
39686 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
39687 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
39688 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
39689 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
39690 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
39691 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39692 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39693 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39694 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39695 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39696 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39697 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39698 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
39699 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
39700 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
39701 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
39702 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
39703 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
39704 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
39705 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction)_wrap_DateTime_GetJulianDayNumber, METH_O, NULL},
39706 { (char *)"DateTime_GetJDN", (PyCFunction)_wrap_DateTime_GetJDN, METH_O, NULL},
39707 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction)_wrap_DateTime_GetModifiedJulianDayNumber, METH_O, NULL},
39708 { (char *)"DateTime_GetMJD", (PyCFunction)_wrap_DateTime_GetMJD, METH_O, NULL},
39709 { (char *)"DateTime_GetRataDie", (PyCFunction)_wrap_DateTime_GetRataDie, METH_O, NULL},
39710 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39711 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39712 { (char *)"DateTime_FromTimezone", (PyCFunction) _wrap_DateTime_FromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39713 { (char *)"DateTime_MakeFromTimezone", (PyCFunction) _wrap_DateTime_MakeFromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39714 { (char *)"DateTime_ToUTC", (PyCFunction) _wrap_DateTime_ToUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39715 { (char *)"DateTime_MakeUTC", (PyCFunction) _wrap_DateTime_MakeUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39716 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
39717 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
39718 { (char *)"DateTime_FromUTC", (PyCFunction) _wrap_DateTime_FromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39719 { (char *)"DateTime_MakeFromUTC", (PyCFunction) _wrap_DateTime_MakeFromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39720 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
39721 { (char *)"DateTime_IsValid", (PyCFunction)_wrap_DateTime_IsValid, METH_O, NULL},
39722 { (char *)"DateTime_GetTicks", (PyCFunction)_wrap_DateTime_GetTicks, METH_O, NULL},
39723 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
39724 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39725 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
39726 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39727 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
39728 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
39729 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
39730 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
39731 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
39732 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
39733 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39734 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
39735 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
39736 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
39737 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
39738 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
39739 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
39740 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
39741 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
39742 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
39743 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
39744 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
39745 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
39746 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
39747 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
39748 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
39749 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
39750 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
39751 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
39752 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
39753 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
39754 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
39755 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
39756 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39757 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39758 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
39759 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39760 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
39761 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
39762 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
39763 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
39764 { (char *)"DateTime_FormatDate", (PyCFunction)_wrap_DateTime_FormatDate, METH_O, NULL},
39765 { (char *)"DateTime_FormatTime", (PyCFunction)_wrap_DateTime_FormatTime, METH_O, NULL},
39766 { (char *)"DateTime_FormatISODate", (PyCFunction)_wrap_DateTime_FormatISODate, METH_O, NULL},
39767 { (char *)"DateTime_FormatISOTime", (PyCFunction)_wrap_DateTime_FormatISOTime, METH_O, NULL},
39768 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
39769 { (char *)"DateTime_swiginit", DateTime_swiginit, METH_VARARGS, NULL},
39770 { (char *)"TimeSpan_Milliseconds", (PyCFunction) _wrap_TimeSpan_Milliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
39771 { (char *)"TimeSpan_Millisecond", (PyCFunction)_wrap_TimeSpan_Millisecond, METH_NOARGS, NULL},
39772 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
39773 { (char *)"TimeSpan_Second", (PyCFunction)_wrap_TimeSpan_Second, METH_NOARGS, NULL},
39774 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
39775 { (char *)"TimeSpan_Minute", (PyCFunction)_wrap_TimeSpan_Minute, METH_NOARGS, NULL},
39776 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
39777 { (char *)"TimeSpan_Hour", (PyCFunction)_wrap_TimeSpan_Hour, METH_NOARGS, NULL},
39778 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
39779 { (char *)"TimeSpan_Day", (PyCFunction)_wrap_TimeSpan_Day, METH_NOARGS, NULL},
39780 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
39781 { (char *)"TimeSpan_Week", (PyCFunction)_wrap_TimeSpan_Week, METH_NOARGS, NULL},
39782 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
39783 { (char *)"delete_TimeSpan", (PyCFunction)_wrap_delete_TimeSpan, METH_O, NULL},
39784 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
39785 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
39786 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
39787 { (char *)"TimeSpan_Neg", (PyCFunction)_wrap_TimeSpan_Neg, METH_O, NULL},
39788 { (char *)"TimeSpan_Abs", (PyCFunction)_wrap_TimeSpan_Abs, METH_O, NULL},
39789 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
39790 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
39791 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
39792 { (char *)"TimeSpan___neg__", (PyCFunction)_wrap_TimeSpan___neg__, METH_O, NULL},
39793 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
39794 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
39795 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
39796 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
39797 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
39798 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
39799 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
39800 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
39801 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39802 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39803 { (char *)"TimeSpan_IsNull", (PyCFunction)_wrap_TimeSpan_IsNull, METH_O, NULL},
39804 { (char *)"TimeSpan_IsPositive", (PyCFunction)_wrap_TimeSpan_IsPositive, METH_O, NULL},
39805 { (char *)"TimeSpan_IsNegative", (PyCFunction)_wrap_TimeSpan_IsNegative, METH_O, NULL},
39806 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
39807 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
39808 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
39809 { (char *)"TimeSpan_GetWeeks", (PyCFunction)_wrap_TimeSpan_GetWeeks, METH_O, NULL},
39810 { (char *)"TimeSpan_GetDays", (PyCFunction)_wrap_TimeSpan_GetDays, METH_O, NULL},
39811 { (char *)"TimeSpan_GetHours", (PyCFunction)_wrap_TimeSpan_GetHours, METH_O, NULL},
39812 { (char *)"TimeSpan_GetMinutes", (PyCFunction)_wrap_TimeSpan_GetMinutes, METH_O, NULL},
39813 { (char *)"TimeSpan_GetSeconds", (PyCFunction)_wrap_TimeSpan_GetSeconds, METH_O, NULL},
39814 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction)_wrap_TimeSpan_GetMilliseconds, METH_O, NULL},
39815 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
39816 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
39817 { (char *)"TimeSpan_swiginit", TimeSpan_swiginit, METH_VARARGS, NULL},
39818 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
39819 { (char *)"delete_DateSpan", (PyCFunction)_wrap_delete_DateSpan, METH_O, NULL},
39820 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
39821 { (char *)"DateSpan_Day", (PyCFunction)_wrap_DateSpan_Day, METH_NOARGS, NULL},
39822 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
39823 { (char *)"DateSpan_Week", (PyCFunction)_wrap_DateSpan_Week, METH_NOARGS, NULL},
39824 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
39825 { (char *)"DateSpan_Month", (PyCFunction)_wrap_DateSpan_Month, METH_NOARGS, NULL},
39826 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
39827 { (char *)"DateSpan_Year", (PyCFunction)_wrap_DateSpan_Year, METH_NOARGS, NULL},
39828 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
39829 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
39830 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
39831 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
39832 { (char *)"DateSpan_GetYears", (PyCFunction)_wrap_DateSpan_GetYears, METH_O, NULL},
39833 { (char *)"DateSpan_GetMonths", (PyCFunction)_wrap_DateSpan_GetMonths, METH_O, NULL},
39834 { (char *)"DateSpan_GetWeeks", (PyCFunction)_wrap_DateSpan_GetWeeks, METH_O, NULL},
39835 { (char *)"DateSpan_GetDays", (PyCFunction)_wrap_DateSpan_GetDays, METH_O, NULL},
39836 { (char *)"DateSpan_GetTotalDays", (PyCFunction)_wrap_DateSpan_GetTotalDays, METH_O, NULL},
39837 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
39838 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
39839 { (char *)"DateSpan_Neg", (PyCFunction)_wrap_DateSpan_Neg, METH_O, NULL},
39840 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
39841 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
39842 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
39843 { (char *)"DateSpan___neg__", (PyCFunction)_wrap_DateSpan___neg__, METH_O, NULL},
39844 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
39845 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
39846 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
39847 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
39848 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
39849 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39850 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39851 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
39852 { (char *)"DateSpan_swiginit", DateSpan_swiginit, METH_VARARGS, NULL},
39853 { (char *)"GetLocalTime", (PyCFunction)_wrap_GetLocalTime, METH_NOARGS, NULL},
39854 { (char *)"GetUTCTime", (PyCFunction)_wrap_GetUTCTime, METH_NOARGS, NULL},
39855 { (char *)"GetCurrentTime", (PyCFunction)_wrap_GetCurrentTime, METH_NOARGS, NULL},
39856 { (char *)"GetLocalTimeMillis", (PyCFunction)_wrap_GetLocalTimeMillis, METH_NOARGS, NULL},
39857 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39858 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39859 { (char *)"delete_DataFormat", (PyCFunction)_wrap_delete_DataFormat, METH_O, NULL},
39860 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
39861 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
39862 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
39863 { (char *)"DataFormat_GetType", (PyCFunction)_wrap_DataFormat_GetType, METH_O, NULL},
39864 { (char *)"DataFormat_GetId", (PyCFunction)_wrap_DataFormat_GetId, METH_O, NULL},
39865 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
39866 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
39867 { (char *)"DataFormat_swiginit", DataFormat_swiginit, METH_VARARGS, NULL},
39868 { (char *)"delete_DataObject", (PyCFunction)_wrap_delete_DataObject, METH_O, NULL},
39869 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39870 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
39871 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
39872 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
39873 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
39874 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
39875 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
39876 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
39877 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
39878 { (char *)"DataObjectSimple_GetFormat", (PyCFunction)_wrap_DataObjectSimple_GetFormat, METH_O, NULL},
39879 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39880 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction)_wrap_DataObjectSimple_GetDataSize, METH_O, NULL},
39881 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction)_wrap_DataObjectSimple_GetDataHere, METH_O, NULL},
39882 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
39883 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
39884 { (char *)"DataObjectSimple_swiginit", DataObjectSimple_swiginit, METH_VARARGS, NULL},
39885 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
39886 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39887 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
39888 { (char *)"PyDataObjectSimple_swiginit", PyDataObjectSimple_swiginit, METH_VARARGS, NULL},
39889 { (char *)"new_DataObjectComposite", (PyCFunction)_wrap_new_DataObjectComposite, METH_NOARGS, NULL},
39890 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
39891 { (char *)"DataObjectComposite_GetReceivedFormat", (PyCFunction)_wrap_DataObjectComposite_GetReceivedFormat, METH_O, NULL},
39892 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
39893 { (char *)"DataObjectComposite_swiginit", DataObjectComposite_swiginit, METH_VARARGS, NULL},
39894 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
39895 { (char *)"TextDataObject_GetTextLength", (PyCFunction)_wrap_TextDataObject_GetTextLength, METH_O, NULL},
39896 { (char *)"TextDataObject_GetText", (PyCFunction)_wrap_TextDataObject_GetText, METH_O, NULL},
39897 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
39898 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
39899 { (char *)"TextDataObject_swiginit", TextDataObject_swiginit, METH_VARARGS, NULL},
39900 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
39901 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39902 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
39903 { (char *)"PyTextDataObject_swiginit", PyTextDataObject_swiginit, METH_VARARGS, NULL},
39904 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
39905 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction)_wrap_BitmapDataObject_GetBitmap, METH_O, NULL},
39906 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
39907 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
39908 { (char *)"BitmapDataObject_swiginit", BitmapDataObject_swiginit, METH_VARARGS, NULL},
39909 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
39910 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39911 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
39912 { (char *)"PyBitmapDataObject_swiginit", PyBitmapDataObject_swiginit, METH_VARARGS, NULL},
39913 { (char *)"new_FileDataObject", (PyCFunction)_wrap_new_FileDataObject, METH_NOARGS, NULL},
39914 { (char *)"FileDataObject_GetFilenames", (PyCFunction)_wrap_FileDataObject_GetFilenames, METH_O, NULL},
39915 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
39916 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
39917 { (char *)"FileDataObject_swiginit", FileDataObject_swiginit, METH_VARARGS, NULL},
39918 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
39919 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
39920 { (char *)"CustomDataObject_GetSize", (PyCFunction)_wrap_CustomDataObject_GetSize, METH_O, NULL},
39921 { (char *)"CustomDataObject_GetData", (PyCFunction)_wrap_CustomDataObject_GetData, METH_O, NULL},
39922 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
39923 { (char *)"CustomDataObject_swiginit", CustomDataObject_swiginit, METH_VARARGS, NULL},
39924 { (char *)"new_URLDataObject", (PyCFunction) _wrap_new_URLDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
39925 { (char *)"URLDataObject_GetURL", (PyCFunction)_wrap_URLDataObject_GetURL, METH_O, NULL},
39926 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
39927 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
39928 { (char *)"URLDataObject_swiginit", URLDataObject_swiginit, METH_VARARGS, NULL},
39929 { (char *)"new_MetafileDataObject", (PyCFunction)_wrap_new_MetafileDataObject, METH_NOARGS, NULL},
39930 { (char *)"MetafileDataObject_SetMetafile", (PyCFunction) _wrap_MetafileDataObject_SetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
39931 { (char *)"MetafileDataObject_GetMetafile", (PyCFunction)_wrap_MetafileDataObject_GetMetafile, METH_O, NULL},
39932 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
39933 { (char *)"MetafileDataObject_swiginit", MetafileDataObject_swiginit, METH_VARARGS, NULL},
39934 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
39935 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
39936 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39937 { (char *)"delete_DropSource", (PyCFunction)_wrap_delete_DropSource, METH_O, NULL},
39938 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
39939 { (char *)"DropSource_GetDataObject", (PyCFunction)_wrap_DropSource_GetDataObject, METH_O, NULL},
39940 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
39941 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
39942 { (char *)"DropSource_GiveFeedback", (PyCFunction) _wrap_DropSource_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
39943 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
39944 { (char *)"DropSource_swiginit", DropSource_swiginit, METH_VARARGS, NULL},
39945 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
39946 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39947 { (char *)"delete_DropTarget", (PyCFunction)_wrap_delete_DropTarget, METH_O, NULL},
39948 { (char *)"DropTarget_GetDataObject", (PyCFunction)_wrap_DropTarget_GetDataObject, METH_O, NULL},
39949 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
39950 { (char *)"DropTarget_OnEnter", (PyCFunction) _wrap_DropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
39951 { (char *)"DropTarget_OnDragOver", (PyCFunction) _wrap_DropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
39952 { (char *)"DropTarget_OnLeave", (PyCFunction)_wrap_DropTarget_OnLeave, METH_O, NULL},
39953 { (char *)"DropTarget_OnDrop", (PyCFunction) _wrap_DropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
39954 { (char *)"DropTarget_GetData", (PyCFunction)_wrap_DropTarget_GetData, METH_O, NULL},
39955 { (char *)"DropTarget_SetDefaultAction", (PyCFunction) _wrap_DropTarget_SetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
39956 { (char *)"DropTarget_GetDefaultAction", (PyCFunction)_wrap_DropTarget_GetDefaultAction, METH_O, NULL},
39957 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
39958 { (char *)"DropTarget_swiginit", DropTarget_swiginit, METH_VARARGS, NULL},
39959 { (char *)"new_TextDropTarget", (PyCFunction)_wrap_new_TextDropTarget, METH_NOARGS, NULL},
39960 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39961 { (char *)"TextDropTarget_OnDropText", (PyCFunction) _wrap_TextDropTarget_OnDropText, METH_VARARGS | METH_KEYWORDS, NULL},
39962 { (char *)"TextDropTarget_OnEnter", (PyCFunction) _wrap_TextDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
39963 { (char *)"TextDropTarget_OnDragOver", (PyCFunction) _wrap_TextDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
39964 { (char *)"TextDropTarget_OnLeave", (PyCFunction)_wrap_TextDropTarget_OnLeave, METH_O, NULL},
39965 { (char *)"TextDropTarget_OnDrop", (PyCFunction) _wrap_TextDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
39966 { (char *)"TextDropTarget_OnData", (PyCFunction) _wrap_TextDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
39967 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
39968 { (char *)"TextDropTarget_swiginit", TextDropTarget_swiginit, METH_VARARGS, NULL},
39969 { (char *)"new_FileDropTarget", (PyCFunction)_wrap_new_FileDropTarget, METH_NOARGS, NULL},
39970 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39971 { (char *)"FileDropTarget_OnDropFiles", (PyCFunction) _wrap_FileDropTarget_OnDropFiles, METH_VARARGS | METH_KEYWORDS, NULL},
39972 { (char *)"FileDropTarget_OnEnter", (PyCFunction) _wrap_FileDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
39973 { (char *)"FileDropTarget_OnDragOver", (PyCFunction) _wrap_FileDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
39974 { (char *)"FileDropTarget_OnLeave", (PyCFunction)_wrap_FileDropTarget_OnLeave, METH_O, NULL},
39975 { (char *)"FileDropTarget_OnDrop", (PyCFunction) _wrap_FileDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
39976 { (char *)"FileDropTarget_OnData", (PyCFunction) _wrap_FileDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
39977 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
39978 { (char *)"FileDropTarget_swiginit", FileDropTarget_swiginit, METH_VARARGS, NULL},
39979 { (char *)"new_Clipboard", (PyCFunction)_wrap_new_Clipboard, METH_NOARGS, NULL},
39980 { (char *)"delete_Clipboard", (PyCFunction)_wrap_delete_Clipboard, METH_O, NULL},
39981 { (char *)"Clipboard_Open", (PyCFunction)_wrap_Clipboard_Open, METH_O, NULL},
39982 { (char *)"Clipboard_Close", (PyCFunction)_wrap_Clipboard_Close, METH_O, NULL},
39983 { (char *)"Clipboard_IsOpened", (PyCFunction)_wrap_Clipboard_IsOpened, METH_O, NULL},
39984 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
39985 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
39986 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
39987 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
39988 { (char *)"Clipboard_Clear", (PyCFunction)_wrap_Clipboard_Clear, METH_O, NULL},
39989 { (char *)"Clipboard_Flush", (PyCFunction)_wrap_Clipboard_Flush, METH_O, NULL},
39990 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
39991 { (char *)"Clipboard_Get", (PyCFunction)_wrap_Clipboard_Get, METH_NOARGS, NULL},
39992 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
39993 { (char *)"Clipboard_swiginit", Clipboard_swiginit, METH_VARARGS, NULL},
39994 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
39995 { (char *)"delete_ClipboardLocker", (PyCFunction)_wrap_delete_ClipboardLocker, METH_O, NULL},
39996 { (char *)"ClipboardLocker___nonzero__", (PyCFunction)_wrap_ClipboardLocker___nonzero__, METH_O, NULL},
39997 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
39998 { (char *)"ClipboardLocker_swiginit", ClipboardLocker_swiginit, METH_VARARGS, NULL},
39999 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
40000 { (char *)"delete_VideoMode", (PyCFunction)_wrap_delete_VideoMode, METH_O, NULL},
40001 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
40002 { (char *)"VideoMode_GetWidth", (PyCFunction)_wrap_VideoMode_GetWidth, METH_O, NULL},
40003 { (char *)"VideoMode_GetHeight", (PyCFunction)_wrap_VideoMode_GetHeight, METH_O, NULL},
40004 { (char *)"VideoMode_GetDepth", (PyCFunction)_wrap_VideoMode_GetDepth, METH_O, NULL},
40005 { (char *)"VideoMode_IsOk", (PyCFunction)_wrap_VideoMode_IsOk, METH_O, NULL},
40006 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
40007 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
40008 { (char *)"VideoMode_w_set", _wrap_VideoMode_w_set, METH_VARARGS, NULL},
40009 { (char *)"VideoMode_w_get", (PyCFunction)_wrap_VideoMode_w_get, METH_O, NULL},
40010 { (char *)"VideoMode_h_set", _wrap_VideoMode_h_set, METH_VARARGS, NULL},
40011 { (char *)"VideoMode_h_get", (PyCFunction)_wrap_VideoMode_h_get, METH_O, NULL},
40012 { (char *)"VideoMode_bpp_set", _wrap_VideoMode_bpp_set, METH_VARARGS, NULL},
40013 { (char *)"VideoMode_bpp_get", (PyCFunction)_wrap_VideoMode_bpp_get, METH_O, NULL},
40014 { (char *)"VideoMode_refresh_set", _wrap_VideoMode_refresh_set, METH_VARARGS, NULL},
40015 { (char *)"VideoMode_refresh_get", (PyCFunction)_wrap_VideoMode_refresh_get, METH_O, NULL},
40016 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
40017 { (char *)"VideoMode_swiginit", VideoMode_swiginit, METH_VARARGS, NULL},
40018 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
40019 { (char *)"delete_Display", (PyCFunction)_wrap_delete_Display, METH_O, NULL},
40020 { (char *)"Display_GetCount", (PyCFunction)_wrap_Display_GetCount, METH_NOARGS, NULL},
40021 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
40022 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
40023 { (char *)"Display_IsOk", (PyCFunction)_wrap_Display_IsOk, METH_O, NULL},
40024 { (char *)"Display_GetGeometry", (PyCFunction)_wrap_Display_GetGeometry, METH_O, NULL},
40025 { (char *)"Display_GetClientArea", (PyCFunction)_wrap_Display_GetClientArea, METH_O, NULL},
40026 { (char *)"Display_GetName", (PyCFunction)_wrap_Display_GetName, METH_O, NULL},
40027 { (char *)"Display_IsPrimary", (PyCFunction)_wrap_Display_IsPrimary, METH_O, NULL},
40028 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
40029 { (char *)"Display_GetCurrentMode", (PyCFunction)_wrap_Display_GetCurrentMode, METH_O, NULL},
40030 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
40031 { (char *)"Display_ResetMode", (PyCFunction)_wrap_Display_ResetMode, METH_O, NULL},
40032 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
40033 { (char *)"Display_swiginit", Display_swiginit, METH_VARARGS, NULL},
40034 { (char *)"StandardPaths_Get", (PyCFunction)_wrap_StandardPaths_Get, METH_NOARGS, NULL},
40035 { (char *)"StandardPaths_GetConfigDir", (PyCFunction)_wrap_StandardPaths_GetConfigDir, METH_O, NULL},
40036 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction)_wrap_StandardPaths_GetUserConfigDir, METH_O, NULL},
40037 { (char *)"StandardPaths_GetDataDir", (PyCFunction)_wrap_StandardPaths_GetDataDir, METH_O, NULL},
40038 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetLocalDataDir, METH_O, NULL},
40039 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction)_wrap_StandardPaths_GetUserDataDir, METH_O, NULL},
40040 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetUserLocalDataDir, METH_O, NULL},
40041 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction)_wrap_StandardPaths_GetPluginsDir, METH_O, NULL},
40042 { (char *)"StandardPaths_GetResourcesDir", (PyCFunction)_wrap_StandardPaths_GetResourcesDir, METH_O, NULL},
40043 { (char *)"StandardPaths_GetLocalizedResourcesDir", (PyCFunction) _wrap_StandardPaths_GetLocalizedResourcesDir, METH_VARARGS | METH_KEYWORDS, NULL},
40044 { (char *)"StandardPaths_GetDocumentsDir", (PyCFunction)_wrap_StandardPaths_GetDocumentsDir, METH_O, NULL},
40045 { (char *)"StandardPaths_GetTempDir", (PyCFunction)_wrap_StandardPaths_GetTempDir, METH_O, NULL},
40046 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
40047 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction)_wrap_StandardPaths_GetInstallPrefix, METH_O, NULL},
40048 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
40049 { (char *)"new_PowerEvent", (PyCFunction) _wrap_new_PowerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
40050 { (char *)"PowerEvent_Veto", (PyCFunction)_wrap_PowerEvent_Veto, METH_O, NULL},
40051 { (char *)"PowerEvent_IsVetoed", (PyCFunction)_wrap_PowerEvent_IsVetoed, METH_O, NULL},
40052 { (char *)"PowerEvent_swigregister", PowerEvent_swigregister, METH_VARARGS, NULL},
40053 { (char *)"PowerEvent_swiginit", PowerEvent_swiginit, METH_VARARGS, NULL},
40054 { (char *)"GetPowerType", (PyCFunction)_wrap_GetPowerType, METH_NOARGS, NULL},
40055 { (char *)"GetBatteryState", (PyCFunction)_wrap_GetBatteryState, METH_NOARGS, NULL},
40056 { (char *)"new_AboutDialogInfo", (PyCFunction)_wrap_new_AboutDialogInfo, METH_NOARGS, NULL},
40057 { (char *)"delete_AboutDialogInfo", (PyCFunction)_wrap_delete_AboutDialogInfo, METH_O, NULL},
40058 { (char *)"AboutDialogInfo_SetName", (PyCFunction) _wrap_AboutDialogInfo_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
40059 { (char *)"AboutDialogInfo_GetName", (PyCFunction)_wrap_AboutDialogInfo_GetName, METH_O, NULL},
40060 { (char *)"AboutDialogInfo_SetVersion", (PyCFunction) _wrap_AboutDialogInfo_SetVersion, METH_VARARGS | METH_KEYWORDS, NULL},
40061 { (char *)"AboutDialogInfo_HasVersion", (PyCFunction)_wrap_AboutDialogInfo_HasVersion, METH_O, NULL},
40062 { (char *)"AboutDialogInfo_GetVersion", (PyCFunction)_wrap_AboutDialogInfo_GetVersion, METH_O, NULL},
40063 { (char *)"AboutDialogInfo_SetDescription", (PyCFunction) _wrap_AboutDialogInfo_SetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
40064 { (char *)"AboutDialogInfo_HasDescription", (PyCFunction)_wrap_AboutDialogInfo_HasDescription, METH_O, NULL},
40065 { (char *)"AboutDialogInfo_GetDescription", (PyCFunction)_wrap_AboutDialogInfo_GetDescription, METH_O, NULL},
40066 { (char *)"AboutDialogInfo_SetCopyright", (PyCFunction) _wrap_AboutDialogInfo_SetCopyright, METH_VARARGS | METH_KEYWORDS, NULL},
40067 { (char *)"AboutDialogInfo_HasCopyright", (PyCFunction)_wrap_AboutDialogInfo_HasCopyright, METH_O, NULL},
40068 { (char *)"AboutDialogInfo_GetCopyright", (PyCFunction)_wrap_AboutDialogInfo_GetCopyright, METH_O, NULL},
40069 { (char *)"AboutDialogInfo_SetLicence", (PyCFunction) _wrap_AboutDialogInfo_SetLicence, METH_VARARGS | METH_KEYWORDS, NULL},
40070 { (char *)"AboutDialogInfo_SetLicense", (PyCFunction) _wrap_AboutDialogInfo_SetLicense, METH_VARARGS | METH_KEYWORDS, NULL},
40071 { (char *)"AboutDialogInfo_HasLicence", (PyCFunction)_wrap_AboutDialogInfo_HasLicence, METH_O, NULL},
40072 { (char *)"AboutDialogInfo_GetLicence", (PyCFunction)_wrap_AboutDialogInfo_GetLicence, METH_O, NULL},
40073 { (char *)"AboutDialogInfo_SetIcon", (PyCFunction) _wrap_AboutDialogInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
40074 { (char *)"AboutDialogInfo_HasIcon", (PyCFunction)_wrap_AboutDialogInfo_HasIcon, METH_O, NULL},
40075 { (char *)"AboutDialogInfo_GetIcon", (PyCFunction)_wrap_AboutDialogInfo_GetIcon, METH_O, NULL},
40076 { (char *)"AboutDialogInfo__SetWebSite", (PyCFunction) _wrap_AboutDialogInfo__SetWebSite, METH_VARARGS | METH_KEYWORDS, NULL},
40077 { (char *)"AboutDialogInfo__GetWebSiteURL", (PyCFunction)_wrap_AboutDialogInfo__GetWebSiteURL, METH_O, NULL},
40078 { (char *)"AboutDialogInfo__GetWebSiteDescription", (PyCFunction)_wrap_AboutDialogInfo__GetWebSiteDescription, METH_O, NULL},
40079 { (char *)"AboutDialogInfo_HasWebSite", (PyCFunction)_wrap_AboutDialogInfo_HasWebSite, METH_O, NULL},
40080 { (char *)"AboutDialogInfo_SetDevelopers", (PyCFunction) _wrap_AboutDialogInfo_SetDevelopers, METH_VARARGS | METH_KEYWORDS, NULL},
40081 { (char *)"AboutDialogInfo_AddDeveloper", (PyCFunction) _wrap_AboutDialogInfo_AddDeveloper, METH_VARARGS | METH_KEYWORDS, NULL},
40082 { (char *)"AboutDialogInfo_HasDevelopers", (PyCFunction)_wrap_AboutDialogInfo_HasDevelopers, METH_O, NULL},
40083 { (char *)"AboutDialogInfo_GetDevelopers", (PyCFunction)_wrap_AboutDialogInfo_GetDevelopers, METH_O, NULL},
40084 { (char *)"AboutDialogInfo_SetDocWriters", (PyCFunction) _wrap_AboutDialogInfo_SetDocWriters, METH_VARARGS | METH_KEYWORDS, NULL},
40085 { (char *)"AboutDialogInfo_AddDocWriter", (PyCFunction) _wrap_AboutDialogInfo_AddDocWriter, METH_VARARGS | METH_KEYWORDS, NULL},
40086 { (char *)"AboutDialogInfo_HasDocWriters", (PyCFunction)_wrap_AboutDialogInfo_HasDocWriters, METH_O, NULL},
40087 { (char *)"AboutDialogInfo_GetDocWriters", (PyCFunction)_wrap_AboutDialogInfo_GetDocWriters, METH_O, NULL},
40088 { (char *)"AboutDialogInfo_SetArtists", (PyCFunction) _wrap_AboutDialogInfo_SetArtists, METH_VARARGS | METH_KEYWORDS, NULL},
40089 { (char *)"AboutDialogInfo_AddArtist", (PyCFunction) _wrap_AboutDialogInfo_AddArtist, METH_VARARGS | METH_KEYWORDS, NULL},
40090 { (char *)"AboutDialogInfo_HasArtists", (PyCFunction)_wrap_AboutDialogInfo_HasArtists, METH_O, NULL},
40091 { (char *)"AboutDialogInfo_GetArtists", (PyCFunction)_wrap_AboutDialogInfo_GetArtists, METH_O, NULL},
40092 { (char *)"AboutDialogInfo_SetTranslators", (PyCFunction) _wrap_AboutDialogInfo_SetTranslators, METH_VARARGS | METH_KEYWORDS, NULL},
40093 { (char *)"AboutDialogInfo_AddTranslator", (PyCFunction) _wrap_AboutDialogInfo_AddTranslator, METH_VARARGS | METH_KEYWORDS, NULL},
40094 { (char *)"AboutDialogInfo_HasTranslators", (PyCFunction)_wrap_AboutDialogInfo_HasTranslators, METH_O, NULL},
40095 { (char *)"AboutDialogInfo_GetTranslators", (PyCFunction)_wrap_AboutDialogInfo_GetTranslators, METH_O, NULL},
40096 { (char *)"AboutDialogInfo_IsSimple", (PyCFunction)_wrap_AboutDialogInfo_IsSimple, METH_O, NULL},
40097 { (char *)"AboutDialogInfo_GetDescriptionAndCredits", (PyCFunction)_wrap_AboutDialogInfo_GetDescriptionAndCredits, METH_O, NULL},
40098 { (char *)"AboutDialogInfo_swigregister", AboutDialogInfo_swigregister, METH_VARARGS, NULL},
40099 { (char *)"AboutDialogInfo_swiginit", AboutDialogInfo_swiginit, METH_VARARGS, NULL},
40100 { (char *)"AboutBox", (PyCFunction) _wrap_AboutBox, METH_VARARGS | METH_KEYWORDS, NULL},
40101 { NULL, NULL, 0, NULL }
40102 };
40103
40104
40105 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
40106
40107 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
40108 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
40109 }
40110 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
40111 return (void *)((wxEvent *) ((wxMenuEvent *) x));
40112 }
40113 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
40114 return (void *)((wxEvent *) ((wxCloseEvent *) x));
40115 }
40116 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
40117 return (void *)((wxEvent *) ((wxMouseEvent *) x));
40118 }
40119 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
40120 return (void *)((wxEvent *) ((wxEraseEvent *) x));
40121 }
40122 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
40123 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
40124 }
40125 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
40126 return (void *)((wxEvent *) ((wxTimerEvent *) x));
40127 }
40128 static void *_p_wxPowerEventTo_p_wxEvent(void *x) {
40129 return (void *)((wxEvent *) ((wxPowerEvent *) x));
40130 }
40131 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
40132 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
40133 }
40134 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
40135 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
40136 }
40137 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
40138 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
40139 }
40140 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
40141 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
40142 }
40143 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
40144 return (void *)((wxEvent *) ((wxPyEvent *) x));
40145 }
40146 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
40147 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
40148 }
40149 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
40150 return (void *)((wxEvent *) ((wxIdleEvent *) x));
40151 }
40152 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
40153 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
40154 }
40155 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
40156 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
40157 }
40158 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
40159 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
40160 }
40161 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
40162 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
40163 }
40164 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
40165 return (void *)((wxEvent *) ((wxActivateEvent *) x));
40166 }
40167 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
40168 return (void *)((wxEvent *) ((wxSizeEvent *) x));
40169 }
40170 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
40171 return (void *)((wxEvent *) ((wxMoveEvent *) x));
40172 }
40173 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
40174 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
40175 }
40176 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
40177 return (void *)((wxEvent *) ((wxPaintEvent *) x));
40178 }
40179 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
40180 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
40181 }
40182 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
40183 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
40184 }
40185 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
40186 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
40187 }
40188 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
40189 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
40190 }
40191 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
40192 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
40193 }
40194 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
40195 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
40196 }
40197 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
40198 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
40199 }
40200 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
40201 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
40202 }
40203 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
40204 return (void *)((wxEvent *) ((wxFocusEvent *) x));
40205 }
40206 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
40207 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
40208 }
40209 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
40210 return (void *)((wxEvent *) ((wxProcessEvent *) x));
40211 }
40212 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
40213 return (void *)((wxEvent *) ((wxShowEvent *) x));
40214 }
40215 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
40216 return (void *)((wxEvent *) ((wxCommandEvent *) x));
40217 }
40218 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
40219 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
40220 }
40221 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
40222 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
40223 }
40224 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
40225 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
40226 }
40227 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
40228 return (void *)((wxEvent *) ((wxKeyEvent *) x));
40229 }
40230 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
40231 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
40232 }
40233 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
40234 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
40235 }
40236 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
40237 return (void *)((wxConfigBase *) ((wxConfig *) x));
40238 }
40239 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
40240 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
40241 }
40242 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
40243 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
40244 }
40245 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
40246 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
40247 }
40248 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
40249 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
40250 }
40251 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
40252 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
40253 }
40254 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
40255 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
40256 }
40257 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
40258 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
40259 }
40260 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
40261 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
40262 }
40263 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
40264 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
40265 }
40266 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
40267 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
40268 }
40269 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
40270 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
40271 }
40272 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
40273 return (void *)((wxDataObject *) ((wxURLDataObject *) x));
40274 }
40275 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
40276 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
40277 }
40278 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
40279 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
40280 }
40281 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
40282 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
40283 }
40284 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
40285 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
40286 }
40287 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
40288 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
40289 }
40290 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
40291 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
40292 }
40293 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
40294 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
40295 }
40296 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
40297 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
40298 }
40299 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
40300 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
40301 }
40302 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
40303 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
40304 }
40305 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
40306 return (void *)((wxEvtHandler *) ((wxWindow *) x));
40307 }
40308 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
40309 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
40310 }
40311 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
40312 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
40313 }
40314 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
40315 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
40316 }
40317 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
40318 return (void *)((wxEvtHandler *) ((wxValidator *) x));
40319 }
40320 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
40321 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
40322 }
40323 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
40324 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
40325 }
40326 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
40327 return (void *)((wxEvtHandler *) ((wxMenu *) x));
40328 }
40329 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
40330 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
40331 }
40332 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
40333 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
40334 }
40335 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
40336 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
40337 }
40338 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
40339 return (void *)((wxObject *) ((wxSizerItem *) x));
40340 }
40341 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
40342 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
40343 }
40344 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
40345 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
40346 }
40347 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
40348 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
40349 }
40350 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
40351 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
40352 }
40353 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
40354 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
40355 }
40356 static void *_p_wxSizerTo_p_wxObject(void *x) {
40357 return (void *)((wxObject *) ((wxSizer *) x));
40358 }
40359 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
40360 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
40361 }
40362 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
40363 return (void *)((wxObject *) ((wxFileHistory *) x));
40364 }
40365 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
40366 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
40367 }
40368 static void *_p_wxEventTo_p_wxObject(void *x) {
40369 return (void *)((wxObject *) ((wxEvent *) x));
40370 }
40371 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
40372 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
40373 }
40374 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
40375 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
40376 }
40377 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
40378 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
40379 }
40380 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
40381 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
40382 }
40383 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
40384 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
40385 }
40386 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
40387 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
40388 }
40389 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
40390 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
40391 }
40392 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
40393 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
40394 }
40395 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
40396 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
40397 }
40398 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
40399 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
40400 }
40401 static void *_p_wxControlTo_p_wxObject(void *x) {
40402 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
40403 }
40404 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
40405 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
40406 }
40407 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
40408 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
40409 }
40410 static void *_p_wxPowerEventTo_p_wxObject(void *x) {
40411 return (void *)((wxObject *) (wxEvent *) ((wxPowerEvent *) x));
40412 }
40413 static void *_p_wxFSFileTo_p_wxObject(void *x) {
40414 return (void *)((wxObject *) ((wxFSFile *) x));
40415 }
40416 static void *_p_wxClipboardTo_p_wxObject(void *x) {
40417 return (void *)((wxObject *) ((wxClipboard *) x));
40418 }
40419 static void *_p_wxPySizerTo_p_wxObject(void *x) {
40420 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
40421 }
40422 static void *_p_wxPyEventTo_p_wxObject(void *x) {
40423 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
40424 }
40425 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
40426 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
40427 }
40428 static void *_p_wxShowEventTo_p_wxObject(void *x) {
40429 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
40430 }
40431 static void *_p_wxToolTipTo_p_wxObject(void *x) {
40432 return (void *)((wxObject *) ((wxToolTip *) x));
40433 }
40434 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
40435 return (void *)((wxObject *) ((wxMenuItem *) x));
40436 }
40437 static void *_p_wxDateEventTo_p_wxObject(void *x) {
40438 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
40439 }
40440 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
40441 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
40442 }
40443 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
40444 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
40445 }
40446 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
40447 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
40448 }
40449 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
40450 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
40451 }
40452 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
40453 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
40454 }
40455 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
40456 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
40457 }
40458 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
40459 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
40460 }
40461 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
40462 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
40463 }
40464 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
40465 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
40466 }
40467 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
40468 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
40469 }
40470 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
40471 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
40472 }
40473 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
40474 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
40475 }
40476 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
40477 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
40478 }
40479 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
40480 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
40481 }
40482 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
40483 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
40484 }
40485 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
40486 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
40487 }
40488 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
40489 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
40490 }
40491 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
40492 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
40493 }
40494 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
40495 return (void *)((wxObject *) ((wxImageHandler *) x));
40496 }
40497 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
40498 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
40499 }
40500 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
40501 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
40502 }
40503 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
40504 return (void *)((wxObject *) ((wxEvtHandler *) x));
40505 }
40506 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
40507 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
40508 }
40509 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
40510 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
40511 }
40512 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
40513 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
40514 }
40515 static void *_p_wxImageTo_p_wxObject(void *x) {
40516 return (void *)((wxObject *) ((wxImage *) x));
40517 }
40518 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
40519 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
40520 }
40521 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
40522 return (void *)((wxObject *) ((wxSystemOptions *) x));
40523 }
40524 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
40525 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
40526 }
40527 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
40528 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
40529 }
40530 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
40531 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
40532 }
40533 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
40534 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
40535 }
40536 static void *_p_wxWindowTo_p_wxObject(void *x) {
40537 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
40538 }
40539 static void *_p_wxMenuTo_p_wxObject(void *x) {
40540 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
40541 }
40542 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
40543 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
40544 }
40545 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
40546 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
40547 }
40548 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
40549 return (void *)((wxObject *) ((wxFileSystem *) x));
40550 }
40551 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
40552 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
40553 }
40554 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
40555 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
40556 }
40557 static void *_p_wxPyAppTo_p_wxObject(void *x) {
40558 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
40559 }
40560 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
40561 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
40562 }
40563 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
40564 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
40565 }
40566 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
40567 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
40568 }
40569 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
40570 return (void *)((wxObject *) ((wxBusyInfo *) x));
40571 }
40572 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
40573 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
40574 }
40575 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
40576 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
40577 }
40578 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
40579 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
40580 }
40581 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
40582 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
40583 }
40584 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
40585 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
40586 }
40587 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
40588 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
40589 }
40590 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
40591 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
40592 }
40593 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
40594 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
40595 }
40596 static void *_p_wxValidatorTo_p_wxObject(void *x) {
40597 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
40598 }
40599 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
40600 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
40601 }
40602 static void *_p_wxLogBufferTo_p_wxLog(void *x) {
40603 return (void *)((wxLog *) ((wxLogBuffer *) x));
40604 }
40605 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
40606 return (void *)((wxLog *) ((wxLogStderr *) x));
40607 }
40608 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
40609 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
40610 }
40611 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
40612 return (void *)((wxLog *) ((wxLogWindow *) x));
40613 }
40614 static void *_p_wxLogChainTo_p_wxLog(void *x) {
40615 return (void *)((wxLog *) ((wxLogChain *) x));
40616 }
40617 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
40618 return (void *)((wxLog *) ((wxLogGui *) x));
40619 }
40620 static void *_p_wxPyLogTo_p_wxLog(void *x) {
40621 return (void *)((wxLog *) ((wxPyLog *) x));
40622 }
40623 static void *_p_wxControlTo_p_wxWindow(void *x) {
40624 return (void *)((wxWindow *) ((wxControl *) x));
40625 }
40626 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
40627 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
40628 }
40629 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
40630 return (void *)((wxWindow *) ((wxMenuBar *) x));
40631 }
40632 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
40633 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
40634 }
40635 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
40636 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
40637 }
40638 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
40639 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};
40640 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
40641 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
40642 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
40643 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxLogLevel *", 0, 0, (void*)0, 0};
40644 static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
40645 static swig_type_info _swigt__p_wxAboutDialogInfo = {"_p_wxAboutDialogInfo", "wxAboutDialogInfo *", 0, 0, (void*)0, 0};
40646 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
40647 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
40648 static swig_type_info _swigt__p_wxBitmapDataObject = {"_p_wxBitmapDataObject", "wxBitmapDataObject *", 0, 0, (void*)0, 0};
40649 static swig_type_info _swigt__p_wxBusyCursor = {"_p_wxBusyCursor", "wxBusyCursor *", 0, 0, (void*)0, 0};
40650 static swig_type_info _swigt__p_wxBusyInfo = {"_p_wxBusyInfo", "wxBusyInfo *", 0, 0, (void*)0, 0};
40651 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
40652 static swig_type_info _swigt__p_wxChar = {"_p_wxChar", "wxChar *", 0, 0, (void*)0, 0};
40653 static swig_type_info _swigt__p_wxClipboard = {"_p_wxClipboard", "wxClipboard *", 0, 0, (void*)0, 0};
40654 static swig_type_info _swigt__p_wxClipboardLocker = {"_p_wxClipboardLocker", "wxClipboardLocker *", 0, 0, (void*)0, 0};
40655 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
40656 static swig_type_info _swigt__p_wxConfig = {"_p_wxConfig", "wxConfig *", 0, 0, (void*)0, 0};
40657 static swig_type_info _swigt__p_wxConfigBase = {"_p_wxConfigBase", "wxConfigBase *", 0, 0, (void*)0, 0};
40658 static swig_type_info _swigt__p_wxConfigPathChanger = {"_p_wxConfigPathChanger", "wxConfigPathChanger *", 0, 0, (void*)0, 0};
40659 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
40660 static swig_type_info _swigt__p_wxCustomDataObject = {"_p_wxCustomDataObject", "wxCustomDataObject *", 0, 0, (void*)0, 0};
40661 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
40662 static swig_type_info _swigt__p_wxDataFormat = {"_p_wxDataFormat", "wxDataFormat *", 0, 0, (void*)0, 0};
40663 static swig_type_info _swigt__p_wxDataObject = {"_p_wxDataObject", "wxDataObject *", 0, 0, (void*)0, 0};
40664 static swig_type_info _swigt__p_wxDataObjectComposite = {"_p_wxDataObjectComposite", "wxDataObjectComposite *", 0, 0, (void*)0, 0};
40665 static swig_type_info _swigt__p_wxDataObjectSimple = {"_p_wxDataObjectSimple", "wxDataObjectSimple *", 0, 0, (void*)0, 0};
40666 static swig_type_info _swigt__p_wxDateSpan = {"_p_wxDateSpan", "wxDateSpan *", 0, 0, (void*)0, 0};
40667 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
40668 static swig_type_info _swigt__p_wxDateTime__TimeZone = {"_p_wxDateTime__TimeZone", "wxDateTime::TimeZone *", 0, 0, (void*)0, 0};
40669 static swig_type_info _swigt__p_wxDisplay = {"_p_wxDisplay", "wxDisplay *", 0, 0, (void*)0, 0};
40670 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
40671 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
40672 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0, 0};
40673 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0, 0};
40674 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0, 0};
40675 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0, 0};
40676 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0, 0};
40677 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0, 0};
40678 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0, 0};
40679 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0, 0};
40680 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", 0, 0, 0, 0, 0};
40681 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0, 0};
40682 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", 0, 0, 0, 0, 0};
40683 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0, 0};
40684 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0};
40685 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0};
40686 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0, 0};
40687 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0, 0};
40688 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0, 0};
40689 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0, 0};
40690 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0, 0};
40691 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0, 0};
40692 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0, 0};
40693 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0, 0};
40694 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", 0, 0, 0, 0, 0};
40695 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0};
40696 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0};
40697 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0};
40698 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0};
40699 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0};
40700 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0, 0};
40701 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0, 0};
40702 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0, 0};
40703 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0, 0};
40704 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", 0, 0, 0, 0, 0};
40705 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0, 0};
40706 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0};
40707 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0};
40708 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", 0, 0, 0, 0, 0};
40709 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0, 0};
40710 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
40711 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", 0, 0, 0, 0, 0};
40712 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0, 0};
40713 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0, 0};
40714 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0, 0};
40715 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0, 0};
40716 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0, 0};
40717 static swig_type_info _swigt__p_wxFileConfig = {"_p_wxFileConfig", "wxFileConfig *", 0, 0, (void*)0, 0};
40718 static swig_type_info _swigt__p_wxFileDataObject = {"_p_wxFileDataObject", "wxFileDataObject *", 0, 0, (void*)0, 0};
40719 static swig_type_info _swigt__p_wxFileHistory = {"_p_wxFileHistory", "wxFileHistory *", 0, 0, (void*)0, 0};
40720 static swig_type_info _swigt__p_wxFileType = {"_p_wxFileType", "wxFileType *", 0, 0, (void*)0, 0};
40721 static swig_type_info _swigt__p_wxFileTypeInfo = {"_p_wxFileTypeInfo", "wxFileTypeInfo *", 0, 0, (void*)0, 0};
40722 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
40723 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
40724 static swig_type_info _swigt__p_wxIcon = {"_p_wxIcon", "wxIcon *", 0, 0, (void*)0, 0};
40725 static swig_type_info _swigt__p_wxJoystick = {"_p_wxJoystick", "wxJoystick *", 0, 0, (void*)0, 0};
40726 static swig_type_info _swigt__p_wxJoystickEvent = {"_p_wxJoystickEvent", "wxJoystickEvent *", 0, 0, (void*)0, 0};
40727 static swig_type_info _swigt__p_wxKillError = {"_p_wxKillError", "enum wxKillError *|wxKillError *", 0, 0, (void*)0, 0};
40728 static swig_type_info _swigt__p_wxLog = {"_p_wxLog", "wxLog *", 0, 0, (void*)0, 0};
40729 static swig_type_info _swigt__p_wxLogBuffer = {"_p_wxLogBuffer", "wxLogBuffer *", 0, 0, (void*)0, 0};
40730 static swig_type_info _swigt__p_wxLogChain = {"_p_wxLogChain", "wxLogChain *", 0, 0, (void*)0, 0};
40731 static swig_type_info _swigt__p_wxLogGui = {"_p_wxLogGui", "wxLogGui *", 0, 0, (void*)0, 0};
40732 static swig_type_info _swigt__p_wxLogNull = {"_p_wxLogNull", "wxLogNull *", 0, 0, (void*)0, 0};
40733 static swig_type_info _swigt__p_wxLogStderr = {"_p_wxLogStderr", "wxLogStderr *", 0, 0, (void*)0, 0};
40734 static swig_type_info _swigt__p_wxLogTextCtrl = {"_p_wxLogTextCtrl", "wxLogTextCtrl *", 0, 0, (void*)0, 0};
40735 static swig_type_info _swigt__p_wxLogWindow = {"_p_wxLogWindow", "wxLogWindow *", 0, 0, (void*)0, 0};
40736 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
40737 static swig_type_info _swigt__p_wxMetafile = {"_p_wxMetafile", "wxMetafile *", 0, 0, (void*)0, 0};
40738 static swig_type_info _swigt__p_wxMetafileDataObject = {"_p_wxMetafileDataObject", "wxMetafileDataObject *", 0, 0, (void*)0, 0};
40739 static swig_type_info _swigt__p_wxMimeTypesManager = {"_p_wxMimeTypesManager", "wxMimeTypesManager *", 0, 0, (void*)0, 0};
40740 static swig_type_info _swigt__p_wxMouseState = {"_p_wxMouseState", "wxMouseState *", 0, 0, (void*)0, 0};
40741 static swig_type_info _swigt__p_wxMutexGuiLocker = {"_p_wxMutexGuiLocker", "wxMutexGuiLocker *", 0, 0, (void*)0, 0};
40742 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
40743 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0, 0};
40744 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0, 0};
40745 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0, 0};
40746 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0};
40747 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0};
40748 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0, 0};
40749 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0, 0};
40750 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0, 0};
40751 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0, 0};
40752 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0, 0};
40753 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0, 0};
40754 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0, 0};
40755 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0, 0};
40756 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0, 0};
40757 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0, 0};
40758 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0, 0};
40759 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0, 0};
40760 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0, 0};
40761 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0, 0};
40762 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0, 0};
40763 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0, 0};
40764 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0, 0};
40765 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0, 0};
40766 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0, 0};
40767 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0, 0};
40768 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0, 0};
40769 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0};
40770 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0, 0};
40771 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", 0, 0, 0, 0, 0};
40772 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0, 0};
40773 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
40774 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
40775 static swig_type_info _swigt__p_wxPlatformInfo = {"_p_wxPlatformInfo", "wxPlatformInfo *", 0, 0, (void*)0, 0};
40776 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
40777 static swig_type_info _swigt__p_wxPowerEvent = {"_p_wxPowerEvent", "wxPowerEvent *", 0, 0, (void*)0, 0};
40778 static swig_type_info _swigt__p_wxProcessEvent = {"_p_wxProcessEvent", "wxProcessEvent *", 0, 0, (void*)0, 0};
40779 static swig_type_info _swigt__p_wxPyArtProvider = {"_p_wxPyArtProvider", "wxPyArtProvider *", 0, 0, (void*)0, 0};
40780 static swig_type_info _swigt__p_wxPyBitmapDataObject = {"_p_wxPyBitmapDataObject", "wxPyBitmapDataObject *", 0, 0, (void*)0, 0};
40781 static swig_type_info _swigt__p_wxPyDataObjectSimple = {"_p_wxPyDataObjectSimple", "wxPyDataObjectSimple *", 0, 0, (void*)0, 0};
40782 static swig_type_info _swigt__p_wxPyDropSource = {"_p_wxPyDropSource", "wxPyDropSource *", 0, 0, (void*)0, 0};
40783 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
40784 static swig_type_info _swigt__p_wxPyFileDropTarget = {"_p_wxPyFileDropTarget", "wxPyFileDropTarget *", 0, 0, (void*)0, 0};
40785 static swig_type_info _swigt__p_wxPyLog = {"_p_wxPyLog", "wxPyLog *", 0, 0, (void*)0, 0};
40786 static swig_type_info _swigt__p_wxPyProcess = {"_p_wxPyProcess", "wxPyProcess *", 0, 0, (void*)0, 0};
40787 static swig_type_info _swigt__p_wxPyTextDataObject = {"_p_wxPyTextDataObject", "wxPyTextDataObject *", 0, 0, (void*)0, 0};
40788 static swig_type_info _swigt__p_wxPyTextDropTarget = {"_p_wxPyTextDropTarget", "wxPyTextDropTarget *", 0, 0, (void*)0, 0};
40789 static swig_type_info _swigt__p_wxPyTimer = {"_p_wxPyTimer", "wxPyTimer *", 0, 0, (void*)0, 0};
40790 static swig_type_info _swigt__p_wxPyTipProvider = {"_p_wxPyTipProvider", "wxPyTipProvider *", 0, 0, (void*)0, 0};
40791 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
40792 static swig_type_info _swigt__p_wxSingleInstanceChecker = {"_p_wxSingleInstanceChecker", "wxSingleInstanceChecker *", 0, 0, (void*)0, 0};
40793 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
40794 static swig_type_info _swigt__p_wxSound = {"_p_wxSound", "wxSound *", 0, 0, (void*)0, 0};
40795 static swig_type_info _swigt__p_wxStandardPaths = {"_p_wxStandardPaths", "wxStandardPaths *", 0, 0, (void*)0, 0};
40796 static swig_type_info _swigt__p_wxStopWatch = {"_p_wxStopWatch", "wxStopWatch *", 0, 0, (void*)0, 0};
40797 static swig_type_info _swigt__p_wxString = {"_p_wxString", "wxString *", 0, 0, (void*)0, 0};
40798 static swig_type_info _swigt__p_wxSystemOptions = {"_p_wxSystemOptions", "wxSystemOptions *", 0, 0, (void*)0, 0};
40799 static swig_type_info _swigt__p_wxSystemSettings = {"_p_wxSystemSettings", "wxSystemSettings *", 0, 0, (void*)0, 0};
40800 static swig_type_info _swigt__p_wxTextCtrl = {"_p_wxTextCtrl", "wxTextCtrl *", 0, 0, (void*)0, 0};
40801 static swig_type_info _swigt__p_wxTextDataObject = {"_p_wxTextDataObject", "wxTextDataObject *", 0, 0, (void*)0, 0};
40802 static swig_type_info _swigt__p_wxTimeSpan = {"_p_wxTimeSpan", "wxTimeSpan *", 0, 0, (void*)0, 0};
40803 static swig_type_info _swigt__p_wxTimer = {"_p_wxTimer", "wxTimer *", 0, 0, (void*)0, 0};
40804 static swig_type_info _swigt__p_wxTimerEvent = {"_p_wxTimerEvent", "wxTimerEvent *", 0, 0, (void*)0, 0};
40805 static swig_type_info _swigt__p_wxTimerRunner = {"_p_wxTimerRunner", "wxTimerRunner *", 0, 0, (void*)0, 0};
40806 static swig_type_info _swigt__p_wxTipProvider = {"_p_wxTipProvider", "wxTipProvider *", 0, 0, (void*)0, 0};
40807 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
40808 static swig_type_info _swigt__p_wxURLDataObject = {"_p_wxURLDataObject", "wxURLDataObject *", 0, 0, (void*)0, 0};
40809 static swig_type_info _swigt__p_wxVideoMode = {"_p_wxVideoMode", "wxVideoMode *", 0, 0, (void*)0, 0};
40810 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
40811 static swig_type_info _swigt__p_wxWindowDisabler = {"_p_wxWindowDisabler", "wxWindowDisabler *", 0, 0, (void*)0, 0};
40812
40813 static swig_type_info *swig_type_initial[] = {
40814 &_swigt__p_char,
40815 &_swigt__p_form_ops_t,
40816 &_swigt__p_int,
40817 &_swigt__p_unsigned_char,
40818 &_swigt__p_unsigned_int,
40819 &_swigt__p_unsigned_long,
40820 &_swigt__p_void,
40821 &_swigt__p_wxANIHandler,
40822 &_swigt__p_wxAboutDialogInfo,
40823 &_swigt__p_wxAcceleratorTable,
40824 &_swigt__p_wxActivateEvent,
40825 &_swigt__p_wxArrayString,
40826 &_swigt__p_wxBMPHandler,
40827 &_swigt__p_wxBitmap,
40828 &_swigt__p_wxBitmapDataObject,
40829 &_swigt__p_wxBoxSizer,
40830 &_swigt__p_wxBusyCursor,
40831 &_swigt__p_wxBusyInfo,
40832 &_swigt__p_wxCURHandler,
40833 &_swigt__p_wxCaret,
40834 &_swigt__p_wxChar,
40835 &_swigt__p_wxChildFocusEvent,
40836 &_swigt__p_wxClipboard,
40837 &_swigt__p_wxClipboardLocker,
40838 &_swigt__p_wxClipboardTextEvent,
40839 &_swigt__p_wxCloseEvent,
40840 &_swigt__p_wxColour,
40841 &_swigt__p_wxCommandEvent,
40842 &_swigt__p_wxConfig,
40843 &_swigt__p_wxConfigBase,
40844 &_swigt__p_wxConfigPathChanger,
40845 &_swigt__p_wxContextMenuEvent,
40846 &_swigt__p_wxControl,
40847 &_swigt__p_wxControlWithItems,
40848 &_swigt__p_wxCursor,
40849 &_swigt__p_wxCustomDataObject,
40850 &_swigt__p_wxDC,
40851 &_swigt__p_wxDataFormat,
40852 &_swigt__p_wxDataObject,
40853 &_swigt__p_wxDataObjectComposite,
40854 &_swigt__p_wxDataObjectSimple,
40855 &_swigt__p_wxDateEvent,
40856 &_swigt__p_wxDateSpan,
40857 &_swigt__p_wxDateTime,
40858 &_swigt__p_wxDateTime__TimeZone,
40859 &_swigt__p_wxDisplay,
40860 &_swigt__p_wxDisplayChangedEvent,
40861 &_swigt__p_wxDropFilesEvent,
40862 &_swigt__p_wxDuplexMode,
40863 &_swigt__p_wxEraseEvent,
40864 &_swigt__p_wxEvent,
40865 &_swigt__p_wxEvtHandler,
40866 &_swigt__p_wxFSFile,
40867 &_swigt__p_wxFileConfig,
40868 &_swigt__p_wxFileDataObject,
40869 &_swigt__p_wxFileHistory,
40870 &_swigt__p_wxFileSystem,
40871 &_swigt__p_wxFileType,
40872 &_swigt__p_wxFileTypeInfo,
40873 &_swigt__p_wxFlexGridSizer,
40874 &_swigt__p_wxFocusEvent,
40875 &_swigt__p_wxFont,
40876 &_swigt__p_wxFrame,
40877 &_swigt__p_wxGBSizerItem,
40878 &_swigt__p_wxGIFHandler,
40879 &_swigt__p_wxGridBagSizer,
40880 &_swigt__p_wxGridSizer,
40881 &_swigt__p_wxICOHandler,
40882 &_swigt__p_wxIcon,
40883 &_swigt__p_wxIconizeEvent,
40884 &_swigt__p_wxIdleEvent,
40885 &_swigt__p_wxImage,
40886 &_swigt__p_wxImageHandler,
40887 &_swigt__p_wxIndividualLayoutConstraint,
40888 &_swigt__p_wxInitDialogEvent,
40889 &_swigt__p_wxJPEGHandler,
40890 &_swigt__p_wxJoystick,
40891 &_swigt__p_wxJoystickEvent,
40892 &_swigt__p_wxKeyEvent,
40893 &_swigt__p_wxKillError,
40894 &_swigt__p_wxLayoutConstraints,
40895 &_swigt__p_wxLog,
40896 &_swigt__p_wxLogBuffer,
40897 &_swigt__p_wxLogChain,
40898 &_swigt__p_wxLogGui,
40899 &_swigt__p_wxLogNull,
40900 &_swigt__p_wxLogStderr,
40901 &_swigt__p_wxLogTextCtrl,
40902 &_swigt__p_wxLogWindow,
40903 &_swigt__p_wxMaximizeEvent,
40904 &_swigt__p_wxMenu,
40905 &_swigt__p_wxMenuBar,
40906 &_swigt__p_wxMenuEvent,
40907 &_swigt__p_wxMenuItem,
40908 &_swigt__p_wxMetafile,
40909 &_swigt__p_wxMetafileDataObject,
40910 &_swigt__p_wxMimeTypesManager,
40911 &_swigt__p_wxMouseCaptureChangedEvent,
40912 &_swigt__p_wxMouseCaptureLostEvent,
40913 &_swigt__p_wxMouseEvent,
40914 &_swigt__p_wxMouseState,
40915 &_swigt__p_wxMoveEvent,
40916 &_swigt__p_wxMutexGuiLocker,
40917 &_swigt__p_wxNavigationKeyEvent,
40918 &_swigt__p_wxNcPaintEvent,
40919 &_swigt__p_wxNotifyEvent,
40920 &_swigt__p_wxObject,
40921 &_swigt__p_wxOutputStream,
40922 &_swigt__p_wxPCXHandler,
40923 &_swigt__p_wxPNGHandler,
40924 &_swigt__p_wxPNMHandler,
40925 &_swigt__p_wxPaintEvent,
40926 &_swigt__p_wxPaletteChangedEvent,
40927 &_swigt__p_wxPaperSize,
40928 &_swigt__p_wxPlatformInfo,
40929 &_swigt__p_wxPoint,
40930 &_swigt__p_wxPowerEvent,
40931 &_swigt__p_wxProcessEvent,
40932 &_swigt__p_wxPyApp,
40933 &_swigt__p_wxPyArtProvider,
40934 &_swigt__p_wxPyBitmapDataObject,
40935 &_swigt__p_wxPyCommandEvent,
40936 &_swigt__p_wxPyDataObjectSimple,
40937 &_swigt__p_wxPyDropSource,
40938 &_swigt__p_wxPyDropTarget,
40939 &_swigt__p_wxPyEvent,
40940 &_swigt__p_wxPyFileDropTarget,
40941 &_swigt__p_wxPyImageHandler,
40942 &_swigt__p_wxPyLog,
40943 &_swigt__p_wxPyProcess,
40944 &_swigt__p_wxPySizer,
40945 &_swigt__p_wxPyTextDataObject,
40946 &_swigt__p_wxPyTextDropTarget,
40947 &_swigt__p_wxPyTimer,
40948 &_swigt__p_wxPyTipProvider,
40949 &_swigt__p_wxPyValidator,
40950 &_swigt__p_wxQueryNewPaletteEvent,
40951 &_swigt__p_wxRect,
40952 &_swigt__p_wxScrollEvent,
40953 &_swigt__p_wxScrollWinEvent,
40954 &_swigt__p_wxSetCursorEvent,
40955 &_swigt__p_wxShowEvent,
40956 &_swigt__p_wxSingleInstanceChecker,
40957 &_swigt__p_wxSize,
40958 &_swigt__p_wxSizeEvent,
40959 &_swigt__p_wxSizer,
40960 &_swigt__p_wxSizerItem,
40961 &_swigt__p_wxSound,
40962 &_swigt__p_wxStandardPaths,
40963 &_swigt__p_wxStaticBoxSizer,
40964 &_swigt__p_wxStdDialogButtonSizer,
40965 &_swigt__p_wxStopWatch,
40966 &_swigt__p_wxString,
40967 &_swigt__p_wxSysColourChangedEvent,
40968 &_swigt__p_wxSystemOptions,
40969 &_swigt__p_wxSystemSettings,
40970 &_swigt__p_wxTIFFHandler,
40971 &_swigt__p_wxTextCtrl,
40972 &_swigt__p_wxTextDataObject,
40973 &_swigt__p_wxTimeSpan,
40974 &_swigt__p_wxTimer,
40975 &_swigt__p_wxTimerEvent,
40976 &_swigt__p_wxTimerRunner,
40977 &_swigt__p_wxTipProvider,
40978 &_swigt__p_wxToolTip,
40979 &_swigt__p_wxURLDataObject,
40980 &_swigt__p_wxUpdateUIEvent,
40981 &_swigt__p_wxValidator,
40982 &_swigt__p_wxVideoMode,
40983 &_swigt__p_wxWindow,
40984 &_swigt__p_wxWindowCreateEvent,
40985 &_swigt__p_wxWindowDestroyEvent,
40986 &_swigt__p_wxWindowDisabler,
40987 &_swigt__p_wxXPMHandler,
40988 };
40989
40990 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
40991 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
40992 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
40993 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
40994 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
40995 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
40996 static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
40997 static swig_cast_info _swigc__p_wxAboutDialogInfo[] = { {&_swigt__p_wxAboutDialogInfo, 0, 0, 0},{0, 0, 0, 0}};
40998 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
40999 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
41000 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}};
41001 static swig_cast_info _swigc__p_wxBusyCursor[] = { {&_swigt__p_wxBusyCursor, 0, 0, 0},{0, 0, 0, 0}};
41002 static swig_cast_info _swigc__p_wxBusyInfo[] = { {&_swigt__p_wxBusyInfo, 0, 0, 0},{0, 0, 0, 0}};
41003 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
41004 static swig_cast_info _swigc__p_wxChar[] = { {&_swigt__p_wxChar, 0, 0, 0},{0, 0, 0, 0}};
41005 static swig_cast_info _swigc__p_wxClipboard[] = { {&_swigt__p_wxClipboard, 0, 0, 0},{0, 0, 0, 0}};
41006 static swig_cast_info _swigc__p_wxClipboardLocker[] = { {&_swigt__p_wxClipboardLocker, 0, 0, 0},{0, 0, 0, 0}};
41007 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
41008 static swig_cast_info _swigc__p_wxConfig[] = { {&_swigt__p_wxConfig, 0, 0, 0},{0, 0, 0, 0}};
41009 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}};
41010 static swig_cast_info _swigc__p_wxConfigPathChanger[] = { {&_swigt__p_wxConfigPathChanger, 0, 0, 0},{0, 0, 0, 0}};
41011 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
41012 static swig_cast_info _swigc__p_wxCustomDataObject[] = { {&_swigt__p_wxCustomDataObject, 0, 0, 0},{0, 0, 0, 0}};
41013 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
41014 static swig_cast_info _swigc__p_wxDataFormat[] = { {&_swigt__p_wxDataFormat, 0, 0, 0},{0, 0, 0, 0}};
41015 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}};
41016 static swig_cast_info _swigc__p_wxDataObjectComposite[] = { {&_swigt__p_wxDataObjectComposite, 0, 0, 0},{0, 0, 0, 0}};
41017 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}};
41018 static swig_cast_info _swigc__p_wxDateSpan[] = { {&_swigt__p_wxDateSpan, 0, 0, 0},{0, 0, 0, 0}};
41019 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
41020 static swig_cast_info _swigc__p_wxDateTime__TimeZone[] = { {&_swigt__p_wxDateTime__TimeZone, 0, 0, 0},{0, 0, 0, 0}};
41021 static swig_cast_info _swigc__p_wxDisplay[] = { {&_swigt__p_wxDisplay, 0, 0, 0},{0, 0, 0, 0}};
41022 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
41023 static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
41024 static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
41025 static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
41026 static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
41027 static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
41028 static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
41029 static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
41030 static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
41031 static swig_cast_info _swigc__p_wxNotifyEvent[] = {{&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
41032 static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
41033 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = {{&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
41034 static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
41035 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
41036 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
41037 static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
41038 static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
41039 static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
41040 static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
41041 static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
41042 static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
41043 static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
41044 static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
41045 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = {{&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
41046 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
41047 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
41048 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
41049 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
41050 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
41051 static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
41052 static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
41053 static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
41054 static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
41055 static swig_cast_info _swigc__p_wxCommandEvent[] = {{&_swigt__p_wxCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
41056 static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
41057 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
41058 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
41059 static swig_cast_info _swigc__p_wxKeyEvent[] = {{&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
41060 static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
41061 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}};
41062 static swig_cast_info _swigc__p_wxControl[] = {{&_swigt__p_wxControl, 0, 0, 0},{0, 0, 0, 0}};
41063 static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
41064 static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
41065 static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
41066 static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};
41067 static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
41068 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}};
41069 static swig_cast_info _swigc__p_wxFileConfig[] = { {&_swigt__p_wxFileConfig, 0, 0, 0},{0, 0, 0, 0}};
41070 static swig_cast_info _swigc__p_wxFileDataObject[] = { {&_swigt__p_wxFileDataObject, 0, 0, 0},{0, 0, 0, 0}};
41071 static swig_cast_info _swigc__p_wxFileHistory[] = { {&_swigt__p_wxFileHistory, 0, 0, 0},{0, 0, 0, 0}};
41072 static swig_cast_info _swigc__p_wxFileType[] = { {&_swigt__p_wxFileType, 0, 0, 0},{0, 0, 0, 0}};
41073 static swig_cast_info _swigc__p_wxFileTypeInfo[] = { {&_swigt__p_wxFileTypeInfo, 0, 0, 0},{0, 0, 0, 0}};
41074 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
41075 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
41076 static swig_cast_info _swigc__p_wxIcon[] = { {&_swigt__p_wxIcon, 0, 0, 0},{0, 0, 0, 0}};
41077 static swig_cast_info _swigc__p_wxJoystick[] = { {&_swigt__p_wxJoystick, 0, 0, 0},{0, 0, 0, 0}};
41078 static swig_cast_info _swigc__p_wxJoystickEvent[] = { {&_swigt__p_wxJoystickEvent, 0, 0, 0},{0, 0, 0, 0}};
41079 static swig_cast_info _swigc__p_wxKillError[] = { {&_swigt__p_wxKillError, 0, 0, 0},{0, 0, 0, 0}};
41080 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}};
41081 static swig_cast_info _swigc__p_wxLogBuffer[] = { {&_swigt__p_wxLogBuffer, 0, 0, 0},{0, 0, 0, 0}};
41082 static swig_cast_info _swigc__p_wxLogChain[] = { {&_swigt__p_wxLogChain, 0, 0, 0},{0, 0, 0, 0}};
41083 static swig_cast_info _swigc__p_wxLogGui[] = { {&_swigt__p_wxLogGui, 0, 0, 0},{0, 0, 0, 0}};
41084 static swig_cast_info _swigc__p_wxLogNull[] = { {&_swigt__p_wxLogNull, 0, 0, 0},{0, 0, 0, 0}};
41085 static swig_cast_info _swigc__p_wxLogStderr[] = { {&_swigt__p_wxLogStderr, 0, 0, 0},{0, 0, 0, 0}};
41086 static swig_cast_info _swigc__p_wxLogTextCtrl[] = { {&_swigt__p_wxLogTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
41087 static swig_cast_info _swigc__p_wxLogWindow[] = { {&_swigt__p_wxLogWindow, 0, 0, 0},{0, 0, 0, 0}};
41088 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
41089 static swig_cast_info _swigc__p_wxMetafile[] = { {&_swigt__p_wxMetafile, 0, 0, 0},{0, 0, 0, 0}};
41090 static swig_cast_info _swigc__p_wxMetafileDataObject[] = { {&_swigt__p_wxMetafileDataObject, 0, 0, 0},{0, 0, 0, 0}};
41091 static swig_cast_info _swigc__p_wxMimeTypesManager[] = { {&_swigt__p_wxMimeTypesManager, 0, 0, 0},{0, 0, 0, 0}};
41092 static swig_cast_info _swigc__p_wxMouseState[] = { {&_swigt__p_wxMouseState, 0, 0, 0},{0, 0, 0, 0}};
41093 static swig_cast_info _swigc__p_wxMutexGuiLocker[] = { {&_swigt__p_wxMutexGuiLocker, 0, 0, 0},{0, 0, 0, 0}};
41094 static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
41095 static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
41096 static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
41097 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
41098 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
41099 static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
41100 static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
41101 static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
41102 static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
41103 static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
41104 static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
41105 static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
41106 static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
41107 static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
41108 static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
41109 static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
41110 static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
41111 static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
41112 static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
41113 static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
41114 static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
41115 static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
41116 static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
41117 static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
41118 static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
41119 static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
41120 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
41121 static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
41122 static swig_cast_info _swigc__p_wxImage[] = {{&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
41123 static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
41124 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}};
41125 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
41126 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
41127 static swig_cast_info _swigc__p_wxPlatformInfo[] = { {&_swigt__p_wxPlatformInfo, 0, 0, 0},{0, 0, 0, 0}};
41128 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
41129 static swig_cast_info _swigc__p_wxPowerEvent[] = { {&_swigt__p_wxPowerEvent, 0, 0, 0},{0, 0, 0, 0}};
41130 static swig_cast_info _swigc__p_wxProcessEvent[] = { {&_swigt__p_wxProcessEvent, 0, 0, 0},{0, 0, 0, 0}};
41131 static swig_cast_info _swigc__p_wxPyArtProvider[] = { {&_swigt__p_wxPyArtProvider, 0, 0, 0},{0, 0, 0, 0}};
41132 static swig_cast_info _swigc__p_wxPyBitmapDataObject[] = { {&_swigt__p_wxPyBitmapDataObject, 0, 0, 0},{0, 0, 0, 0}};
41133 static swig_cast_info _swigc__p_wxPyDataObjectSimple[] = { {&_swigt__p_wxPyDataObjectSimple, 0, 0, 0},{0, 0, 0, 0}};
41134 static swig_cast_info _swigc__p_wxPyDropSource[] = { {&_swigt__p_wxPyDropSource, 0, 0, 0},{0, 0, 0, 0}};
41135 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}};
41136 static swig_cast_info _swigc__p_wxPyFileDropTarget[] = { {&_swigt__p_wxPyFileDropTarget, 0, 0, 0},{0, 0, 0, 0}};
41137 static swig_cast_info _swigc__p_wxPyLog[] = { {&_swigt__p_wxPyLog, 0, 0, 0},{0, 0, 0, 0}};
41138 static swig_cast_info _swigc__p_wxPyProcess[] = { {&_swigt__p_wxPyProcess, 0, 0, 0},{0, 0, 0, 0}};
41139 static swig_cast_info _swigc__p_wxPyTextDataObject[] = { {&_swigt__p_wxPyTextDataObject, 0, 0, 0},{0, 0, 0, 0}};
41140 static swig_cast_info _swigc__p_wxPyTextDropTarget[] = { {&_swigt__p_wxPyTextDropTarget, 0, 0, 0},{0, 0, 0, 0}};
41141 static swig_cast_info _swigc__p_wxPyTimer[] = { {&_swigt__p_wxPyTimer, 0, 0, 0},{0, 0, 0, 0}};
41142 static swig_cast_info _swigc__p_wxPyTipProvider[] = { {&_swigt__p_wxPyTipProvider, 0, 0, 0},{0, 0, 0, 0}};
41143 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
41144 static swig_cast_info _swigc__p_wxSingleInstanceChecker[] = { {&_swigt__p_wxSingleInstanceChecker, 0, 0, 0},{0, 0, 0, 0}};
41145 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
41146 static swig_cast_info _swigc__p_wxSound[] = { {&_swigt__p_wxSound, 0, 0, 0},{0, 0, 0, 0}};
41147 static swig_cast_info _swigc__p_wxStandardPaths[] = { {&_swigt__p_wxStandardPaths, 0, 0, 0},{0, 0, 0, 0}};
41148 static swig_cast_info _swigc__p_wxStopWatch[] = { {&_swigt__p_wxStopWatch, 0, 0, 0},{0, 0, 0, 0}};
41149 static swig_cast_info _swigc__p_wxString[] = { {&_swigt__p_wxString, 0, 0, 0},{0, 0, 0, 0}};
41150 static swig_cast_info _swigc__p_wxSystemOptions[] = { {&_swigt__p_wxSystemOptions, 0, 0, 0},{0, 0, 0, 0}};
41151 static swig_cast_info _swigc__p_wxSystemSettings[] = { {&_swigt__p_wxSystemSettings, 0, 0, 0},{0, 0, 0, 0}};
41152 static swig_cast_info _swigc__p_wxTextCtrl[] = { {&_swigt__p_wxTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
41153 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}};
41154 static swig_cast_info _swigc__p_wxTimeSpan[] = { {&_swigt__p_wxTimeSpan, 0, 0, 0},{0, 0, 0, 0}};
41155 static swig_cast_info _swigc__p_wxTimer[] = { {&_swigt__p_wxTimer, 0, 0, 0},{0, 0, 0, 0}};
41156 static swig_cast_info _swigc__p_wxTimerEvent[] = { {&_swigt__p_wxTimerEvent, 0, 0, 0},{0, 0, 0, 0}};
41157 static swig_cast_info _swigc__p_wxTimerRunner[] = { {&_swigt__p_wxTimerRunner, 0, 0, 0},{0, 0, 0, 0}};
41158 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}};
41159 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
41160 static swig_cast_info _swigc__p_wxURLDataObject[] = { {&_swigt__p_wxURLDataObject, 0, 0, 0},{0, 0, 0, 0}};
41161 static swig_cast_info _swigc__p_wxVideoMode[] = { {&_swigt__p_wxVideoMode, 0, 0, 0},{0, 0, 0, 0}};
41162 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}};
41163 static swig_cast_info _swigc__p_wxWindowDisabler[] = { {&_swigt__p_wxWindowDisabler, 0, 0, 0},{0, 0, 0, 0}};
41164
41165 static swig_cast_info *swig_cast_initial[] = {
41166 _swigc__p_char,
41167 _swigc__p_form_ops_t,
41168 _swigc__p_int,
41169 _swigc__p_unsigned_char,
41170 _swigc__p_unsigned_int,
41171 _swigc__p_unsigned_long,
41172 _swigc__p_void,
41173 _swigc__p_wxANIHandler,
41174 _swigc__p_wxAboutDialogInfo,
41175 _swigc__p_wxAcceleratorTable,
41176 _swigc__p_wxActivateEvent,
41177 _swigc__p_wxArrayString,
41178 _swigc__p_wxBMPHandler,
41179 _swigc__p_wxBitmap,
41180 _swigc__p_wxBitmapDataObject,
41181 _swigc__p_wxBoxSizer,
41182 _swigc__p_wxBusyCursor,
41183 _swigc__p_wxBusyInfo,
41184 _swigc__p_wxCURHandler,
41185 _swigc__p_wxCaret,
41186 _swigc__p_wxChar,
41187 _swigc__p_wxChildFocusEvent,
41188 _swigc__p_wxClipboard,
41189 _swigc__p_wxClipboardLocker,
41190 _swigc__p_wxClipboardTextEvent,
41191 _swigc__p_wxCloseEvent,
41192 _swigc__p_wxColour,
41193 _swigc__p_wxCommandEvent,
41194 _swigc__p_wxConfig,
41195 _swigc__p_wxConfigBase,
41196 _swigc__p_wxConfigPathChanger,
41197 _swigc__p_wxContextMenuEvent,
41198 _swigc__p_wxControl,
41199 _swigc__p_wxControlWithItems,
41200 _swigc__p_wxCursor,
41201 _swigc__p_wxCustomDataObject,
41202 _swigc__p_wxDC,
41203 _swigc__p_wxDataFormat,
41204 _swigc__p_wxDataObject,
41205 _swigc__p_wxDataObjectComposite,
41206 _swigc__p_wxDataObjectSimple,
41207 _swigc__p_wxDateEvent,
41208 _swigc__p_wxDateSpan,
41209 _swigc__p_wxDateTime,
41210 _swigc__p_wxDateTime__TimeZone,
41211 _swigc__p_wxDisplay,
41212 _swigc__p_wxDisplayChangedEvent,
41213 _swigc__p_wxDropFilesEvent,
41214 _swigc__p_wxDuplexMode,
41215 _swigc__p_wxEraseEvent,
41216 _swigc__p_wxEvent,
41217 _swigc__p_wxEvtHandler,
41218 _swigc__p_wxFSFile,
41219 _swigc__p_wxFileConfig,
41220 _swigc__p_wxFileDataObject,
41221 _swigc__p_wxFileHistory,
41222 _swigc__p_wxFileSystem,
41223 _swigc__p_wxFileType,
41224 _swigc__p_wxFileTypeInfo,
41225 _swigc__p_wxFlexGridSizer,
41226 _swigc__p_wxFocusEvent,
41227 _swigc__p_wxFont,
41228 _swigc__p_wxFrame,
41229 _swigc__p_wxGBSizerItem,
41230 _swigc__p_wxGIFHandler,
41231 _swigc__p_wxGridBagSizer,
41232 _swigc__p_wxGridSizer,
41233 _swigc__p_wxICOHandler,
41234 _swigc__p_wxIcon,
41235 _swigc__p_wxIconizeEvent,
41236 _swigc__p_wxIdleEvent,
41237 _swigc__p_wxImage,
41238 _swigc__p_wxImageHandler,
41239 _swigc__p_wxIndividualLayoutConstraint,
41240 _swigc__p_wxInitDialogEvent,
41241 _swigc__p_wxJPEGHandler,
41242 _swigc__p_wxJoystick,
41243 _swigc__p_wxJoystickEvent,
41244 _swigc__p_wxKeyEvent,
41245 _swigc__p_wxKillError,
41246 _swigc__p_wxLayoutConstraints,
41247 _swigc__p_wxLog,
41248 _swigc__p_wxLogBuffer,
41249 _swigc__p_wxLogChain,
41250 _swigc__p_wxLogGui,
41251 _swigc__p_wxLogNull,
41252 _swigc__p_wxLogStderr,
41253 _swigc__p_wxLogTextCtrl,
41254 _swigc__p_wxLogWindow,
41255 _swigc__p_wxMaximizeEvent,
41256 _swigc__p_wxMenu,
41257 _swigc__p_wxMenuBar,
41258 _swigc__p_wxMenuEvent,
41259 _swigc__p_wxMenuItem,
41260 _swigc__p_wxMetafile,
41261 _swigc__p_wxMetafileDataObject,
41262 _swigc__p_wxMimeTypesManager,
41263 _swigc__p_wxMouseCaptureChangedEvent,
41264 _swigc__p_wxMouseCaptureLostEvent,
41265 _swigc__p_wxMouseEvent,
41266 _swigc__p_wxMouseState,
41267 _swigc__p_wxMoveEvent,
41268 _swigc__p_wxMutexGuiLocker,
41269 _swigc__p_wxNavigationKeyEvent,
41270 _swigc__p_wxNcPaintEvent,
41271 _swigc__p_wxNotifyEvent,
41272 _swigc__p_wxObject,
41273 _swigc__p_wxOutputStream,
41274 _swigc__p_wxPCXHandler,
41275 _swigc__p_wxPNGHandler,
41276 _swigc__p_wxPNMHandler,
41277 _swigc__p_wxPaintEvent,
41278 _swigc__p_wxPaletteChangedEvent,
41279 _swigc__p_wxPaperSize,
41280 _swigc__p_wxPlatformInfo,
41281 _swigc__p_wxPoint,
41282 _swigc__p_wxPowerEvent,
41283 _swigc__p_wxProcessEvent,
41284 _swigc__p_wxPyApp,
41285 _swigc__p_wxPyArtProvider,
41286 _swigc__p_wxPyBitmapDataObject,
41287 _swigc__p_wxPyCommandEvent,
41288 _swigc__p_wxPyDataObjectSimple,
41289 _swigc__p_wxPyDropSource,
41290 _swigc__p_wxPyDropTarget,
41291 _swigc__p_wxPyEvent,
41292 _swigc__p_wxPyFileDropTarget,
41293 _swigc__p_wxPyImageHandler,
41294 _swigc__p_wxPyLog,
41295 _swigc__p_wxPyProcess,
41296 _swigc__p_wxPySizer,
41297 _swigc__p_wxPyTextDataObject,
41298 _swigc__p_wxPyTextDropTarget,
41299 _swigc__p_wxPyTimer,
41300 _swigc__p_wxPyTipProvider,
41301 _swigc__p_wxPyValidator,
41302 _swigc__p_wxQueryNewPaletteEvent,
41303 _swigc__p_wxRect,
41304 _swigc__p_wxScrollEvent,
41305 _swigc__p_wxScrollWinEvent,
41306 _swigc__p_wxSetCursorEvent,
41307 _swigc__p_wxShowEvent,
41308 _swigc__p_wxSingleInstanceChecker,
41309 _swigc__p_wxSize,
41310 _swigc__p_wxSizeEvent,
41311 _swigc__p_wxSizer,
41312 _swigc__p_wxSizerItem,
41313 _swigc__p_wxSound,
41314 _swigc__p_wxStandardPaths,
41315 _swigc__p_wxStaticBoxSizer,
41316 _swigc__p_wxStdDialogButtonSizer,
41317 _swigc__p_wxStopWatch,
41318 _swigc__p_wxString,
41319 _swigc__p_wxSysColourChangedEvent,
41320 _swigc__p_wxSystemOptions,
41321 _swigc__p_wxSystemSettings,
41322 _swigc__p_wxTIFFHandler,
41323 _swigc__p_wxTextCtrl,
41324 _swigc__p_wxTextDataObject,
41325 _swigc__p_wxTimeSpan,
41326 _swigc__p_wxTimer,
41327 _swigc__p_wxTimerEvent,
41328 _swigc__p_wxTimerRunner,
41329 _swigc__p_wxTipProvider,
41330 _swigc__p_wxToolTip,
41331 _swigc__p_wxURLDataObject,
41332 _swigc__p_wxUpdateUIEvent,
41333 _swigc__p_wxValidator,
41334 _swigc__p_wxVideoMode,
41335 _swigc__p_wxWindow,
41336 _swigc__p_wxWindowCreateEvent,
41337 _swigc__p_wxWindowDestroyEvent,
41338 _swigc__p_wxWindowDisabler,
41339 _swigc__p_wxXPMHandler,
41340 };
41341
41342
41343 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
41344
41345 static swig_const_info swig_const_table[] = {
41346 {0, 0, 0, 0.0, 0, 0}};
41347
41348 #ifdef __cplusplus
41349 }
41350 #endif
41351 /* -----------------------------------------------------------------------------
41352 * Type initialization:
41353 * This problem is tough by the requirement that no dynamic
41354 * memory is used. Also, since swig_type_info structures store pointers to
41355 * swig_cast_info structures and swig_cast_info structures store pointers back
41356 * to swig_type_info structures, we need some lookup code at initialization.
41357 * The idea is that swig generates all the structures that are needed.
41358 * The runtime then collects these partially filled structures.
41359 * The SWIG_InitializeModule function takes these initial arrays out of
41360 * swig_module, and does all the lookup, filling in the swig_module.types
41361 * array with the correct data and linking the correct swig_cast_info
41362 * structures together.
41363 *
41364 * The generated swig_type_info structures are assigned staticly to an initial
41365 * array. We just loop though that array, and handle each type individually.
41366 * First we lookup if this type has been already loaded, and if so, use the
41367 * loaded structure instead of the generated one. Then we have to fill in the
41368 * cast linked list. The cast data is initially stored in something like a
41369 * two-dimensional array. Each row corresponds to a type (there are the same
41370 * number of rows as there are in the swig_type_initial array). Each entry in
41371 * a column is one of the swig_cast_info structures for that type.
41372 * The cast_initial array is actually an array of arrays, because each row has
41373 * a variable number of columns. So to actually build the cast linked list,
41374 * we find the array of casts associated with the type, and loop through it
41375 * adding the casts to the list. The one last trick we need to do is making
41376 * sure the type pointer in the swig_cast_info struct is correct.
41377 *
41378 * First off, we lookup the cast->type name to see if it is already loaded.
41379 * There are three cases to handle:
41380 * 1) If the cast->type has already been loaded AND the type we are adding
41381 * casting info to has not been loaded (it is in this module), THEN we
41382 * replace the cast->type pointer with the type pointer that has already
41383 * been loaded.
41384 * 2) If BOTH types (the one we are adding casting info to, and the
41385 * cast->type) are loaded, THEN the cast info has already been loaded by
41386 * the previous module so we just ignore it.
41387 * 3) Finally, if cast->type has not already been loaded, then we add that
41388 * swig_cast_info to the linked list (because the cast->type) pointer will
41389 * be correct.
41390 * ----------------------------------------------------------------------------- */
41391
41392 #ifdef __cplusplus
41393 extern "C" {
41394 #if 0
41395 } /* c-mode */
41396 #endif
41397 #endif
41398
41399 #if 0
41400 #define SWIGRUNTIME_DEBUG
41401 #endif
41402
41403 SWIGRUNTIME void
41404 SWIG_InitializeModule(void *clientdata) {
41405 size_t i;
41406 swig_module_info *module_head;
41407 static int init_run = 0;
41408
41409 clientdata = clientdata;
41410
41411 if (init_run) return;
41412 init_run = 1;
41413
41414 /* Initialize the swig_module */
41415 swig_module.type_initial = swig_type_initial;
41416 swig_module.cast_initial = swig_cast_initial;
41417
41418 /* Try and load any already created modules */
41419 module_head = SWIG_GetModule(clientdata);
41420 if (module_head) {
41421 swig_module.next = module_head->next;
41422 module_head->next = &swig_module;
41423 } else {
41424 /* This is the first module loaded */
41425 swig_module.next = &swig_module;
41426 SWIG_SetModule(clientdata, &swig_module);
41427 }
41428
41429 /* Now work on filling in swig_module.types */
41430 #ifdef SWIGRUNTIME_DEBUG
41431 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
41432 #endif
41433 for (i = 0; i < swig_module.size; ++i) {
41434 swig_type_info *type = 0;
41435 swig_type_info *ret;
41436 swig_cast_info *cast;
41437
41438 #ifdef SWIGRUNTIME_DEBUG
41439 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
41440 #endif
41441
41442 /* if there is another module already loaded */
41443 if (swig_module.next != &swig_module) {
41444 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
41445 }
41446 if (type) {
41447 /* Overwrite clientdata field */
41448 #ifdef SWIGRUNTIME_DEBUG
41449 printf("SWIG_InitializeModule: found type %s\n", type->name);
41450 #endif
41451 if (swig_module.type_initial[i]->clientdata) {
41452 type->clientdata = swig_module.type_initial[i]->clientdata;
41453 #ifdef SWIGRUNTIME_DEBUG
41454 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
41455 #endif
41456 }
41457 } else {
41458 type = swig_module.type_initial[i];
41459 }
41460
41461 /* Insert casting types */
41462 cast = swig_module.cast_initial[i];
41463 while (cast->type) {
41464 /* Don't need to add information already in the list */
41465 ret = 0;
41466 #ifdef SWIGRUNTIME_DEBUG
41467 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
41468 #endif
41469 if (swig_module.next != &swig_module) {
41470 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
41471 #ifdef SWIGRUNTIME_DEBUG
41472 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
41473 #endif
41474 }
41475 if (ret) {
41476 if (type == swig_module.type_initial[i]) {
41477 #ifdef SWIGRUNTIME_DEBUG
41478 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
41479 #endif
41480 cast->type = ret;
41481 ret = 0;
41482 } else {
41483 /* Check for casting already in the list */
41484 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
41485 #ifdef SWIGRUNTIME_DEBUG
41486 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
41487 #endif
41488 if (!ocast) ret = 0;
41489 }
41490 }
41491
41492 if (!ret) {
41493 #ifdef SWIGRUNTIME_DEBUG
41494 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
41495 #endif
41496 if (type->cast) {
41497 type->cast->prev = cast;
41498 cast->next = type->cast;
41499 }
41500 type->cast = cast;
41501 }
41502 cast++;
41503 }
41504 /* Set entry in modules->types array equal to the type */
41505 swig_module.types[i] = type;
41506 }
41507 swig_module.types[i] = 0;
41508
41509 #ifdef SWIGRUNTIME_DEBUG
41510 printf("**** SWIG_InitializeModule: Cast List ******\n");
41511 for (i = 0; i < swig_module.size; ++i) {
41512 int j = 0;
41513 swig_cast_info *cast = swig_module.cast_initial[i];
41514 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
41515 while (cast->type) {
41516 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
41517 cast++;
41518 ++j;
41519 }
41520 printf("---- Total casts: %d\n",j);
41521 }
41522 printf("**** SWIG_InitializeModule: Cast List ******\n");
41523 #endif
41524 }
41525
41526 /* This function will propagate the clientdata field of type to
41527 * any new swig_type_info structures that have been added into the list
41528 * of equivalent types. It is like calling
41529 * SWIG_TypeClientData(type, clientdata) a second time.
41530 */
41531 SWIGRUNTIME void
41532 SWIG_PropagateClientData(void) {
41533 size_t i;
41534 swig_cast_info *equiv;
41535 static int init_run = 0;
41536
41537 if (init_run) return;
41538 init_run = 1;
41539
41540 for (i = 0; i < swig_module.size; i++) {
41541 if (swig_module.types[i]->clientdata) {
41542 equiv = swig_module.types[i]->cast;
41543 while (equiv) {
41544 if (!equiv->converter) {
41545 if (equiv->type && !equiv->type->clientdata)
41546 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
41547 }
41548 equiv = equiv->next;
41549 }
41550 }
41551 }
41552 }
41553
41554 #ifdef __cplusplus
41555 #if 0
41556 {
41557 /* c-mode */
41558 #endif
41559 }
41560 #endif
41561
41562
41563
41564 #ifdef __cplusplus
41565 extern "C" {
41566 #endif
41567
41568 /* Python-specific SWIG API */
41569 #define SWIG_newvarlink() SWIG_Python_newvarlink()
41570 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
41571 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
41572
41573 /* -----------------------------------------------------------------------------
41574 * global variable support code.
41575 * ----------------------------------------------------------------------------- */
41576
41577 typedef struct swig_globalvar {
41578 char *name; /* Name of global variable */
41579 PyObject *(*get_attr)(void); /* Return the current value */
41580 int (*set_attr)(PyObject *); /* Set the value */
41581 struct swig_globalvar *next;
41582 } swig_globalvar;
41583
41584 typedef struct swig_varlinkobject {
41585 PyObject_HEAD
41586 swig_globalvar *vars;
41587 } swig_varlinkobject;
41588
41589 SWIGINTERN PyObject *
41590 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
41591 return PyString_FromString("<Swig global variables>");
41592 }
41593
41594 SWIGINTERN PyObject *
41595 swig_varlink_str(swig_varlinkobject *v) {
41596 PyObject *str = PyString_FromString("(");
41597 swig_globalvar *var;
41598 for (var = v->vars; var; var=var->next) {
41599 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
41600 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
41601 }
41602 PyString_ConcatAndDel(&str,PyString_FromString(")"));
41603 return str;
41604 }
41605
41606 SWIGINTERN int
41607 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
41608 PyObject *str = swig_varlink_str(v);
41609 fprintf(fp,"Swig global variables ");
41610 fprintf(fp,"%s\n", PyString_AsString(str));
41611 Py_DECREF(str);
41612 return 0;
41613 }
41614
41615 SWIGINTERN void
41616 swig_varlink_dealloc(swig_varlinkobject *v) {
41617 swig_globalvar *var = v->vars;
41618 while (var) {
41619 swig_globalvar *n = var->next;
41620 free(var->name);
41621 free(var);
41622 var = n;
41623 }
41624 }
41625
41626 SWIGINTERN PyObject *
41627 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
41628 PyObject *res = NULL;
41629 swig_globalvar *var = v->vars;
41630 while (var) {
41631 if (strcmp(var->name,n) == 0) {
41632 res = (*var->get_attr)();
41633 break;
41634 }
41635 var = var->next;
41636 }
41637 if (res == NULL && !PyErr_Occurred()) {
41638 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
41639 }
41640 return res;
41641 }
41642
41643 SWIGINTERN int
41644 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
41645 int res = 1;
41646 swig_globalvar *var = v->vars;
41647 while (var) {
41648 if (strcmp(var->name,n) == 0) {
41649 res = (*var->set_attr)(p);
41650 break;
41651 }
41652 var = var->next;
41653 }
41654 if (res == 1 && !PyErr_Occurred()) {
41655 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
41656 }
41657 return res;
41658 }
41659
41660 SWIGINTERN PyTypeObject*
41661 swig_varlink_type(void) {
41662 static char varlink__doc__[] = "Swig var link object";
41663 static PyTypeObject varlink_type;
41664 static int type_init = 0;
41665 if (!type_init) {
41666 const PyTypeObject tmp
41667 = {
41668 PyObject_HEAD_INIT(NULL)
41669 0, /* Number of items in variable part (ob_size) */
41670 (char *)"swigvarlink", /* Type name (tp_name) */
41671 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
41672 0, /* Itemsize (tp_itemsize) */
41673 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
41674 (printfunc) swig_varlink_print, /* Print (tp_print) */
41675 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
41676 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
41677 0, /* tp_compare */
41678 (reprfunc) swig_varlink_repr, /* tp_repr */
41679 0, /* tp_as_number */
41680 0, /* tp_as_sequence */
41681 0, /* tp_as_mapping */
41682 0, /* tp_hash */
41683 0, /* tp_call */
41684 (reprfunc)swig_varlink_str, /* tp_str */
41685 0, /* tp_getattro */
41686 0, /* tp_setattro */
41687 0, /* tp_as_buffer */
41688 0, /* tp_flags */
41689 varlink__doc__, /* tp_doc */
41690 0, /* tp_traverse */
41691 0, /* tp_clear */
41692 0, /* tp_richcompare */
41693 0, /* tp_weaklistoffset */
41694 #if PY_VERSION_HEX >= 0x02020000
41695 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
41696 #endif
41697 #if PY_VERSION_HEX >= 0x02030000
41698 0, /* tp_del */
41699 #endif
41700 #ifdef COUNT_ALLOCS
41701 0,0,0,0 /* tp_alloc -> tp_next */
41702 #endif
41703 };
41704 varlink_type = tmp;
41705 varlink_type.ob_type = &PyType_Type;
41706 type_init = 1;
41707 }
41708 return &varlink_type;
41709 }
41710
41711 /* Create a variable linking object for use later */
41712 SWIGINTERN PyObject *
41713 SWIG_Python_newvarlink(void) {
41714 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
41715 if (result) {
41716 result->vars = 0;
41717 }
41718 return ((PyObject*) result);
41719 }
41720
41721 SWIGINTERN void
41722 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
41723 swig_varlinkobject *v = (swig_varlinkobject *) p;
41724 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
41725 if (gv) {
41726 size_t size = strlen(name)+1;
41727 gv->name = (char *)malloc(size);
41728 if (gv->name) {
41729 strncpy(gv->name,name,size);
41730 gv->get_attr = get_attr;
41731 gv->set_attr = set_attr;
41732 gv->next = v->vars;
41733 }
41734 }
41735 v->vars = gv;
41736 }
41737
41738 SWIGINTERN PyObject *
41739 SWIG_globals() {
41740 static PyObject *_SWIG_globals = 0;
41741 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
41742 return _SWIG_globals;
41743 }
41744
41745 /* -----------------------------------------------------------------------------
41746 * constants/methods manipulation
41747 * ----------------------------------------------------------------------------- */
41748
41749 /* Install Constants */
41750 SWIGINTERN void
41751 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
41752 PyObject *obj = 0;
41753 size_t i;
41754 for (i = 0; constants[i].type; ++i) {
41755 switch(constants[i].type) {
41756 case SWIG_PY_POINTER:
41757 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
41758 break;
41759 case SWIG_PY_BINARY:
41760 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
41761 break;
41762 default:
41763 obj = 0;
41764 break;
41765 }
41766 if (obj) {
41767 PyDict_SetItemString(d, constants[i].name, obj);
41768 Py_DECREF(obj);
41769 }
41770 }
41771 }
41772
41773 /* -----------------------------------------------------------------------------*/
41774 /* Fix SwigMethods to carry the callback ptrs when needed */
41775 /* -----------------------------------------------------------------------------*/
41776
41777 SWIGINTERN void
41778 SWIG_Python_FixMethods(PyMethodDef *methods,
41779 swig_const_info *const_table,
41780 swig_type_info **types,
41781 swig_type_info **types_initial) {
41782 size_t i;
41783 for (i = 0; methods[i].ml_name; ++i) {
41784 const char *c = methods[i].ml_doc;
41785 if (c && (c = strstr(c, "swig_ptr: "))) {
41786 int j;
41787 swig_const_info *ci = 0;
41788 const char *name = c + 10;
41789 for (j = 0; const_table[j].type; ++j) {
41790 if (strncmp(const_table[j].name, name,
41791 strlen(const_table[j].name)) == 0) {
41792 ci = &(const_table[j]);
41793 break;
41794 }
41795 }
41796 if (ci) {
41797 size_t shift = (ci->ptype) - types;
41798 swig_type_info *ty = types_initial[shift];
41799 size_t ldoc = (c - methods[i].ml_doc);
41800 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
41801 char *ndoc = (char*)malloc(ldoc + lptr + 10);
41802 if (ndoc) {
41803 char *buff = ndoc;
41804 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
41805 if (ptr) {
41806 strncpy(buff, methods[i].ml_doc, ldoc);
41807 buff += ldoc;
41808 strncpy(buff, "swig_ptr: ", 10);
41809 buff += 10;
41810 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
41811 methods[i].ml_doc = ndoc;
41812 }
41813 }
41814 }
41815 }
41816 }
41817 }
41818
41819 #ifdef __cplusplus
41820 }
41821 #endif
41822
41823 /* -----------------------------------------------------------------------------*
41824 * Partial Init method
41825 * -----------------------------------------------------------------------------*/
41826
41827 #ifdef __cplusplus
41828 extern "C"
41829 #endif
41830 SWIGEXPORT void SWIG_init(void) {
41831 PyObject *m, *d;
41832
41833 /* Fix SwigMethods to carry the callback ptrs when needed */
41834 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
41835
41836 m = Py_InitModule((char *) SWIG_name, SwigMethods);
41837 d = PyModule_GetDict(m);
41838
41839 SWIG_InitializeModule(0);
41840 SWIG_InstallConstants(d,swig_const_table);
41841
41842
41843 SWIG_Python_SetConstant(d, "SYS_OEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_OEM_FIXED_FONT)));
41844 SWIG_Python_SetConstant(d, "SYS_ANSI_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_FIXED_FONT)));
41845 SWIG_Python_SetConstant(d, "SYS_ANSI_VAR_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_VAR_FONT)));
41846 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FONT)));
41847 SWIG_Python_SetConstant(d, "SYS_DEVICE_DEFAULT_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEVICE_DEFAULT_FONT)));
41848 SWIG_Python_SetConstant(d, "SYS_DEFAULT_PALETTE",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_PALETTE)));
41849 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FIXED_FONT)));
41850 SWIG_Python_SetConstant(d, "SYS_DEFAULT_GUI_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_GUI_FONT)));
41851 SWIG_Python_SetConstant(d, "SYS_ICONTITLE_FONT",SWIG_From_int(static_cast< int >(wxSYS_ICONTITLE_FONT)));
41852 SWIG_Python_SetConstant(d, "SYS_COLOUR_SCROLLBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_SCROLLBAR)));
41853 SWIG_Python_SetConstant(d, "SYS_COLOUR_BACKGROUND",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BACKGROUND)));
41854 SWIG_Python_SetConstant(d, "SYS_COLOUR_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_DESKTOP)));
41855 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVECAPTION)));
41856 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTION)));
41857 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENU",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENU)));
41858 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOW)));
41859 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWFRAME",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWFRAME)));
41860 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUTEXT)));
41861 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWTEXT)));
41862 SWIG_Python_SetConstant(d, "SYS_COLOUR_CAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_CAPTIONTEXT)));
41863 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVEBORDER)));
41864 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVEBORDER)));
41865 SWIG_Python_SetConstant(d, "SYS_COLOUR_APPWORKSPACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_APPWORKSPACE)));
41866 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHT)));
41867 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHTTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHTTEXT)));
41868 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNFACE)));
41869 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DFACE)));
41870 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNSHADOW)));
41871 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DSHADOW)));
41872 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRAYTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRAYTEXT)));
41873 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNTEXT)));
41874 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
41875 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHIGHLIGHT)));
41876 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHILIGHT)));
41877 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHIGHLIGHT)));
41878 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHILIGHT)));
41879 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DDKSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DDKSHADOW)));
41880 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DLIGHT)));
41881 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOTEXT)));
41882 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOBK",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOBK)));
41883 SWIG_Python_SetConstant(d, "SYS_COLOUR_LISTBOX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_LISTBOX)));
41884 SWIG_Python_SetConstant(d, "SYS_COLOUR_HOTLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HOTLIGHT)));
41885 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
41886 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTINACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
41887 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUHILIGHT)));
41888 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUBAR)));
41889 SWIG_Python_SetConstant(d, "SYS_COLOUR_MAX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MAX)));
41890 SWIG_Python_SetConstant(d, "SYS_MOUSE_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_MOUSE_BUTTONS)));
41891 SWIG_Python_SetConstant(d, "SYS_BORDER_X",SWIG_From_int(static_cast< int >(wxSYS_BORDER_X)));
41892 SWIG_Python_SetConstant(d, "SYS_BORDER_Y",SWIG_From_int(static_cast< int >(wxSYS_BORDER_Y)));
41893 SWIG_Python_SetConstant(d, "SYS_CURSOR_X",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_X)));
41894 SWIG_Python_SetConstant(d, "SYS_CURSOR_Y",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_Y)));
41895 SWIG_Python_SetConstant(d, "SYS_DCLICK_X",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_X)));
41896 SWIG_Python_SetConstant(d, "SYS_DCLICK_Y",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_Y)));
41897 SWIG_Python_SetConstant(d, "SYS_DRAG_X",SWIG_From_int(static_cast< int >(wxSYS_DRAG_X)));
41898 SWIG_Python_SetConstant(d, "SYS_DRAG_Y",SWIG_From_int(static_cast< int >(wxSYS_DRAG_Y)));
41899 SWIG_Python_SetConstant(d, "SYS_EDGE_X",SWIG_From_int(static_cast< int >(wxSYS_EDGE_X)));
41900 SWIG_Python_SetConstant(d, "SYS_EDGE_Y",SWIG_From_int(static_cast< int >(wxSYS_EDGE_Y)));
41901 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_X)));
41902 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_Y)));
41903 SWIG_Python_SetConstant(d, "SYS_HTHUMB_X",SWIG_From_int(static_cast< int >(wxSYS_HTHUMB_X)));
41904 SWIG_Python_SetConstant(d, "SYS_ICON_X",SWIG_From_int(static_cast< int >(wxSYS_ICON_X)));
41905 SWIG_Python_SetConstant(d, "SYS_ICON_Y",SWIG_From_int(static_cast< int >(wxSYS_ICON_Y)));
41906 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_X",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_X)));
41907 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_Y",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_Y)));
41908 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_X",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_X)));
41909 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_Y",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_Y)));
41910 SWIG_Python_SetConstant(d, "SYS_SCREEN_X",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_X)));
41911 SWIG_Python_SetConstant(d, "SYS_SCREEN_Y",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_Y)));
41912 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_X",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_X)));
41913 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_Y",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_Y)));
41914 SWIG_Python_SetConstant(d, "SYS_SMALLICON_X",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_X)));
41915 SWIG_Python_SetConstant(d, "SYS_SMALLICON_Y",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_Y)));
41916 SWIG_Python_SetConstant(d, "SYS_HSCROLL_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_Y)));
41917 SWIG_Python_SetConstant(d, "SYS_VSCROLL_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_X)));
41918 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_X)));
41919 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_Y)));
41920 SWIG_Python_SetConstant(d, "SYS_VTHUMB_Y",SWIG_From_int(static_cast< int >(wxSYS_VTHUMB_Y)));
41921 SWIG_Python_SetConstant(d, "SYS_CAPTION_Y",SWIG_From_int(static_cast< int >(wxSYS_CAPTION_Y)));
41922 SWIG_Python_SetConstant(d, "SYS_MENU_Y",SWIG_From_int(static_cast< int >(wxSYS_MENU_Y)));
41923 SWIG_Python_SetConstant(d, "SYS_NETWORK_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_NETWORK_PRESENT)));
41924 SWIG_Python_SetConstant(d, "SYS_PENWINDOWS_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_PENWINDOWS_PRESENT)));
41925 SWIG_Python_SetConstant(d, "SYS_SHOW_SOUNDS",SWIG_From_int(static_cast< int >(wxSYS_SHOW_SOUNDS)));
41926 SWIG_Python_SetConstant(d, "SYS_SWAP_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_SWAP_BUTTONS)));
41927 SWIG_Python_SetConstant(d, "SYS_CAN_DRAW_FRAME_DECORATIONS",SWIG_From_int(static_cast< int >(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
41928 SWIG_Python_SetConstant(d, "SYS_CAN_ICONIZE_FRAME",SWIG_From_int(static_cast< int >(wxSYS_CAN_ICONIZE_FRAME)));
41929 SWIG_Python_SetConstant(d, "SYS_TABLET_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_TABLET_PRESENT)));
41930 SWIG_Python_SetConstant(d, "SYS_SCREEN_NONE",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_NONE)));
41931 SWIG_Python_SetConstant(d, "SYS_SCREEN_TINY",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_TINY)));
41932 SWIG_Python_SetConstant(d, "SYS_SCREEN_PDA",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_PDA)));
41933 SWIG_Python_SetConstant(d, "SYS_SCREEN_SMALL",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_SMALL)));
41934 SWIG_Python_SetConstant(d, "SYS_SCREEN_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_DESKTOP)));
41935 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
41936 SWIG_addvarlink(SWIG_globals(),(char*)"WINDOW_DEFAULT_VARIANT",WINDOW_DEFAULT_VARIANT_get, WINDOW_DEFAULT_VARIANT_set);
41937 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorPromptStr",FileSelectorPromptStr_get, FileSelectorPromptStr_set);
41938 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorDefaultWildcardStr",FileSelectorDefaultWildcardStr_get, FileSelectorDefaultWildcardStr_set);
41939 SWIG_addvarlink(SWIG_globals(),(char*)"DirSelectorPromptStr",DirSelectorPromptStr_get, DirSelectorPromptStr_set);
41940 SWIG_Python_SetConstant(d, "STOCK_NOFLAGS",SWIG_From_int(static_cast< int >(wxSTOCK_NOFLAGS)));
41941 SWIG_Python_SetConstant(d, "STOCK_WITH_MNEMONIC",SWIG_From_int(static_cast< int >(wxSTOCK_WITH_MNEMONIC)));
41942 SWIG_Python_SetConstant(d, "STOCK_WITH_ACCELERATOR",SWIG_From_int(static_cast< int >(wxSTOCK_WITH_ACCELERATOR)));
41943 SWIG_Python_SetConstant(d, "STOCK_MENU",SWIG_From_int(static_cast< int >(wxSTOCK_MENU)));
41944 SWIG_Python_SetConstant(d, "SHUTDOWN_POWEROFF",SWIG_From_int(static_cast< int >(wxSHUTDOWN_POWEROFF)));
41945 SWIG_Python_SetConstant(d, "SHUTDOWN_REBOOT",SWIG_From_int(static_cast< int >(wxSHUTDOWN_REBOOT)));
41946 SWIG_Python_SetConstant(d, "OS_UNKNOWN",SWIG_From_int(static_cast< int >(wxOS_UNKNOWN)));
41947 SWIG_Python_SetConstant(d, "OS_MAC_OS",SWIG_From_int(static_cast< int >(wxOS_MAC_OS)));
41948 SWIG_Python_SetConstant(d, "OS_MAC_OSX_DARWIN",SWIG_From_int(static_cast< int >(wxOS_MAC_OSX_DARWIN)));
41949 SWIG_Python_SetConstant(d, "OS_MAC",SWIG_From_int(static_cast< int >(wxOS_MAC)));
41950 SWIG_Python_SetConstant(d, "OS_WINDOWS_9X",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_9X)));
41951 SWIG_Python_SetConstant(d, "OS_WINDOWS_NT",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_NT)));
41952 SWIG_Python_SetConstant(d, "OS_WINDOWS_MICRO",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_MICRO)));
41953 SWIG_Python_SetConstant(d, "OS_WINDOWS_CE",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_CE)));
41954 SWIG_Python_SetConstant(d, "OS_WINDOWS",SWIG_From_int(static_cast< int >(wxOS_WINDOWS)));
41955 SWIG_Python_SetConstant(d, "OS_UNIX_LINUX",SWIG_From_int(static_cast< int >(wxOS_UNIX_LINUX)));
41956 SWIG_Python_SetConstant(d, "OS_UNIX_FREEBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_FREEBSD)));
41957 SWIG_Python_SetConstant(d, "OS_UNIX_OPENBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_OPENBSD)));
41958 SWIG_Python_SetConstant(d, "OS_UNIX_NETBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_NETBSD)));
41959 SWIG_Python_SetConstant(d, "OS_UNIX_SOLARIS",SWIG_From_int(static_cast< int >(wxOS_UNIX_SOLARIS)));
41960 SWIG_Python_SetConstant(d, "OS_UNIX_AIX",SWIG_From_int(static_cast< int >(wxOS_UNIX_AIX)));
41961 SWIG_Python_SetConstant(d, "OS_UNIX_HPUX",SWIG_From_int(static_cast< int >(wxOS_UNIX_HPUX)));
41962 SWIG_Python_SetConstant(d, "OS_UNIX",SWIG_From_int(static_cast< int >(wxOS_UNIX)));
41963 SWIG_Python_SetConstant(d, "OS_DOS",SWIG_From_int(static_cast< int >(wxOS_DOS)));
41964 SWIG_Python_SetConstant(d, "OS_OS2",SWIG_From_int(static_cast< int >(wxOS_OS2)));
41965 SWIG_Python_SetConstant(d, "PORT_UNKNOWN",SWIG_From_int(static_cast< int >(wxPORT_UNKNOWN)));
41966 SWIG_Python_SetConstant(d, "PORT_BASE",SWIG_From_int(static_cast< int >(wxPORT_BASE)));
41967 SWIG_Python_SetConstant(d, "PORT_MSW",SWIG_From_int(static_cast< int >(wxPORT_MSW)));
41968 SWIG_Python_SetConstant(d, "PORT_MOTIF",SWIG_From_int(static_cast< int >(wxPORT_MOTIF)));
41969 SWIG_Python_SetConstant(d, "PORT_GTK",SWIG_From_int(static_cast< int >(wxPORT_GTK)));
41970 SWIG_Python_SetConstant(d, "PORT_MGL",SWIG_From_int(static_cast< int >(wxPORT_MGL)));
41971 SWIG_Python_SetConstant(d, "PORT_X11",SWIG_From_int(static_cast< int >(wxPORT_X11)));
41972 SWIG_Python_SetConstant(d, "PORT_PM",SWIG_From_int(static_cast< int >(wxPORT_PM)));
41973 SWIG_Python_SetConstant(d, "PORT_OS2",SWIG_From_int(static_cast< int >(wxPORT_OS2)));
41974 SWIG_Python_SetConstant(d, "PORT_MAC",SWIG_From_int(static_cast< int >(wxPORT_MAC)));
41975 SWIG_Python_SetConstant(d, "PORT_COCOA",SWIG_From_int(static_cast< int >(wxPORT_COCOA)));
41976 SWIG_Python_SetConstant(d, "PORT_WINCE",SWIG_From_int(static_cast< int >(wxPORT_WINCE)));
41977 SWIG_Python_SetConstant(d, "PORT_PALMOS",SWIG_From_int(static_cast< int >(wxPORT_PALMOS)));
41978 SWIG_Python_SetConstant(d, "PORT_DFB",SWIG_From_int(static_cast< int >(wxPORT_DFB)));
41979 SWIG_Python_SetConstant(d, "ARCH_INVALID",SWIG_From_int(static_cast< int >(wxARCH_INVALID)));
41980 SWIG_Python_SetConstant(d, "ARCH_32",SWIG_From_int(static_cast< int >(wxARCH_32)));
41981 SWIG_Python_SetConstant(d, "ARCH_64",SWIG_From_int(static_cast< int >(wxARCH_64)));
41982 SWIG_Python_SetConstant(d, "ARCH_MAX",SWIG_From_int(static_cast< int >(wxARCH_MAX)));
41983 SWIG_Python_SetConstant(d, "ENDIAN_INVALID",SWIG_From_int(static_cast< int >(wxENDIAN_INVALID)));
41984 SWIG_Python_SetConstant(d, "ENDIAN_BIG",SWIG_From_int(static_cast< int >(wxENDIAN_BIG)));
41985 SWIG_Python_SetConstant(d, "ENDIAN_LITTLE",SWIG_From_int(static_cast< int >(wxENDIAN_LITTLE)));
41986 SWIG_Python_SetConstant(d, "ENDIAN_PDP",SWIG_From_int(static_cast< int >(wxENDIAN_PDP)));
41987 SWIG_Python_SetConstant(d, "ENDIAN_MAX",SWIG_From_int(static_cast< int >(wxENDIAN_MAX)));
41988 SWIG_Python_SetConstant(d, "TIMER_CONTINUOUS",SWIG_From_int(static_cast< int >(wxTIMER_CONTINUOUS)));
41989 SWIG_Python_SetConstant(d, "TIMER_ONE_SHOT",SWIG_From_int(static_cast< int >(wxTIMER_ONE_SHOT)));
41990 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
41991
41992 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
41993
41994 SWIG_Python_SetConstant(d, "LOG_FatalError",SWIG_From_int(static_cast< int >(wxLOG_FatalError)));
41995 SWIG_Python_SetConstant(d, "LOG_Error",SWIG_From_int(static_cast< int >(wxLOG_Error)));
41996 SWIG_Python_SetConstant(d, "LOG_Warning",SWIG_From_int(static_cast< int >(wxLOG_Warning)));
41997 SWIG_Python_SetConstant(d, "LOG_Message",SWIG_From_int(static_cast< int >(wxLOG_Message)));
41998 SWIG_Python_SetConstant(d, "LOG_Status",SWIG_From_int(static_cast< int >(wxLOG_Status)));
41999 SWIG_Python_SetConstant(d, "LOG_Info",SWIG_From_int(static_cast< int >(wxLOG_Info)));
42000 SWIG_Python_SetConstant(d, "LOG_Debug",SWIG_From_int(static_cast< int >(wxLOG_Debug)));
42001 SWIG_Python_SetConstant(d, "LOG_Trace",SWIG_From_int(static_cast< int >(wxLOG_Trace)));
42002 SWIG_Python_SetConstant(d, "LOG_Progress",SWIG_From_int(static_cast< int >(wxLOG_Progress)));
42003 SWIG_Python_SetConstant(d, "LOG_User",SWIG_From_int(static_cast< int >(wxLOG_User)));
42004 SWIG_Python_SetConstant(d, "LOG_Max",SWIG_From_int(static_cast< int >(wxLOG_Max)));
42005 SWIG_Python_SetConstant(d, "TRACE_MemAlloc",SWIG_FromCharPtr("memalloc"));
42006 SWIG_Python_SetConstant(d, "TRACE_Messages",SWIG_FromCharPtr("messages"));
42007 SWIG_Python_SetConstant(d, "TRACE_ResAlloc",SWIG_FromCharPtr("resalloc"));
42008 SWIG_Python_SetConstant(d, "TRACE_RefCount",SWIG_FromCharPtr("refcount"));
42009 SWIG_Python_SetConstant(d, "TRACE_OleCalls",SWIG_FromCharPtr("ole"));
42010 SWIG_Python_SetConstant(d, "TraceMemAlloc",SWIG_From_int(static_cast< int >(0x0001)));
42011 SWIG_Python_SetConstant(d, "TraceMessages",SWIG_From_int(static_cast< int >(0x0002)));
42012 SWIG_Python_SetConstant(d, "TraceResAlloc",SWIG_From_int(static_cast< int >(0x0004)));
42013 SWIG_Python_SetConstant(d, "TraceRefCount",SWIG_From_int(static_cast< int >(0x0008)));
42014 SWIG_Python_SetConstant(d, "TraceOleCalls",SWIG_From_int(static_cast< int >(0x0100)));
42015 SWIG_Python_SetConstant(d, "PROCESS_DEFAULT",SWIG_From_int(static_cast< int >(wxPROCESS_DEFAULT)));
42016 SWIG_Python_SetConstant(d, "PROCESS_REDIRECT",SWIG_From_int(static_cast< int >(wxPROCESS_REDIRECT)));
42017 SWIG_Python_SetConstant(d, "KILL_OK",SWIG_From_int(static_cast< int >(wxKILL_OK)));
42018 SWIG_Python_SetConstant(d, "KILL_BAD_SIGNAL",SWIG_From_int(static_cast< int >(wxKILL_BAD_SIGNAL)));
42019 SWIG_Python_SetConstant(d, "KILL_ACCESS_DENIED",SWIG_From_int(static_cast< int >(wxKILL_ACCESS_DENIED)));
42020 SWIG_Python_SetConstant(d, "KILL_NO_PROCESS",SWIG_From_int(static_cast< int >(wxKILL_NO_PROCESS)));
42021 SWIG_Python_SetConstant(d, "KILL_ERROR",SWIG_From_int(static_cast< int >(wxKILL_ERROR)));
42022 SWIG_Python_SetConstant(d, "KILL_NOCHILDREN",SWIG_From_int(static_cast< int >(wxKILL_NOCHILDREN)));
42023 SWIG_Python_SetConstant(d, "KILL_CHILDREN",SWIG_From_int(static_cast< int >(wxKILL_CHILDREN)));
42024 SWIG_Python_SetConstant(d, "SIGNONE",SWIG_From_int(static_cast< int >(wxSIGNONE)));
42025 SWIG_Python_SetConstant(d, "SIGHUP",SWIG_From_int(static_cast< int >(wxSIGHUP)));
42026 SWIG_Python_SetConstant(d, "SIGINT",SWIG_From_int(static_cast< int >(wxSIGINT)));
42027 SWIG_Python_SetConstant(d, "SIGQUIT",SWIG_From_int(static_cast< int >(wxSIGQUIT)));
42028 SWIG_Python_SetConstant(d, "SIGILL",SWIG_From_int(static_cast< int >(wxSIGILL)));
42029 SWIG_Python_SetConstant(d, "SIGTRAP",SWIG_From_int(static_cast< int >(wxSIGTRAP)));
42030 SWIG_Python_SetConstant(d, "SIGABRT",SWIG_From_int(static_cast< int >(wxSIGABRT)));
42031 SWIG_Python_SetConstant(d, "SIGIOT",SWIG_From_int(static_cast< int >(wxSIGIOT)));
42032 SWIG_Python_SetConstant(d, "SIGEMT",SWIG_From_int(static_cast< int >(wxSIGEMT)));
42033 SWIG_Python_SetConstant(d, "SIGFPE",SWIG_From_int(static_cast< int >(wxSIGFPE)));
42034 SWIG_Python_SetConstant(d, "SIGKILL",SWIG_From_int(static_cast< int >(wxSIGKILL)));
42035 SWIG_Python_SetConstant(d, "SIGBUS",SWIG_From_int(static_cast< int >(wxSIGBUS)));
42036 SWIG_Python_SetConstant(d, "SIGSEGV",SWIG_From_int(static_cast< int >(wxSIGSEGV)));
42037 SWIG_Python_SetConstant(d, "SIGSYS",SWIG_From_int(static_cast< int >(wxSIGSYS)));
42038 SWIG_Python_SetConstant(d, "SIGPIPE",SWIG_From_int(static_cast< int >(wxSIGPIPE)));
42039 SWIG_Python_SetConstant(d, "SIGALRM",SWIG_From_int(static_cast< int >(wxSIGALRM)));
42040 SWIG_Python_SetConstant(d, "SIGTERM",SWIG_From_int(static_cast< int >(wxSIGTERM)));
42041 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
42042 SWIG_Python_SetConstant(d, "EXEC_ASYNC",SWIG_From_int(static_cast< int >(wxEXEC_ASYNC)));
42043 SWIG_Python_SetConstant(d, "EXEC_SYNC",SWIG_From_int(static_cast< int >(wxEXEC_SYNC)));
42044 SWIG_Python_SetConstant(d, "EXEC_NOHIDE",SWIG_From_int(static_cast< int >(wxEXEC_NOHIDE)));
42045 SWIG_Python_SetConstant(d, "EXEC_MAKE_GROUP_LEADER",SWIG_From_int(static_cast< int >(wxEXEC_MAKE_GROUP_LEADER)));
42046 SWIG_Python_SetConstant(d, "EXEC_NODISABLE",SWIG_From_int(static_cast< int >(wxEXEC_NODISABLE)));
42047
42048 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
42049
42050 SWIG_Python_SetConstant(d, "JOYSTICK1",SWIG_From_int(static_cast< int >(wxJOYSTICK1)));
42051 SWIG_Python_SetConstant(d, "JOYSTICK2",SWIG_From_int(static_cast< int >(wxJOYSTICK2)));
42052 SWIG_Python_SetConstant(d, "JOY_BUTTON_ANY",SWIG_From_int(static_cast< int >(wxJOY_BUTTON_ANY)));
42053 SWIG_Python_SetConstant(d, "JOY_BUTTON1",SWIG_From_int(static_cast< int >(wxJOY_BUTTON1)));
42054 SWIG_Python_SetConstant(d, "JOY_BUTTON2",SWIG_From_int(static_cast< int >(wxJOY_BUTTON2)));
42055 SWIG_Python_SetConstant(d, "JOY_BUTTON3",SWIG_From_int(static_cast< int >(wxJOY_BUTTON3)));
42056 SWIG_Python_SetConstant(d, "JOY_BUTTON4",SWIG_From_int(static_cast< int >(wxJOY_BUTTON4)));
42057 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
42058 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
42059 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
42060 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
42061 SWIG_Python_SetConstant(d, "SOUND_SYNC",SWIG_From_int(static_cast< int >(wxSOUND_SYNC)));
42062 SWIG_Python_SetConstant(d, "SOUND_ASYNC",SWIG_From_int(static_cast< int >(wxSOUND_ASYNC)));
42063 SWIG_Python_SetConstant(d, "SOUND_LOOP",SWIG_From_int(static_cast< int >(wxSOUND_LOOP)));
42064 SWIG_Python_SetConstant(d, "MAILCAP_STANDARD",SWIG_From_int(static_cast< int >(wxMAILCAP_STANDARD)));
42065 SWIG_Python_SetConstant(d, "MAILCAP_NETSCAPE",SWIG_From_int(static_cast< int >(wxMAILCAP_NETSCAPE)));
42066 SWIG_Python_SetConstant(d, "MAILCAP_KDE",SWIG_From_int(static_cast< int >(wxMAILCAP_KDE)));
42067 SWIG_Python_SetConstant(d, "MAILCAP_GNOME",SWIG_From_int(static_cast< int >(wxMAILCAP_GNOME)));
42068 SWIG_Python_SetConstant(d, "MAILCAP_ALL",SWIG_From_int(static_cast< int >(wxMAILCAP_ALL)));
42069 SWIG_addvarlink(SWIG_globals(),(char*)"TheMimeTypesManager",TheMimeTypesManager_get, TheMimeTypesManager_set);
42070 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TOOLBAR",ART_TOOLBAR_get, ART_TOOLBAR_set);
42071 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MENU",ART_MENU_get, ART_MENU_set);
42072 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FRAME_ICON",ART_FRAME_ICON_get, ART_FRAME_ICON_set);
42073 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CMN_DIALOG",ART_CMN_DIALOG_get, ART_CMN_DIALOG_set);
42074 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BROWSER",ART_HELP_BROWSER_get, ART_HELP_BROWSER_set);
42075 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MESSAGE_BOX",ART_MESSAGE_BOX_get, ART_MESSAGE_BOX_set);
42076 SWIG_addvarlink(SWIG_globals(),(char*)"ART_BUTTON",ART_BUTTON_get, ART_BUTTON_set);
42077 SWIG_addvarlink(SWIG_globals(),(char*)"ART_OTHER",ART_OTHER_get, ART_OTHER_set);
42078 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ADD_BOOKMARK",ART_ADD_BOOKMARK_get, ART_ADD_BOOKMARK_set);
42079 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DEL_BOOKMARK",ART_DEL_BOOKMARK_get, ART_DEL_BOOKMARK_set);
42080 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SIDE_PANEL",ART_HELP_SIDE_PANEL_get, ART_HELP_SIDE_PANEL_set);
42081 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SETTINGS",ART_HELP_SETTINGS_get, ART_HELP_SETTINGS_set);
42082 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BOOK",ART_HELP_BOOK_get, ART_HELP_BOOK_set);
42083 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_FOLDER",ART_HELP_FOLDER_get, ART_HELP_FOLDER_set);
42084 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_PAGE",ART_HELP_PAGE_get, ART_HELP_PAGE_set);
42085 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_BACK",ART_GO_BACK_get, ART_GO_BACK_set);
42086 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_FORWARD",ART_GO_FORWARD_get, ART_GO_FORWARD_set);
42087 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_UP",ART_GO_UP_get, ART_GO_UP_set);
42088 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DOWN",ART_GO_DOWN_get, ART_GO_DOWN_set);
42089 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_TO_PARENT",ART_GO_TO_PARENT_get, ART_GO_TO_PARENT_set);
42090 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_HOME",ART_GO_HOME_get, ART_GO_HOME_set);
42091 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_OPEN",ART_FILE_OPEN_get, ART_FILE_OPEN_set);
42092 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE",ART_FILE_SAVE_get, ART_FILE_SAVE_set);
42093 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE_AS",ART_FILE_SAVE_AS_get, ART_FILE_SAVE_AS_set);
42094 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PRINT",ART_PRINT_get, ART_PRINT_set);
42095 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP",ART_HELP_get, ART_HELP_set);
42096 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TIP",ART_TIP_get, ART_TIP_set);
42097 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REPORT_VIEW",ART_REPORT_VIEW_get, ART_REPORT_VIEW_set);
42098 SWIG_addvarlink(SWIG_globals(),(char*)"ART_LIST_VIEW",ART_LIST_VIEW_get, ART_LIST_VIEW_set);
42099 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW_DIR",ART_NEW_DIR_get, ART_NEW_DIR_set);
42100 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HARDDISK",ART_HARDDISK_get, ART_HARDDISK_set);
42101 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FLOPPY",ART_FLOPPY_get, ART_FLOPPY_set);
42102 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CDROM",ART_CDROM_get, ART_CDROM_set);
42103 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REMOVABLE",ART_REMOVABLE_get, ART_REMOVABLE_set);
42104 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER",ART_FOLDER_get, ART_FOLDER_set);
42105 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER_OPEN",ART_FOLDER_OPEN_get, ART_FOLDER_OPEN_set);
42106 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DIR_UP",ART_GO_DIR_UP_get, ART_GO_DIR_UP_set);
42107 SWIG_addvarlink(SWIG_globals(),(char*)"ART_EXECUTABLE_FILE",ART_EXECUTABLE_FILE_get, ART_EXECUTABLE_FILE_set);
42108 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NORMAL_FILE",ART_NORMAL_FILE_get, ART_NORMAL_FILE_set);
42109 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TICK_MARK",ART_TICK_MARK_get, ART_TICK_MARK_set);
42110 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CROSS_MARK",ART_CROSS_MARK_get, ART_CROSS_MARK_set);
42111 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ERROR",ART_ERROR_get, ART_ERROR_set);
42112 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUESTION",ART_QUESTION_get, ART_QUESTION_set);
42113 SWIG_addvarlink(SWIG_globals(),(char*)"ART_WARNING",ART_WARNING_get, ART_WARNING_set);
42114 SWIG_addvarlink(SWIG_globals(),(char*)"ART_INFORMATION",ART_INFORMATION_get, ART_INFORMATION_set);
42115 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MISSING_IMAGE",ART_MISSING_IMAGE_get, ART_MISSING_IMAGE_set);
42116 SWIG_addvarlink(SWIG_globals(),(char*)"ART_COPY",ART_COPY_get, ART_COPY_set);
42117 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CUT",ART_CUT_get, ART_CUT_set);
42118 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PASTE",ART_PASTE_get, ART_PASTE_set);
42119 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DELETE",ART_DELETE_get, ART_DELETE_set);
42120 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW",ART_NEW_get, ART_NEW_set);
42121 SWIG_addvarlink(SWIG_globals(),(char*)"ART_UNDO",ART_UNDO_get, ART_UNDO_set);
42122 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REDO",ART_REDO_get, ART_REDO_set);
42123 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUIT",ART_QUIT_get, ART_QUIT_set);
42124 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND",ART_FIND_get, ART_FIND_set);
42125 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND_AND_REPLACE",ART_FIND_AND_REPLACE_get, ART_FIND_AND_REPLACE_set);
42126
42127 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
42128
42129 SWIG_Python_SetConstant(d, "CONFIG_USE_LOCAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_LOCAL_FILE)));
42130 SWIG_Python_SetConstant(d, "CONFIG_USE_GLOBAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_GLOBAL_FILE)));
42131 SWIG_Python_SetConstant(d, "CONFIG_USE_RELATIVE_PATH",SWIG_From_int(static_cast< int >(wxCONFIG_USE_RELATIVE_PATH)));
42132 SWIG_Python_SetConstant(d, "CONFIG_USE_NO_ESCAPE_CHARACTERS",SWIG_From_int(static_cast< int >(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
42133 SWIG_Python_SetConstant(d, "ConfigBase_Type_Unknown",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Unknown)));
42134 SWIG_Python_SetConstant(d, "ConfigBase_Type_String",SWIG_From_int(static_cast< int >(wxConfigBase::Type_String)));
42135 SWIG_Python_SetConstant(d, "ConfigBase_Type_Boolean",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Boolean)));
42136 SWIG_Python_SetConstant(d, "ConfigBase_Type_Integer",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Integer)));
42137 SWIG_Python_SetConstant(d, "ConfigBase_Type_Float",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Float)));
42138 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTimeFormat",DefaultDateTimeFormat_get, DefaultDateTimeFormat_set);
42139 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultTimeSpanFormat",DefaultTimeSpanFormat_get, DefaultTimeSpanFormat_set);
42140 SWIG_Python_SetConstant(d, "DateTime_Local",SWIG_From_int(static_cast< int >(wxDateTime::Local)));
42141 SWIG_Python_SetConstant(d, "DateTime_GMT_12",SWIG_From_int(static_cast< int >(wxDateTime::GMT_12)));
42142 SWIG_Python_SetConstant(d, "DateTime_GMT_11",SWIG_From_int(static_cast< int >(wxDateTime::GMT_11)));
42143 SWIG_Python_SetConstant(d, "DateTime_GMT_10",SWIG_From_int(static_cast< int >(wxDateTime::GMT_10)));
42144 SWIG_Python_SetConstant(d, "DateTime_GMT_9",SWIG_From_int(static_cast< int >(wxDateTime::GMT_9)));
42145 SWIG_Python_SetConstant(d, "DateTime_GMT_8",SWIG_From_int(static_cast< int >(wxDateTime::GMT_8)));
42146 SWIG_Python_SetConstant(d, "DateTime_GMT_7",SWIG_From_int(static_cast< int >(wxDateTime::GMT_7)));
42147 SWIG_Python_SetConstant(d, "DateTime_GMT_6",SWIG_From_int(static_cast< int >(wxDateTime::GMT_6)));
42148 SWIG_Python_SetConstant(d, "DateTime_GMT_5",SWIG_From_int(static_cast< int >(wxDateTime::GMT_5)));
42149 SWIG_Python_SetConstant(d, "DateTime_GMT_4",SWIG_From_int(static_cast< int >(wxDateTime::GMT_4)));
42150 SWIG_Python_SetConstant(d, "DateTime_GMT_3",SWIG_From_int(static_cast< int >(wxDateTime::GMT_3)));
42151 SWIG_Python_SetConstant(d, "DateTime_GMT_2",SWIG_From_int(static_cast< int >(wxDateTime::GMT_2)));
42152 SWIG_Python_SetConstant(d, "DateTime_GMT_1",SWIG_From_int(static_cast< int >(wxDateTime::GMT_1)));
42153 SWIG_Python_SetConstant(d, "DateTime_GMT0",SWIG_From_int(static_cast< int >(wxDateTime::GMT0)));
42154 SWIG_Python_SetConstant(d, "DateTime_GMT1",SWIG_From_int(static_cast< int >(wxDateTime::GMT1)));
42155 SWIG_Python_SetConstant(d, "DateTime_GMT2",SWIG_From_int(static_cast< int >(wxDateTime::GMT2)));
42156 SWIG_Python_SetConstant(d, "DateTime_GMT3",SWIG_From_int(static_cast< int >(wxDateTime::GMT3)));
42157 SWIG_Python_SetConstant(d, "DateTime_GMT4",SWIG_From_int(static_cast< int >(wxDateTime::GMT4)));
42158 SWIG_Python_SetConstant(d, "DateTime_GMT5",SWIG_From_int(static_cast< int >(wxDateTime::GMT5)));
42159 SWIG_Python_SetConstant(d, "DateTime_GMT6",SWIG_From_int(static_cast< int >(wxDateTime::GMT6)));
42160 SWIG_Python_SetConstant(d, "DateTime_GMT7",SWIG_From_int(static_cast< int >(wxDateTime::GMT7)));
42161 SWIG_Python_SetConstant(d, "DateTime_GMT8",SWIG_From_int(static_cast< int >(wxDateTime::GMT8)));
42162 SWIG_Python_SetConstant(d, "DateTime_GMT9",SWIG_From_int(static_cast< int >(wxDateTime::GMT9)));
42163 SWIG_Python_SetConstant(d, "DateTime_GMT10",SWIG_From_int(static_cast< int >(wxDateTime::GMT10)));
42164 SWIG_Python_SetConstant(d, "DateTime_GMT11",SWIG_From_int(static_cast< int >(wxDateTime::GMT11)));
42165 SWIG_Python_SetConstant(d, "DateTime_GMT12",SWIG_From_int(static_cast< int >(wxDateTime::GMT12)));
42166 SWIG_Python_SetConstant(d, "DateTime_WET",SWIG_From_int(static_cast< int >(wxDateTime::WET)));
42167 SWIG_Python_SetConstant(d, "DateTime_WEST",SWIG_From_int(static_cast< int >(wxDateTime::WEST)));
42168 SWIG_Python_SetConstant(d, "DateTime_CET",SWIG_From_int(static_cast< int >(wxDateTime::CET)));
42169 SWIG_Python_SetConstant(d, "DateTime_CEST",SWIG_From_int(static_cast< int >(wxDateTime::CEST)));
42170 SWIG_Python_SetConstant(d, "DateTime_EET",SWIG_From_int(static_cast< int >(wxDateTime::EET)));
42171 SWIG_Python_SetConstant(d, "DateTime_EEST",SWIG_From_int(static_cast< int >(wxDateTime::EEST)));
42172 SWIG_Python_SetConstant(d, "DateTime_MSK",SWIG_From_int(static_cast< int >(wxDateTime::MSK)));
42173 SWIG_Python_SetConstant(d, "DateTime_MSD",SWIG_From_int(static_cast< int >(wxDateTime::MSD)));
42174 SWIG_Python_SetConstant(d, "DateTime_AST",SWIG_From_int(static_cast< int >(wxDateTime::AST)));
42175 SWIG_Python_SetConstant(d, "DateTime_ADT",SWIG_From_int(static_cast< int >(wxDateTime::ADT)));
42176 SWIG_Python_SetConstant(d, "DateTime_EST",SWIG_From_int(static_cast< int >(wxDateTime::EST)));
42177 SWIG_Python_SetConstant(d, "DateTime_EDT",SWIG_From_int(static_cast< int >(wxDateTime::EDT)));
42178 SWIG_Python_SetConstant(d, "DateTime_CST",SWIG_From_int(static_cast< int >(wxDateTime::CST)));
42179 SWIG_Python_SetConstant(d, "DateTime_CDT",SWIG_From_int(static_cast< int >(wxDateTime::CDT)));
42180 SWIG_Python_SetConstant(d, "DateTime_MST",SWIG_From_int(static_cast< int >(wxDateTime::MST)));
42181 SWIG_Python_SetConstant(d, "DateTime_MDT",SWIG_From_int(static_cast< int >(wxDateTime::MDT)));
42182 SWIG_Python_SetConstant(d, "DateTime_PST",SWIG_From_int(static_cast< int >(wxDateTime::PST)));
42183 SWIG_Python_SetConstant(d, "DateTime_PDT",SWIG_From_int(static_cast< int >(wxDateTime::PDT)));
42184 SWIG_Python_SetConstant(d, "DateTime_HST",SWIG_From_int(static_cast< int >(wxDateTime::HST)));
42185 SWIG_Python_SetConstant(d, "DateTime_AKST",SWIG_From_int(static_cast< int >(wxDateTime::AKST)));
42186 SWIG_Python_SetConstant(d, "DateTime_AKDT",SWIG_From_int(static_cast< int >(wxDateTime::AKDT)));
42187 SWIG_Python_SetConstant(d, "DateTime_A_WST",SWIG_From_int(static_cast< int >(wxDateTime::A_WST)));
42188 SWIG_Python_SetConstant(d, "DateTime_A_CST",SWIG_From_int(static_cast< int >(wxDateTime::A_CST)));
42189 SWIG_Python_SetConstant(d, "DateTime_A_EST",SWIG_From_int(static_cast< int >(wxDateTime::A_EST)));
42190 SWIG_Python_SetConstant(d, "DateTime_A_ESST",SWIG_From_int(static_cast< int >(wxDateTime::A_ESST)));
42191 SWIG_Python_SetConstant(d, "DateTime_UTC",SWIG_From_int(static_cast< int >(wxDateTime::UTC)));
42192 SWIG_Python_SetConstant(d, "DateTime_Gregorian",SWIG_From_int(static_cast< int >(wxDateTime::Gregorian)));
42193 SWIG_Python_SetConstant(d, "DateTime_Julian",SWIG_From_int(static_cast< int >(wxDateTime::Julian)));
42194 SWIG_Python_SetConstant(d, "DateTime_Gr_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Unknown)));
42195 SWIG_Python_SetConstant(d, "DateTime_Gr_Standard",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Standard)));
42196 SWIG_Python_SetConstant(d, "DateTime_Gr_Alaska",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Alaska)));
42197 SWIG_Python_SetConstant(d, "DateTime_Gr_Albania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Albania)));
42198 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria)));
42199 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Brixen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Brixen)));
42200 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Salzburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Salzburg)));
42201 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Tyrol",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Tyrol)));
42202 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Carinthia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Carinthia)));
42203 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Styria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Styria)));
42204 SWIG_Python_SetConstant(d, "DateTime_Gr_Belgium",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Belgium)));
42205 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria)));
42206 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_1)));
42207 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_2)));
42208 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_3)));
42209 SWIG_Python_SetConstant(d, "DateTime_Gr_Canada",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Canada)));
42210 SWIG_Python_SetConstant(d, "DateTime_Gr_China",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China)));
42211 SWIG_Python_SetConstant(d, "DateTime_Gr_China_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_1)));
42212 SWIG_Python_SetConstant(d, "DateTime_Gr_China_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_2)));
42213 SWIG_Python_SetConstant(d, "DateTime_Gr_Czechoslovakia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Czechoslovakia)));
42214 SWIG_Python_SetConstant(d, "DateTime_Gr_Denmark",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Denmark)));
42215 SWIG_Python_SetConstant(d, "DateTime_Gr_Egypt",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Egypt)));
42216 SWIG_Python_SetConstant(d, "DateTime_Gr_Estonia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Estonia)));
42217 SWIG_Python_SetConstant(d, "DateTime_Gr_Finland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Finland)));
42218 SWIG_Python_SetConstant(d, "DateTime_Gr_France",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France)));
42219 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Alsace",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Alsace)));
42220 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Lorraine",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Lorraine)));
42221 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Strasbourg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Strasbourg)));
42222 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany)));
42223 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Catholic)));
42224 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Prussia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Prussia)));
42225 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Protestant)));
42226 SWIG_Python_SetConstant(d, "DateTime_Gr_GreatBritain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_GreatBritain)));
42227 SWIG_Python_SetConstant(d, "DateTime_Gr_Greece",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Greece)));
42228 SWIG_Python_SetConstant(d, "DateTime_Gr_Hungary",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Hungary)));
42229 SWIG_Python_SetConstant(d, "DateTime_Gr_Ireland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Ireland)));
42230 SWIG_Python_SetConstant(d, "DateTime_Gr_Italy",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Italy)));
42231 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan)));
42232 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_1)));
42233 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_2)));
42234 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_3)));
42235 SWIG_Python_SetConstant(d, "DateTime_Gr_Latvia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Latvia)));
42236 SWIG_Python_SetConstant(d, "DateTime_Gr_Lithuania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Lithuania)));
42237 SWIG_Python_SetConstant(d, "DateTime_Gr_Luxemburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Luxemburg)));
42238 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands)));
42239 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Groningen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Groningen)));
42240 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Gelderland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Gelderland)));
42241 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Utrecht",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Utrecht)));
42242 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Friesland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Friesland)));
42243 SWIG_Python_SetConstant(d, "DateTime_Gr_Norway",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Norway)));
42244 SWIG_Python_SetConstant(d, "DateTime_Gr_Poland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Poland)));
42245 SWIG_Python_SetConstant(d, "DateTime_Gr_Portugal",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Portugal)));
42246 SWIG_Python_SetConstant(d, "DateTime_Gr_Romania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Romania)));
42247 SWIG_Python_SetConstant(d, "DateTime_Gr_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Russia)));
42248 SWIG_Python_SetConstant(d, "DateTime_Gr_Scotland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Scotland)));
42249 SWIG_Python_SetConstant(d, "DateTime_Gr_Spain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Spain)));
42250 SWIG_Python_SetConstant(d, "DateTime_Gr_Sweden",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Sweden)));
42251 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland)));
42252 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Catholic)));
42253 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Protestant)));
42254 SWIG_Python_SetConstant(d, "DateTime_Gr_Turkey",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Turkey)));
42255 SWIG_Python_SetConstant(d, "DateTime_Gr_USA",SWIG_From_int(static_cast< int >(wxDateTime::Gr_USA)));
42256 SWIG_Python_SetConstant(d, "DateTime_Gr_Wales",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Wales)));
42257 SWIG_Python_SetConstant(d, "DateTime_Gr_Yugoslavia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Yugoslavia)));
42258 SWIG_Python_SetConstant(d, "DateTime_Country_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Country_Unknown)));
42259 SWIG_Python_SetConstant(d, "DateTime_Country_Default",SWIG_From_int(static_cast< int >(wxDateTime::Country_Default)));
42260 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_Start",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_Start)));
42261 SWIG_Python_SetConstant(d, "DateTime_Country_EEC",SWIG_From_int(static_cast< int >(wxDateTime::Country_EEC)));
42262 SWIG_Python_SetConstant(d, "DateTime_France",SWIG_From_int(static_cast< int >(wxDateTime::France)));
42263 SWIG_Python_SetConstant(d, "DateTime_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Germany)));
42264 SWIG_Python_SetConstant(d, "DateTime_UK",SWIG_From_int(static_cast< int >(wxDateTime::UK)));
42265 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_End",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_End)));
42266 SWIG_Python_SetConstant(d, "DateTime_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Russia)));
42267 SWIG_Python_SetConstant(d, "DateTime_USA",SWIG_From_int(static_cast< int >(wxDateTime::USA)));
42268 SWIG_Python_SetConstant(d, "DateTime_Jan",SWIG_From_int(static_cast< int >(wxDateTime::Jan)));
42269 SWIG_Python_SetConstant(d, "DateTime_Feb",SWIG_From_int(static_cast< int >(wxDateTime::Feb)));
42270 SWIG_Python_SetConstant(d, "DateTime_Mar",SWIG_From_int(static_cast< int >(wxDateTime::Mar)));
42271 SWIG_Python_SetConstant(d, "DateTime_Apr",SWIG_From_int(static_cast< int >(wxDateTime::Apr)));
42272 SWIG_Python_SetConstant(d, "DateTime_May",SWIG_From_int(static_cast< int >(wxDateTime::May)));
42273 SWIG_Python_SetConstant(d, "DateTime_Jun",SWIG_From_int(static_cast< int >(wxDateTime::Jun)));
42274 SWIG_Python_SetConstant(d, "DateTime_Jul",SWIG_From_int(static_cast< int >(wxDateTime::Jul)));
42275 SWIG_Python_SetConstant(d, "DateTime_Aug",SWIG_From_int(static_cast< int >(wxDateTime::Aug)));
42276 SWIG_Python_SetConstant(d, "DateTime_Sep",SWIG_From_int(static_cast< int >(wxDateTime::Sep)));
42277 SWIG_Python_SetConstant(d, "DateTime_Oct",SWIG_From_int(static_cast< int >(wxDateTime::Oct)));
42278 SWIG_Python_SetConstant(d, "DateTime_Nov",SWIG_From_int(static_cast< int >(wxDateTime::Nov)));
42279 SWIG_Python_SetConstant(d, "DateTime_Dec",SWIG_From_int(static_cast< int >(wxDateTime::Dec)));
42280 SWIG_Python_SetConstant(d, "DateTime_Inv_Month",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Month)));
42281 SWIG_Python_SetConstant(d, "DateTime_Sun",SWIG_From_int(static_cast< int >(wxDateTime::Sun)));
42282 SWIG_Python_SetConstant(d, "DateTime_Mon",SWIG_From_int(static_cast< int >(wxDateTime::Mon)));
42283 SWIG_Python_SetConstant(d, "DateTime_Tue",SWIG_From_int(static_cast< int >(wxDateTime::Tue)));
42284 SWIG_Python_SetConstant(d, "DateTime_Wed",SWIG_From_int(static_cast< int >(wxDateTime::Wed)));
42285 SWIG_Python_SetConstant(d, "DateTime_Thu",SWIG_From_int(static_cast< int >(wxDateTime::Thu)));
42286 SWIG_Python_SetConstant(d, "DateTime_Fri",SWIG_From_int(static_cast< int >(wxDateTime::Fri)));
42287 SWIG_Python_SetConstant(d, "DateTime_Sat",SWIG_From_int(static_cast< int >(wxDateTime::Sat)));
42288 SWIG_Python_SetConstant(d, "DateTime_Inv_WeekDay",SWIG_From_int(static_cast< int >(wxDateTime::Inv_WeekDay)));
42289 SWIG_Python_SetConstant(d, "DateTime_Inv_Year",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Year)));
42290 SWIG_Python_SetConstant(d, "DateTime_Name_Full",SWIG_From_int(static_cast< int >(wxDateTime::Name_Full)));
42291 SWIG_Python_SetConstant(d, "DateTime_Name_Abbr",SWIG_From_int(static_cast< int >(wxDateTime::Name_Abbr)));
42292 SWIG_Python_SetConstant(d, "DateTime_Default_First",SWIG_From_int(static_cast< int >(wxDateTime::Default_First)));
42293 SWIG_Python_SetConstant(d, "DateTime_Monday_First",SWIG_From_int(static_cast< int >(wxDateTime::Monday_First)));
42294 SWIG_Python_SetConstant(d, "DateTime_Sunday_First",SWIG_From_int(static_cast< int >(wxDateTime::Sunday_First)));
42295 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTime",DefaultDateTime_get, DefaultDateTime_set);
42296 SWIG_Python_SetConstant(d, "DF_INVALID",SWIG_From_int(static_cast< int >(wxDF_INVALID)));
42297 SWIG_Python_SetConstant(d, "DF_TEXT",SWIG_From_int(static_cast< int >(wxDF_TEXT)));
42298 SWIG_Python_SetConstant(d, "DF_BITMAP",SWIG_From_int(static_cast< int >(wxDF_BITMAP)));
42299 SWIG_Python_SetConstant(d, "DF_METAFILE",SWIG_From_int(static_cast< int >(wxDF_METAFILE)));
42300 SWIG_Python_SetConstant(d, "DF_SYLK",SWIG_From_int(static_cast< int >(wxDF_SYLK)));
42301 SWIG_Python_SetConstant(d, "DF_DIF",SWIG_From_int(static_cast< int >(wxDF_DIF)));
42302 SWIG_Python_SetConstant(d, "DF_TIFF",SWIG_From_int(static_cast< int >(wxDF_TIFF)));
42303 SWIG_Python_SetConstant(d, "DF_OEMTEXT",SWIG_From_int(static_cast< int >(wxDF_OEMTEXT)));
42304 SWIG_Python_SetConstant(d, "DF_DIB",SWIG_From_int(static_cast< int >(wxDF_DIB)));
42305 SWIG_Python_SetConstant(d, "DF_PALETTE",SWIG_From_int(static_cast< int >(wxDF_PALETTE)));
42306 SWIG_Python_SetConstant(d, "DF_PENDATA",SWIG_From_int(static_cast< int >(wxDF_PENDATA)));
42307 SWIG_Python_SetConstant(d, "DF_RIFF",SWIG_From_int(static_cast< int >(wxDF_RIFF)));
42308 SWIG_Python_SetConstant(d, "DF_WAVE",SWIG_From_int(static_cast< int >(wxDF_WAVE)));
42309 SWIG_Python_SetConstant(d, "DF_UNICODETEXT",SWIG_From_int(static_cast< int >(wxDF_UNICODETEXT)));
42310 SWIG_Python_SetConstant(d, "DF_ENHMETAFILE",SWIG_From_int(static_cast< int >(wxDF_ENHMETAFILE)));
42311 SWIG_Python_SetConstant(d, "DF_FILENAME",SWIG_From_int(static_cast< int >(wxDF_FILENAME)));
42312 SWIG_Python_SetConstant(d, "DF_LOCALE",SWIG_From_int(static_cast< int >(wxDF_LOCALE)));
42313 SWIG_Python_SetConstant(d, "DF_PRIVATE",SWIG_From_int(static_cast< int >(wxDF_PRIVATE)));
42314 SWIG_Python_SetConstant(d, "DF_HTML",SWIG_From_int(static_cast< int >(wxDF_HTML)));
42315 SWIG_Python_SetConstant(d, "DF_MAX",SWIG_From_int(static_cast< int >(wxDF_MAX)));
42316 SWIG_addvarlink(SWIG_globals(),(char*)"FormatInvalid",FormatInvalid_get, FormatInvalid_set);
42317 SWIG_Python_SetConstant(d, "DataObject_Get",SWIG_From_int(static_cast< int >(wxDataObject::Get)));
42318 SWIG_Python_SetConstant(d, "DataObject_Set",SWIG_From_int(static_cast< int >(wxDataObject::Set)));
42319 SWIG_Python_SetConstant(d, "DataObject_Both",SWIG_From_int(static_cast< int >(wxDataObject::Both)));
42320 SWIG_Python_SetConstant(d, "Drag_CopyOnly",SWIG_From_int(static_cast< int >(wxDrag_CopyOnly)));
42321 SWIG_Python_SetConstant(d, "Drag_AllowMove",SWIG_From_int(static_cast< int >(wxDrag_AllowMove)));
42322 SWIG_Python_SetConstant(d, "Drag_DefaultMove",SWIG_From_int(static_cast< int >(wxDrag_DefaultMove)));
42323 SWIG_Python_SetConstant(d, "DragError",SWIG_From_int(static_cast< int >(wxDragError)));
42324 SWIG_Python_SetConstant(d, "DragNone",SWIG_From_int(static_cast< int >(wxDragNone)));
42325 SWIG_Python_SetConstant(d, "DragCopy",SWIG_From_int(static_cast< int >(wxDragCopy)));
42326 SWIG_Python_SetConstant(d, "DragMove",SWIG_From_int(static_cast< int >(wxDragMove)));
42327 SWIG_Python_SetConstant(d, "DragLink",SWIG_From_int(static_cast< int >(wxDragLink)));
42328 SWIG_Python_SetConstant(d, "DragCancel",SWIG_From_int(static_cast< int >(wxDragCancel)));
42329
42330 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
42331 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
42332 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
42333 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
42334
42335 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultVideoMode",DefaultVideoMode_get, DefaultVideoMode_set);
42336 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_None",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_None)));
42337 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Messages",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Messages)));
42338 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Max",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Max)));
42339 SWIG_Python_SetConstant(d, "POWER_SOCKET",SWIG_From_int(static_cast< int >(wxPOWER_SOCKET)));
42340 SWIG_Python_SetConstant(d, "POWER_BATTERY",SWIG_From_int(static_cast< int >(wxPOWER_BATTERY)));
42341 SWIG_Python_SetConstant(d, "POWER_UNKNOWN",SWIG_From_int(static_cast< int >(wxPOWER_UNKNOWN)));
42342 SWIG_Python_SetConstant(d, "BATTERY_NORMAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_NORMAL_STATE)));
42343 SWIG_Python_SetConstant(d, "BATTERY_LOW_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_LOW_STATE)));
42344 SWIG_Python_SetConstant(d, "BATTERY_CRITICAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_CRITICAL_STATE)));
42345 SWIG_Python_SetConstant(d, "BATTERY_SHUTDOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_SHUTDOWN_STATE)));
42346 SWIG_Python_SetConstant(d, "BATTERY_UNKNOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_UNKNOWN_STATE)));
42347 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDING", PyInt_FromLong(wxEVT_POWER_SUSPENDING));
42348 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDED", PyInt_FromLong(wxEVT_POWER_SUSPENDED));
42349 PyDict_SetItemString(d, "wxEVT_POWER_SUSPEND_CANCEL", PyInt_FromLong(wxEVT_POWER_SUSPEND_CANCEL));
42350 PyDict_SetItemString(d, "wxEVT_POWER_RESUME", PyInt_FromLong(wxEVT_POWER_RESUME));
42351 }
42352
wxWidgets (Impactor)