projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
more changes from 2.8.4 added
[wxWidgets.git] / wxPython / src / gtk / _misc_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 #if PY_VERSION_HEX < 0x02050000
989 typedef int Py_ssize_t;
990 #endif
991
992 /* for raw pointers */
993 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
994 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
995 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
996 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
997 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
998 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
999 #define swig_owntype int
1000
1001 /* for raw packed data */
1002 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1003 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1004
1005 /* for class or struct pointers */
1006 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1007 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1008
1009 /* for C or C++ function pointers */
1010 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1011 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1012
1013 /* for C++ member pointers, ie, member methods */
1014 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1015 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1016
1017
1018 /* Runtime API */
1019
1020 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1021 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1022 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1023
1024 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1025 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1026 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1027 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1028 #define SWIG_fail goto fail
1029
1030
1031 /* Runtime API implementation */
1032
1033 /* Error manipulation */
1034
1035 SWIGINTERN void
1036 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1037 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1038 PyErr_SetObject(errtype, obj);
1039 Py_DECREF(obj);
1040 SWIG_PYTHON_THREAD_END_BLOCK;
1041 }
1042
1043 SWIGINTERN void
1044 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1045 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1046 PyErr_SetString(errtype, (char *) msg);
1047 SWIG_PYTHON_THREAD_END_BLOCK;
1048 }
1049
1050 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1051
1052 /* Set a constant value */
1053
1054 SWIGINTERN void
1055 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1056 PyDict_SetItemString(d, (char*) name, obj);
1057 Py_DECREF(obj);
1058 }
1059
1060 /* Append a value to the result obj */
1061
1062 SWIGINTERN PyObject*
1063 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1064 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1065 if (!result) {
1066 result = obj;
1067 } else if (result == Py_None) {
1068 Py_DECREF(result);
1069 result = obj;
1070 } else {
1071 if (!PyList_Check(result)) {
1072 PyObject *o2 = result;
1073 result = PyList_New(1);
1074 PyList_SetItem(result, 0, o2);
1075 }
1076 PyList_Append(result,obj);
1077 Py_DECREF(obj);
1078 }
1079 return result;
1080 #else
1081 PyObject* o2;
1082 PyObject* o3;
1083 if (!result) {
1084 result = obj;
1085 } else if (result == Py_None) {
1086 Py_DECREF(result);
1087 result = obj;
1088 } else {
1089 if (!PyTuple_Check(result)) {
1090 o2 = result;
1091 result = PyTuple_New(1);
1092 PyTuple_SET_ITEM(result, 0, o2);
1093 }
1094 o3 = PyTuple_New(1);
1095 PyTuple_SET_ITEM(o3, 0, obj);
1096 o2 = result;
1097 result = PySequence_Concat(o2, o3);
1098 Py_DECREF(o2);
1099 Py_DECREF(o3);
1100 }
1101 return result;
1102 #endif
1103 }
1104
1105 /* Unpack the argument tuple */
1106
1107 SWIGINTERN int
1108 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1109 {
1110 if (!args) {
1111 if (!min && !max) {
1112 return 1;
1113 } else {
1114 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1115 name, (min == max ? "" : "at least "), min);
1116 return 0;
1117 }
1118 }
1119 if (!PyTuple_Check(args)) {
1120 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1121 return 0;
1122 } else {
1123 register int l = PyTuple_GET_SIZE(args);
1124 if (l < min) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at least "), min, l);
1127 return 0;
1128 } else if (l > max) {
1129 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1130 name, (min == max ? "" : "at most "), max, l);
1131 return 0;
1132 } else {
1133 register int i;
1134 for (i = 0; i < l; ++i) {
1135 objs[i] = PyTuple_GET_ITEM(args, i);
1136 }
1137 for (; l < max; ++l) {
1138 objs[l] = 0;
1139 }
1140 return i + 1;
1141 }
1142 }
1143 }
1144
1145 /* A functor is a function object with one single object argument */
1146 #if PY_VERSION_HEX >= 0x02020000
1147 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1148 #else
1149 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1150 #endif
1151
1152 /*
1153 Helper for static pointer initialization for both C and C++ code, for example
1154 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1155 */
1156 #ifdef __cplusplus
1157 #define SWIG_STATIC_POINTER(var) var
1158 #else
1159 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1160 #endif
1161
1162 /* -----------------------------------------------------------------------------
1163 * Pointer declarations
1164 * ----------------------------------------------------------------------------- */
1165
1166 /* Flags for new pointer objects */
1167 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1168 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1169
1170 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1171
1172 #ifdef __cplusplus
1173 extern "C" {
1174 #if 0
1175 } /* cc-mode */
1176 #endif
1177 #endif
1178
1179 /* How to access Py_None */
1180 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1181 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1182 # ifndef SWIG_PYTHON_BUILD_NONE
1183 # define SWIG_PYTHON_BUILD_NONE
1184 # endif
1185 # endif
1186 #endif
1187
1188 #ifdef SWIG_PYTHON_BUILD_NONE
1189 # ifdef Py_None
1190 # undef Py_None
1191 # define Py_None SWIG_Py_None()
1192 # endif
1193 SWIGRUNTIMEINLINE PyObject *
1194 _SWIG_Py_None(void)
1195 {
1196 PyObject *none = Py_BuildValue("");
1197 Py_DECREF(none);
1198 return none;
1199 }
1200 SWIGRUNTIME PyObject *
1201 SWIG_Py_None(void)
1202 {
1203 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1204 return none;
1205 }
1206 #endif
1207
1208 /* The python void return value */
1209
1210 SWIGRUNTIMEINLINE PyObject *
1211 SWIG_Py_Void(void)
1212 {
1213 PyObject *none = Py_None;
1214 Py_INCREF(none);
1215 return none;
1216 }
1217
1218 /* PySwigClientData */
1219
1220 typedef struct {
1221 PyObject *klass;
1222 PyObject *newraw;
1223 PyObject *newargs;
1224 PyObject *destroy;
1225 int delargs;
1226 int implicitconv;
1227 } PySwigClientData;
1228
1229 SWIGRUNTIMEINLINE int
1230 SWIG_Python_CheckImplicit(swig_type_info *ty)
1231 {
1232 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1233 return data ? data->implicitconv : 0;
1234 }
1235
1236 SWIGRUNTIMEINLINE PyObject *
1237 SWIG_Python_ExceptionType(swig_type_info *desc) {
1238 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1239 PyObject *klass = data ? data->klass : 0;
1240 return (klass ? klass : PyExc_RuntimeError);
1241 }
1242
1243
1244 SWIGRUNTIME PySwigClientData *
1245 PySwigClientData_New(PyObject* obj)
1246 {
1247 if (!obj) {
1248 return 0;
1249 } else {
1250 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1251 /* the klass element */
1252 data->klass = obj;
1253 Py_INCREF(data->klass);
1254 /* the newraw method and newargs arguments used to create a new raw instance */
1255 if (PyClass_Check(obj)) {
1256 data->newraw = 0;
1257 data->newargs = obj;
1258 Py_INCREF(obj);
1259 } else {
1260 #if (PY_VERSION_HEX < 0x02020000)
1261 data->newraw = 0;
1262 #else
1263 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1264 #endif
1265 if (data->newraw) {
1266 Py_INCREF(data->newraw);
1267 data->newargs = PyTuple_New(1);
1268 PyTuple_SetItem(data->newargs, 0, obj);
1269 } else {
1270 data->newargs = obj;
1271 }
1272 Py_INCREF(data->newargs);
1273 }
1274 /* the destroy method, aka as the C++ delete method */
1275 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1276 if (PyErr_Occurred()) {
1277 PyErr_Clear();
1278 data->destroy = 0;
1279 }
1280 if (data->destroy) {
1281 int flags;
1282 Py_INCREF(data->destroy);
1283 flags = PyCFunction_GET_FLAGS(data->destroy);
1284 #ifdef METH_O
1285 data->delargs = !(flags & (METH_O));
1286 #else
1287 data->delargs = 0;
1288 #endif
1289 } else {
1290 data->delargs = 0;
1291 }
1292 data->implicitconv = 0;
1293 return data;
1294 }
1295 }
1296
1297 SWIGRUNTIME void
1298 PySwigClientData_Del(PySwigClientData* data)
1299 {
1300 Py_XDECREF(data->newraw);
1301 Py_XDECREF(data->newargs);
1302 Py_XDECREF(data->destroy);
1303 }
1304
1305 /* =============== PySwigObject =====================*/
1306
1307 typedef struct {
1308 PyObject_HEAD
1309 void *ptr;
1310 swig_type_info *ty;
1311 int own;
1312 PyObject *next;
1313 } PySwigObject;
1314
1315 SWIGRUNTIME PyObject *
1316 PySwigObject_long(PySwigObject *v)
1317 {
1318 return PyLong_FromVoidPtr(v->ptr);
1319 }
1320
1321 SWIGRUNTIME PyObject *
1322 PySwigObject_format(const char* fmt, PySwigObject *v)
1323 {
1324 PyObject *res = NULL;
1325 PyObject *args = PyTuple_New(1);
1326 if (args) {
1327 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1328 PyObject *ofmt = PyString_FromString(fmt);
1329 if (ofmt) {
1330 res = PyString_Format(ofmt,args);
1331 Py_DECREF(ofmt);
1332 }
1333 Py_DECREF(args);
1334 }
1335 }
1336 return res;
1337 }
1338
1339 SWIGRUNTIME PyObject *
1340 PySwigObject_oct(PySwigObject *v)
1341 {
1342 return PySwigObject_format("%o",v);
1343 }
1344
1345 SWIGRUNTIME PyObject *
1346 PySwigObject_hex(PySwigObject *v)
1347 {
1348 return PySwigObject_format("%x",v);
1349 }
1350
1351 SWIGRUNTIME PyObject *
1352 #ifdef METH_NOARGS
1353 PySwigObject_repr(PySwigObject *v)
1354 #else
1355 PySwigObject_repr(PySwigObject *v, PyObject *args)
1356 #endif
1357 {
1358 const char *name = SWIG_TypePrettyName(v->ty);
1359 PyObject *hex = PySwigObject_hex(v);
1360 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1361 Py_DECREF(hex);
1362 if (v->next) {
1363 #ifdef METH_NOARGS
1364 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1365 #else
1366 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1367 #endif
1368 PyString_ConcatAndDel(&repr,nrep);
1369 }
1370 return repr;
1371 }
1372
1373 SWIGRUNTIME int
1374 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1375 {
1376 #ifdef METH_NOARGS
1377 PyObject *repr = PySwigObject_repr(v);
1378 #else
1379 PyObject *repr = PySwigObject_repr(v, NULL);
1380 #endif
1381 if (repr) {
1382 fputs(PyString_AsString(repr), fp);
1383 Py_DECREF(repr);
1384 return 0;
1385 } else {
1386 return 1;
1387 }
1388 }
1389
1390 SWIGRUNTIME PyObject *
1391 PySwigObject_str(PySwigObject *v)
1392 {
1393 char result[SWIG_BUFFER_SIZE];
1394 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1395 PyString_FromString(result) : 0;
1396 }
1397
1398 SWIGRUNTIME int
1399 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1400 {
1401 void *i = v->ptr;
1402 void *j = w->ptr;
1403 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1404 }
1405
1406 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1407
1408 SWIGRUNTIME PyTypeObject*
1409 PySwigObject_type(void) {
1410 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1411 return type;
1412 }
1413
1414 SWIGRUNTIMEINLINE int
1415 PySwigObject_Check(PyObject *op) {
1416 return ((op)->ob_type == PySwigObject_type())
1417 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1418 }
1419
1420 SWIGRUNTIME PyObject *
1421 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1422
1423 SWIGRUNTIME void
1424 PySwigObject_dealloc(PyObject *v)
1425 {
1426 PySwigObject *sobj = (PySwigObject *) v;
1427 PyObject *next = sobj->next;
1428 if (sobj->own) {
1429 swig_type_info *ty = sobj->ty;
1430 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1431 PyObject *destroy = data ? data->destroy : 0;
1432 if (destroy) {
1433 /* destroy is always a VARARGS method */
1434 PyObject *res;
1435 if (data->delargs) {
1436 /* we need to create a temporal object to carry the destroy operation */
1437 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1438 res = SWIG_Python_CallFunctor(destroy, tmp);
1439 Py_DECREF(tmp);
1440 } else {
1441 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1442 PyObject *mself = PyCFunction_GET_SELF(destroy);
1443 res = ((*meth)(mself, v));
1444 }
1445 Py_XDECREF(res);
1446 } else {
1447 const char *name = SWIG_TypePrettyName(ty);
1448 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1449 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1450 #endif
1451 }
1452 }
1453 Py_XDECREF(next);
1454 PyObject_DEL(v);
1455 }
1456
1457 SWIGRUNTIME PyObject*
1458 PySwigObject_append(PyObject* v, PyObject* next)
1459 {
1460 PySwigObject *sobj = (PySwigObject *) v;
1461 #ifndef METH_O
1462 PyObject *tmp = 0;
1463 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1464 next = tmp;
1465 #endif
1466 if (!PySwigObject_Check(next)) {
1467 return NULL;
1468 }
1469 sobj->next = next;
1470 Py_INCREF(next);
1471 return SWIG_Py_Void();
1472 }
1473
1474 SWIGRUNTIME PyObject*
1475 #ifdef METH_NOARGS
1476 PySwigObject_next(PyObject* v)
1477 #else
1478 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1479 #endif
1480 {
1481 PySwigObject *sobj = (PySwigObject *) v;
1482 if (sobj->next) {
1483 Py_INCREF(sobj->next);
1484 return sobj->next;
1485 } else {
1486 return SWIG_Py_Void();
1487 }
1488 }
1489
1490 SWIGINTERN PyObject*
1491 #ifdef METH_NOARGS
1492 PySwigObject_disown(PyObject *v)
1493 #else
1494 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1495 #endif
1496 {
1497 PySwigObject *sobj = (PySwigObject *)v;
1498 sobj->own = 0;
1499 return SWIG_Py_Void();
1500 }
1501
1502 SWIGINTERN PyObject*
1503 #ifdef METH_NOARGS
1504 PySwigObject_acquire(PyObject *v)
1505 #else
1506 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1507 #endif
1508 {
1509 PySwigObject *sobj = (PySwigObject *)v;
1510 sobj->own = SWIG_POINTER_OWN;
1511 return SWIG_Py_Void();
1512 }
1513
1514 SWIGINTERN PyObject*
1515 PySwigObject_own(PyObject *v, PyObject *args)
1516 {
1517 PyObject *val = 0;
1518 #if (PY_VERSION_HEX < 0x02020000)
1519 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1520 #else
1521 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1522 #endif
1523 {
1524 return NULL;
1525 }
1526 else
1527 {
1528 PySwigObject *sobj = (PySwigObject *)v;
1529 PyObject *obj = PyBool_FromLong(sobj->own);
1530 if (val) {
1531 #ifdef METH_NOARGS
1532 if (PyObject_IsTrue(val)) {
1533 PySwigObject_acquire(v);
1534 } else {
1535 PySwigObject_disown(v);
1536 }
1537 #else
1538 if (PyObject_IsTrue(val)) {
1539 PySwigObject_acquire(v,args);
1540 } else {
1541 PySwigObject_disown(v,args);
1542 }
1543 #endif
1544 }
1545 return obj;
1546 }
1547 }
1548
1549 #ifdef METH_O
1550 static PyMethodDef
1551 swigobject_methods[] = {
1552 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1553 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1554 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1555 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1556 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1557 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1558 {0, 0, 0, 0}
1559 };
1560 #else
1561 static PyMethodDef
1562 swigobject_methods[] = {
1563 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1564 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1565 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1566 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1567 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1568 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1569 {0, 0, 0, 0}
1570 };
1571 #endif
1572
1573 #if PY_VERSION_HEX < 0x02020000
1574 SWIGINTERN PyObject *
1575 PySwigObject_getattr(PySwigObject *sobj,char *name)
1576 {
1577 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1578 }
1579 #endif
1580
1581 SWIGRUNTIME PyTypeObject*
1582 _PySwigObject_type(void) {
1583 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1584
1585 static PyNumberMethods PySwigObject_as_number = {
1586 (binaryfunc)0, /*nb_add*/
1587 (binaryfunc)0, /*nb_subtract*/
1588 (binaryfunc)0, /*nb_multiply*/
1589 (binaryfunc)0, /*nb_divide*/
1590 (binaryfunc)0, /*nb_remainder*/
1591 (binaryfunc)0, /*nb_divmod*/
1592 (ternaryfunc)0,/*nb_power*/
1593 (unaryfunc)0, /*nb_negative*/
1594 (unaryfunc)0, /*nb_positive*/
1595 (unaryfunc)0, /*nb_absolute*/
1596 (inquiry)0, /*nb_nonzero*/
1597 0, /*nb_invert*/
1598 0, /*nb_lshift*/
1599 0, /*nb_rshift*/
1600 0, /*nb_and*/
1601 0, /*nb_xor*/
1602 0, /*nb_or*/
1603 (coercion)0, /*nb_coerce*/
1604 (unaryfunc)PySwigObject_long, /*nb_int*/
1605 (unaryfunc)PySwigObject_long, /*nb_long*/
1606 (unaryfunc)0, /*nb_float*/
1607 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1608 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1609 #if PY_VERSION_HEX >= 0x02020000
1610 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1611 #elif PY_VERSION_HEX >= 0x02000000
1612 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1613 #endif
1614 };
1615
1616 static PyTypeObject pyswigobject_type;
1617 static int type_init = 0;
1618 if (!type_init) {
1619 const PyTypeObject tmp
1620 = {
1621 PyObject_HEAD_INIT(NULL)
1622 0, /* ob_size */
1623 (char *)"PySwigObject", /* tp_name */
1624 sizeof(PySwigObject), /* tp_basicsize */
1625 0, /* tp_itemsize */
1626 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1627 (printfunc)PySwigObject_print, /* tp_print */
1628 #if PY_VERSION_HEX < 0x02020000
1629 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1630 #else
1631 (getattrfunc)0, /* tp_getattr */
1632 #endif
1633 (setattrfunc)0, /* tp_setattr */
1634 (cmpfunc)PySwigObject_compare, /* tp_compare */
1635 (reprfunc)PySwigObject_repr, /* tp_repr */
1636 &PySwigObject_as_number, /* tp_as_number */
1637 0, /* tp_as_sequence */
1638 0, /* tp_as_mapping */
1639 (hashfunc)0, /* tp_hash */
1640 (ternaryfunc)0, /* tp_call */
1641 (reprfunc)PySwigObject_str, /* tp_str */
1642 PyObject_GenericGetAttr, /* tp_getattro */
1643 0, /* tp_setattro */
1644 0, /* tp_as_buffer */
1645 Py_TPFLAGS_DEFAULT, /* tp_flags */
1646 swigobject_doc, /* tp_doc */
1647 0, /* tp_traverse */
1648 0, /* tp_clear */
1649 0, /* tp_richcompare */
1650 0, /* tp_weaklistoffset */
1651 #if PY_VERSION_HEX >= 0x02020000
1652 0, /* tp_iter */
1653 0, /* tp_iternext */
1654 swigobject_methods, /* tp_methods */
1655 0, /* tp_members */
1656 0, /* tp_getset */
1657 0, /* tp_base */
1658 0, /* tp_dict */
1659 0, /* tp_descr_get */
1660 0, /* tp_descr_set */
1661 0, /* tp_dictoffset */
1662 0, /* tp_init */
1663 0, /* tp_alloc */
1664 0, /* tp_new */
1665 0, /* tp_free */
1666 0, /* tp_is_gc */
1667 0, /* tp_bases */
1668 0, /* tp_mro */
1669 0, /* tp_cache */
1670 0, /* tp_subclasses */
1671 0, /* tp_weaklist */
1672 #endif
1673 #if PY_VERSION_HEX >= 0x02030000
1674 0, /* tp_del */
1675 #endif
1676 #ifdef COUNT_ALLOCS
1677 0,0,0,0 /* tp_alloc -> tp_next */
1678 #endif
1679 };
1680 pyswigobject_type = tmp;
1681 pyswigobject_type.ob_type = &PyType_Type;
1682 type_init = 1;
1683 }
1684 return &pyswigobject_type;
1685 }
1686
1687 SWIGRUNTIME PyObject *
1688 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1689 {
1690 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1691 if (sobj) {
1692 sobj->ptr = ptr;
1693 sobj->ty = ty;
1694 sobj->own = own;
1695 sobj->next = 0;
1696 }
1697 return (PyObject *)sobj;
1698 }
1699
1700 /* -----------------------------------------------------------------------------
1701 * Implements a simple Swig Packed type, and use it instead of string
1702 * ----------------------------------------------------------------------------- */
1703
1704 typedef struct {
1705 PyObject_HEAD
1706 void *pack;
1707 swig_type_info *ty;
1708 size_t size;
1709 } PySwigPacked;
1710
1711 SWIGRUNTIME int
1712 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1713 {
1714 char result[SWIG_BUFFER_SIZE];
1715 fputs("<Swig Packed ", fp);
1716 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1717 fputs("at ", fp);
1718 fputs(result, fp);
1719 }
1720 fputs(v->ty->name,fp);
1721 fputs(">", fp);
1722 return 0;
1723 }
1724
1725 SWIGRUNTIME PyObject *
1726 PySwigPacked_repr(PySwigPacked *v)
1727 {
1728 char result[SWIG_BUFFER_SIZE];
1729 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1730 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1731 } else {
1732 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1733 }
1734 }
1735
1736 SWIGRUNTIME PyObject *
1737 PySwigPacked_str(PySwigPacked *v)
1738 {
1739 char result[SWIG_BUFFER_SIZE];
1740 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1741 return PyString_FromFormat("%s%s", result, v->ty->name);
1742 } else {
1743 return PyString_FromString(v->ty->name);
1744 }
1745 }
1746
1747 SWIGRUNTIME int
1748 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1749 {
1750 size_t i = v->size;
1751 size_t j = w->size;
1752 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1753 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1754 }
1755
1756 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1757
1758 SWIGRUNTIME PyTypeObject*
1759 PySwigPacked_type(void) {
1760 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1761 return type;
1762 }
1763
1764 SWIGRUNTIMEINLINE int
1765 PySwigPacked_Check(PyObject *op) {
1766 return ((op)->ob_type == _PySwigPacked_type())
1767 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1768 }
1769
1770 SWIGRUNTIME void
1771 PySwigPacked_dealloc(PyObject *v)
1772 {
1773 if (PySwigPacked_Check(v)) {
1774 PySwigPacked *sobj = (PySwigPacked *) v;
1775 free(sobj->pack);
1776 }
1777 PyObject_DEL(v);
1778 }
1779
1780 SWIGRUNTIME PyTypeObject*
1781 _PySwigPacked_type(void) {
1782 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1783 static PyTypeObject pyswigpacked_type;
1784 static int type_init = 0;
1785 if (!type_init) {
1786 const PyTypeObject tmp
1787 = {
1788 PyObject_HEAD_INIT(NULL)
1789 0, /* ob_size */
1790 (char *)"PySwigPacked", /* tp_name */
1791 sizeof(PySwigPacked), /* tp_basicsize */
1792 0, /* tp_itemsize */
1793 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1794 (printfunc)PySwigPacked_print, /* tp_print */
1795 (getattrfunc)0, /* tp_getattr */
1796 (setattrfunc)0, /* tp_setattr */
1797 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1798 (reprfunc)PySwigPacked_repr, /* tp_repr */
1799 0, /* tp_as_number */
1800 0, /* tp_as_sequence */
1801 0, /* tp_as_mapping */
1802 (hashfunc)0, /* tp_hash */
1803 (ternaryfunc)0, /* tp_call */
1804 (reprfunc)PySwigPacked_str, /* tp_str */
1805 PyObject_GenericGetAttr, /* tp_getattro */
1806 0, /* tp_setattro */
1807 0, /* tp_as_buffer */
1808 Py_TPFLAGS_DEFAULT, /* tp_flags */
1809 swigpacked_doc, /* tp_doc */
1810 0, /* tp_traverse */
1811 0, /* tp_clear */
1812 0, /* tp_richcompare */
1813 0, /* tp_weaklistoffset */
1814 #if PY_VERSION_HEX >= 0x02020000
1815 0, /* tp_iter */
1816 0, /* tp_iternext */
1817 0, /* tp_methods */
1818 0, /* tp_members */
1819 0, /* tp_getset */
1820 0, /* tp_base */
1821 0, /* tp_dict */
1822 0, /* tp_descr_get */
1823 0, /* tp_descr_set */
1824 0, /* tp_dictoffset */
1825 0, /* tp_init */
1826 0, /* tp_alloc */
1827 0, /* tp_new */
1828 0, /* tp_free */
1829 0, /* tp_is_gc */
1830 0, /* tp_bases */
1831 0, /* tp_mro */
1832 0, /* tp_cache */
1833 0, /* tp_subclasses */
1834 0, /* tp_weaklist */
1835 #endif
1836 #if PY_VERSION_HEX >= 0x02030000
1837 0, /* tp_del */
1838 #endif
1839 #ifdef COUNT_ALLOCS
1840 0,0,0,0 /* tp_alloc -> tp_next */
1841 #endif
1842 };
1843 pyswigpacked_type = tmp;
1844 pyswigpacked_type.ob_type = &PyType_Type;
1845 type_init = 1;
1846 }
1847 return &pyswigpacked_type;
1848 }
1849
1850 SWIGRUNTIME PyObject *
1851 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1852 {
1853 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1854 if (sobj) {
1855 void *pack = malloc(size);
1856 if (pack) {
1857 memcpy(pack, ptr, size);
1858 sobj->pack = pack;
1859 sobj->ty = ty;
1860 sobj->size = size;
1861 } else {
1862 PyObject_DEL((PyObject *) sobj);
1863 sobj = 0;
1864 }
1865 }
1866 return (PyObject *) sobj;
1867 }
1868
1869 SWIGRUNTIME swig_type_info *
1870 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1871 {
1872 if (PySwigPacked_Check(obj)) {
1873 PySwigPacked *sobj = (PySwigPacked *)obj;
1874 if (sobj->size != size) return 0;
1875 memcpy(ptr, sobj->pack, size);
1876 return sobj->ty;
1877 } else {
1878 return 0;
1879 }
1880 }
1881
1882 /* -----------------------------------------------------------------------------
1883 * pointers/data manipulation
1884 * ----------------------------------------------------------------------------- */
1885
1886 SWIGRUNTIMEINLINE PyObject *
1887 _SWIG_This(void)
1888 {
1889 return PyString_FromString("this");
1890 }
1891
1892 SWIGRUNTIME PyObject *
1893 SWIG_This(void)
1894 {
1895 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1896 return swig_this;
1897 }
1898
1899 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1900
1901 SWIGRUNTIME PySwigObject *
1902 SWIG_Python_GetSwigThis(PyObject *pyobj)
1903 {
1904 if (PySwigObject_Check(pyobj)) {
1905 return (PySwigObject *) pyobj;
1906 } else {
1907 PyObject *obj = 0;
1908 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1909 if (PyInstance_Check(pyobj)) {
1910 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1911 } else {
1912 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1913 if (dictptr != NULL) {
1914 PyObject *dict = *dictptr;
1915 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1916 } else {
1917 #ifdef PyWeakref_CheckProxy
1918 if (PyWeakref_CheckProxy(pyobj)) {
1919 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1920 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1921 }
1922 #endif
1923 obj = PyObject_GetAttr(pyobj,SWIG_This());
1924 if (obj) {
1925 Py_DECREF(obj);
1926 } else {
1927 if (PyErr_Occurred()) PyErr_Clear();
1928 return 0;
1929 }
1930 }
1931 }
1932 #else
1933 obj = PyObject_GetAttr(pyobj,SWIG_This());
1934 if (obj) {
1935 Py_DECREF(obj);
1936 } else {
1937 if (PyErr_Occurred()) PyErr_Clear();
1938 return 0;
1939 }
1940 #endif
1941 if (obj && !PySwigObject_Check(obj)) {
1942 /* a PyObject is called 'this', try to get the 'real this'
1943 PySwigObject from it */
1944 return SWIG_Python_GetSwigThis(obj);
1945 }
1946 return (PySwigObject *)obj;
1947 }
1948 }
1949
1950 /* Acquire a pointer value */
1951
1952 SWIGRUNTIME int
1953 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1954 if (own) {
1955 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1956 if (sobj) {
1957 int oldown = sobj->own;
1958 sobj->own = own;
1959 return oldown;
1960 }
1961 }
1962 return 0;
1963 }
1964
1965 /* Convert a pointer value */
1966
1967 SWIGRUNTIME int
1968 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1969 if (!obj) return SWIG_ERROR;
1970 if (obj == Py_None) {
1971 if (ptr) *ptr = 0;
1972 return SWIG_OK;
1973 } else {
1974 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1975 while (sobj) {
1976 void *vptr = sobj->ptr;
1977 if (ty) {
1978 swig_type_info *to = sobj->ty;
1979 if (to == ty) {
1980 /* no type cast needed */
1981 if (ptr) *ptr = vptr;
1982 break;
1983 } else {
1984 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1985 if (!tc) {
1986 sobj = (PySwigObject *)sobj->next;
1987 } else {
1988 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1989 break;
1990 }
1991 }
1992 } else {
1993 if (ptr) *ptr = vptr;
1994 break;
1995 }
1996 }
1997 if (sobj) {
1998 if (own) *own = sobj->own;
1999 if (flags & SWIG_POINTER_DISOWN) {
2000 sobj->own = 0;
2001 }
2002 return SWIG_OK;
2003 } else {
2004 int res = SWIG_ERROR;
2005 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2006 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2007 if (data && !data->implicitconv) {
2008 PyObject *klass = data->klass;
2009 if (klass) {
2010 PyObject *impconv;
2011 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2012 impconv = SWIG_Python_CallFunctor(klass, obj);
2013 data->implicitconv = 0;
2014 if (PyErr_Occurred()) {
2015 PyErr_Clear();
2016 impconv = 0;
2017 }
2018 if (impconv) {
2019 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2020 if (iobj) {
2021 void *vptr;
2022 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2023 if (SWIG_IsOK(res)) {
2024 if (ptr) {
2025 *ptr = vptr;
2026 /* transfer the ownership to 'ptr' */
2027 iobj->own = 0;
2028 res = SWIG_AddCast(res);
2029 res = SWIG_AddNewMask(res);
2030 } else {
2031 res = SWIG_AddCast(res);
2032 }
2033 }
2034 }
2035 Py_DECREF(impconv);
2036 }
2037 }
2038 }
2039 }
2040 return res;
2041 }
2042 }
2043 }
2044
2045 /* Convert a function ptr value */
2046
2047 SWIGRUNTIME int
2048 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2049 if (!PyCFunction_Check(obj)) {
2050 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2051 } else {
2052 void *vptr = 0;
2053
2054 /* here we get the method pointer for callbacks */
2055 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2056 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2057 if (desc) {
2058 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2059 if (!desc) return SWIG_ERROR;
2060 }
2061 if (ty) {
2062 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2063 if (!tc) return SWIG_ERROR;
2064 *ptr = SWIG_TypeCast(tc,vptr);
2065 } else {
2066 *ptr = vptr;
2067 }
2068 return SWIG_OK;
2069 }
2070 }
2071
2072 /* Convert a packed value value */
2073
2074 SWIGRUNTIME int
2075 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2076 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2077 if (!to) return SWIG_ERROR;
2078 if (ty) {
2079 if (to != ty) {
2080 /* check type cast? */
2081 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2082 if (!tc) return SWIG_ERROR;
2083 }
2084 }
2085 return SWIG_OK;
2086 }
2087
2088 /* -----------------------------------------------------------------------------
2089 * Create a new pointer object
2090 * ----------------------------------------------------------------------------- */
2091
2092 /*
2093 Create a new instance object, whitout calling __init__, and set the
2094 'this' attribute.
2095 */
2096
2097 SWIGRUNTIME PyObject*
2098 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2099 {
2100 #if (PY_VERSION_HEX >= 0x02020000)
2101 PyObject *inst = 0;
2102 PyObject *newraw = data->newraw;
2103 if (newraw) {
2104 inst = PyObject_Call(newraw, data->newargs, NULL);
2105 if (inst) {
2106 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2107 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2108 if (dictptr != NULL) {
2109 PyObject *dict = *dictptr;
2110 if (dict == NULL) {
2111 dict = PyDict_New();
2112 *dictptr = dict;
2113 PyDict_SetItem(dict, SWIG_This(), swig_this);
2114 }
2115 }
2116 #else
2117 PyObject *key = SWIG_This();
2118 PyObject_SetAttr(inst, key, swig_this);
2119 #endif
2120 }
2121 } else {
2122 PyObject *dict = PyDict_New();
2123 PyDict_SetItem(dict, SWIG_This(), swig_this);
2124 inst = PyInstance_NewRaw(data->newargs, dict);
2125 Py_DECREF(dict);
2126 }
2127 return inst;
2128 #else
2129 #if (PY_VERSION_HEX >= 0x02010000)
2130 PyObject *inst;
2131 PyObject *dict = PyDict_New();
2132 PyDict_SetItem(dict, SWIG_This(), swig_this);
2133 inst = PyInstance_NewRaw(data->newargs, dict);
2134 Py_DECREF(dict);
2135 return (PyObject *) inst;
2136 #else
2137 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2138 if (inst == NULL) {
2139 return NULL;
2140 }
2141 inst->in_class = (PyClassObject *)data->newargs;
2142 Py_INCREF(inst->in_class);
2143 inst->in_dict = PyDict_New();
2144 if (inst->in_dict == NULL) {
2145 Py_DECREF(inst);
2146 return NULL;
2147 }
2148 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2149 inst->in_weakreflist = NULL;
2150 #endif
2151 #ifdef Py_TPFLAGS_GC
2152 PyObject_GC_Init(inst);
2153 #endif
2154 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2155 return (PyObject *) inst;
2156 #endif
2157 #endif
2158 }
2159
2160 SWIGRUNTIME void
2161 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2162 {
2163 PyObject *dict;
2164 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2165 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2166 if (dictptr != NULL) {
2167 dict = *dictptr;
2168 if (dict == NULL) {
2169 dict = PyDict_New();
2170 *dictptr = dict;
2171 }
2172 PyDict_SetItem(dict, SWIG_This(), swig_this);
2173 return;
2174 }
2175 #endif
2176 dict = PyObject_GetAttrString(inst, "__dict__");
2177 PyDict_SetItem(dict, SWIG_This(), swig_this);
2178 Py_DECREF(dict);
2179 }
2180
2181
2182 SWIGINTERN PyObject *
2183 SWIG_Python_InitShadowInstance(PyObject *args) {
2184 PyObject *obj[2];
2185 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2186 return NULL;
2187 } else {
2188 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2189 if (sthis) {
2190 PySwigObject_append((PyObject*) sthis, obj[1]);
2191 } else {
2192 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2193 }
2194 return SWIG_Py_Void();
2195 }
2196 }
2197
2198 /* Create a new pointer object */
2199
2200 SWIGRUNTIME PyObject *
2201 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2202 if (!ptr) {
2203 return SWIG_Py_Void();
2204 } else {
2205 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2206 PyObject *robj = PySwigObject_New(ptr, type, own);
2207 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2208 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2209 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2210 if (inst) {
2211 Py_DECREF(robj);
2212 robj = inst;
2213 }
2214 }
2215 return robj;
2216 }
2217 }
2218
2219 /* Create a new packed object */
2220
2221 SWIGRUNTIMEINLINE PyObject *
2222 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2223 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2224 }
2225
2226 /* -----------------------------------------------------------------------------*
2227 * Get type list
2228 * -----------------------------------------------------------------------------*/
2229
2230 #ifdef SWIG_LINK_RUNTIME
2231 void *SWIG_ReturnGlobalTypeList(void *);
2232 #endif
2233
2234 SWIGRUNTIME swig_module_info *
2235 SWIG_Python_GetModule(void) {
2236 static void *type_pointer = (void *)0;
2237 /* first check if module already created */
2238 if (!type_pointer) {
2239 #ifdef SWIG_LINK_RUNTIME
2240 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2241 #else
2242 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2243 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2244 if (PyErr_Occurred()) {
2245 PyErr_Clear();
2246 type_pointer = (void *)0;
2247 }
2248 #endif
2249 }
2250 return (swig_module_info *) type_pointer;
2251 }
2252
2253 #if PY_MAJOR_VERSION < 2
2254 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2255 is copied out of Python/modsupport.c in python version 2.3.4 */
2256 SWIGINTERN int
2257 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2258 {
2259 PyObject *dict;
2260 if (!PyModule_Check(m)) {
2261 PyErr_SetString(PyExc_TypeError,
2262 "PyModule_AddObject() needs module as first arg");
2263 return SWIG_ERROR;
2264 }
2265 if (!o) {
2266 PyErr_SetString(PyExc_TypeError,
2267 "PyModule_AddObject() needs non-NULL value");
2268 return SWIG_ERROR;
2269 }
2270
2271 dict = PyModule_GetDict(m);
2272 if (dict == NULL) {
2273 /* Internal error -- modules must have a dict! */
2274 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2275 PyModule_GetName(m));
2276 return SWIG_ERROR;
2277 }
2278 if (PyDict_SetItemString(dict, name, o))
2279 return SWIG_ERROR;
2280 Py_DECREF(o);
2281 return SWIG_OK;
2282 }
2283 #endif
2284
2285 SWIGRUNTIME void
2286 SWIG_Python_DestroyModule(void *vptr)
2287 {
2288 swig_module_info *swig_module = (swig_module_info *) vptr;
2289 swig_type_info **types = swig_module->types;
2290 size_t i;
2291 for (i =0; i < swig_module->size; ++i) {
2292 swig_type_info *ty = types[i];
2293 if (ty->owndata) {
2294 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2295 if (data) PySwigClientData_Del(data);
2296 }
2297 }
2298 Py_DECREF(SWIG_This());
2299 }
2300
2301 SWIGRUNTIME void
2302 SWIG_Python_SetModule(swig_module_info *swig_module) {
2303 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2304
2305 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2306 swig_empty_runtime_method_table);
2307 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2308 if (pointer && module) {
2309 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2310 } else {
2311 Py_XDECREF(pointer);
2312 }
2313 }
2314
2315 /* The python cached type query */
2316 SWIGRUNTIME PyObject *
2317 SWIG_Python_TypeCache() {
2318 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2319 return cache;
2320 }
2321
2322 SWIGRUNTIME swig_type_info *
2323 SWIG_Python_TypeQuery(const char *type)
2324 {
2325 PyObject *cache = SWIG_Python_TypeCache();
2326 PyObject *key = PyString_FromString(type);
2327 PyObject *obj = PyDict_GetItem(cache, key);
2328 swig_type_info *descriptor;
2329 if (obj) {
2330 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2331 } else {
2332 swig_module_info *swig_module = SWIG_Python_GetModule();
2333 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2334 if (descriptor) {
2335 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2336 PyDict_SetItem(cache, key, obj);
2337 Py_DECREF(obj);
2338 }
2339 }
2340 Py_DECREF(key);
2341 return descriptor;
2342 }
2343
2344 /*
2345 For backward compatibility only
2346 */
2347 #define SWIG_POINTER_EXCEPTION 0
2348 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2349 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2350
2351 SWIGRUNTIME int
2352 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2353 {
2354 if (PyErr_Occurred()) {
2355 PyObject *type = 0;
2356 PyObject *value = 0;
2357 PyObject *traceback = 0;
2358 PyErr_Fetch(&type, &value, &traceback);
2359 if (value) {
2360 PyObject *old_str = PyObject_Str(value);
2361 Py_XINCREF(type);
2362 PyErr_Clear();
2363 if (infront) {
2364 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2365 } else {
2366 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2367 }
2368 Py_DECREF(old_str);
2369 }
2370 return 1;
2371 } else {
2372 return 0;
2373 }
2374 }
2375
2376 SWIGRUNTIME int
2377 SWIG_Python_ArgFail(int argnum)
2378 {
2379 if (PyErr_Occurred()) {
2380 /* add information about failing argument */
2381 char mesg[256];
2382 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2383 return SWIG_Python_AddErrMesg(mesg, 1);
2384 } else {
2385 return 0;
2386 }
2387 }
2388
2389 SWIGRUNTIMEINLINE const char *
2390 PySwigObject_GetDesc(PyObject *self)
2391 {
2392 PySwigObject *v = (PySwigObject *)self;
2393 swig_type_info *ty = v ? v->ty : 0;
2394 return ty ? ty->str : (char*)"";
2395 }
2396
2397 SWIGRUNTIME void
2398 SWIG_Python_TypeError(const char *type, PyObject *obj)
2399 {
2400 if (type) {
2401 #if defined(SWIG_COBJECT_TYPES)
2402 if (obj && PySwigObject_Check(obj)) {
2403 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2404 if (otype) {
2405 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2406 type, otype);
2407 return;
2408 }
2409 } else
2410 #endif
2411 {
2412 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2413 if (otype) {
2414 PyObject *str = PyObject_Str(obj);
2415 const char *cstr = str ? PyString_AsString(str) : 0;
2416 if (cstr) {
2417 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2418 type, otype, cstr);
2419 } else {
2420 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2421 type, otype);
2422 }
2423 Py_XDECREF(str);
2424 return;
2425 }
2426 }
2427 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2428 } else {
2429 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2430 }
2431 }
2432
2433
2434 /* Convert a pointer value, signal an exception on a type mismatch */
2435 SWIGRUNTIME void *
2436 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2437 void *result;
2438 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2439 PyErr_Clear();
2440 if (flags & SWIG_POINTER_EXCEPTION) {
2441 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2442 SWIG_Python_ArgFail(argnum);
2443 }
2444 }
2445 return result;
2446 }
2447
2448
2449 #ifdef __cplusplus
2450 #if 0
2451 { /* cc-mode */
2452 #endif
2453 }
2454 #endif
2455
2456
2457
2458 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2459
2460 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2461
2462
2463
2464 /* -------- TYPES TABLE (BEGIN) -------- */
2465
2466 #define SWIGTYPE_p_char swig_types[0]
2467 #define SWIGTYPE_p_form_ops_t swig_types[1]
2468 #define SWIGTYPE_p_int swig_types[2]
2469 #define SWIGTYPE_p_unsigned_char swig_types[3]
2470 #define SWIGTYPE_p_unsigned_int swig_types[4]
2471 #define SWIGTYPE_p_unsigned_long swig_types[5]
2472 #define SWIGTYPE_p_void swig_types[6]
2473 #define SWIGTYPE_p_wxANIHandler swig_types[7]
2474 #define SWIGTYPE_p_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_wxEventBlocker swig_types[51]
2518 #define SWIGTYPE_p_wxEvtHandler swig_types[52]
2519 #define SWIGTYPE_p_wxFSFile swig_types[53]
2520 #define SWIGTYPE_p_wxFileConfig swig_types[54]
2521 #define SWIGTYPE_p_wxFileDataObject swig_types[55]
2522 #define SWIGTYPE_p_wxFileHistory swig_types[56]
2523 #define SWIGTYPE_p_wxFileSystem swig_types[57]
2524 #define SWIGTYPE_p_wxFileType swig_types[58]
2525 #define SWIGTYPE_p_wxFileTypeInfo swig_types[59]
2526 #define SWIGTYPE_p_wxFlexGridSizer swig_types[60]
2527 #define SWIGTYPE_p_wxFocusEvent swig_types[61]
2528 #define SWIGTYPE_p_wxFont swig_types[62]
2529 #define SWIGTYPE_p_wxFrame swig_types[63]
2530 #define SWIGTYPE_p_wxGBSizerItem swig_types[64]
2531 #define SWIGTYPE_p_wxGIFHandler swig_types[65]
2532 #define SWIGTYPE_p_wxGridBagSizer swig_types[66]
2533 #define SWIGTYPE_p_wxGridSizer swig_types[67]
2534 #define SWIGTYPE_p_wxICOHandler swig_types[68]
2535 #define SWIGTYPE_p_wxIcon swig_types[69]
2536 #define SWIGTYPE_p_wxIconizeEvent swig_types[70]
2537 #define SWIGTYPE_p_wxIdleEvent swig_types[71]
2538 #define SWIGTYPE_p_wxImage swig_types[72]
2539 #define SWIGTYPE_p_wxImageHandler swig_types[73]
2540 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[74]
2541 #define SWIGTYPE_p_wxInitDialogEvent swig_types[75]
2542 #define SWIGTYPE_p_wxJPEGHandler swig_types[76]
2543 #define SWIGTYPE_p_wxJoystick swig_types[77]
2544 #define SWIGTYPE_p_wxJoystickEvent swig_types[78]
2545 #define SWIGTYPE_p_wxKeyEvent swig_types[79]
2546 #define SWIGTYPE_p_wxKillError swig_types[80]
2547 #define SWIGTYPE_p_wxLayoutConstraints swig_types[81]
2548 #define SWIGTYPE_p_wxLog swig_types[82]
2549 #define SWIGTYPE_p_wxLogBuffer swig_types[83]
2550 #define SWIGTYPE_p_wxLogChain swig_types[84]
2551 #define SWIGTYPE_p_wxLogGui swig_types[85]
2552 #define SWIGTYPE_p_wxLogNull swig_types[86]
2553 #define SWIGTYPE_p_wxLogStderr swig_types[87]
2554 #define SWIGTYPE_p_wxLogTextCtrl swig_types[88]
2555 #define SWIGTYPE_p_wxLogWindow swig_types[89]
2556 #define SWIGTYPE_p_wxMaximizeEvent swig_types[90]
2557 #define SWIGTYPE_p_wxMenu swig_types[91]
2558 #define SWIGTYPE_p_wxMenuBar swig_types[92]
2559 #define SWIGTYPE_p_wxMenuEvent swig_types[93]
2560 #define SWIGTYPE_p_wxMenuItem 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_wxTGAHandler swig_types[156]
2623 #define SWIGTYPE_p_wxTIFFHandler swig_types[157]
2624 #define SWIGTYPE_p_wxTextCtrl swig_types[158]
2625 #define SWIGTYPE_p_wxTextDataObject swig_types[159]
2626 #define SWIGTYPE_p_wxTimeSpan swig_types[160]
2627 #define SWIGTYPE_p_wxTimer swig_types[161]
2628 #define SWIGTYPE_p_wxTimerEvent swig_types[162]
2629 #define SWIGTYPE_p_wxTimerRunner swig_types[163]
2630 #define SWIGTYPE_p_wxTipProvider swig_types[164]
2631 #define SWIGTYPE_p_wxToolTip swig_types[165]
2632 #define SWIGTYPE_p_wxURLDataObject swig_types[166]
2633 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[167]
2634 #define SWIGTYPE_p_wxValidator swig_types[168]
2635 #define SWIGTYPE_p_wxVideoMode swig_types[169]
2636 #define SWIGTYPE_p_wxWindow swig_types[170]
2637 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[171]
2638 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[172]
2639 #define SWIGTYPE_p_wxWindowDisabler swig_types[173]
2640 #define SWIGTYPE_p_wxXPMHandler swig_types[174]
2641 static swig_type_info *swig_types[176];
2642 static swig_module_info swig_module = {swig_types, 175, 0, 0, 0, 0};
2643 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2644 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2645
2646 /* -------- TYPES TABLE (END) -------- */
2647
2648 #if (PY_VERSION_HEX <= 0x02000000)
2649 # if !defined(SWIG_PYTHON_CLASSIC)
2650 # error "This python version requires to use swig with the '-classic' option"
2651 # endif
2652 #endif
2653 #if (PY_VERSION_HEX <= 0x02020000)
2654 # error "This python version requires to use swig with the '-nomodern' option"
2655 #endif
2656 #if (PY_VERSION_HEX <= 0x02020000)
2657 # error "This python version requires to use swig with the '-nomodernargs' option"
2658 #endif
2659 #ifndef METH_O
2660 # error "This python version requires to use swig with the '-nofastunpack' option"
2661 #endif
2662
2663 /*-----------------------------------------------
2664 @(target):= _misc_.so
2665 ------------------------------------------------*/
2666 #define SWIG_init init_misc_
2667
2668 #define SWIG_name "_misc_"
2669
2670 #define SWIGVERSION 0x010329
2671
2672
2673 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2674 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2675
2676
2677 #include <stdexcept>
2678
2679
2680 namespace swig {
2681 class PyObject_ptr {
2682 protected:
2683 PyObject *_obj;
2684
2685 public:
2686 PyObject_ptr() :_obj(0)
2687 {
2688 }
2689
2690 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2691 {
2692 Py_XINCREF(_obj);
2693 }
2694
2695 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2696 {
2697 if (initial_ref) Py_XINCREF(_obj);
2698 }
2699
2700 PyObject_ptr & operator=(const PyObject_ptr& item)
2701 {
2702 Py_XINCREF(item._obj);
2703 Py_XDECREF(_obj);
2704 _obj = item._obj;
2705 return *this;
2706 }
2707
2708 ~PyObject_ptr()
2709 {
2710 Py_XDECREF(_obj);
2711 }
2712
2713 operator PyObject *() const
2714 {
2715 return _obj;
2716 }
2717
2718 PyObject *operator->() const
2719 {
2720 return _obj;
2721 }
2722 };
2723 }
2724
2725
2726 namespace swig {
2727 struct PyObject_var : PyObject_ptr {
2728 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2729
2730 PyObject_var & operator = (PyObject* obj)
2731 {
2732 Py_XDECREF(_obj);
2733 _obj = obj;
2734 return *this;
2735 }
2736 };
2737 }
2738
2739
2740 #include "wx/wxPython/wxPython.h"
2741 #include "wx/wxPython/pyclasses.h"
2742 #include "wx/wxPython/pyistream.h"
2743
2744 static const wxString wxPyEmptyString(wxEmptyString);
2745
2746
2747
2748 #define SWIG_From_long PyInt_FromLong
2749
2750
2751 SWIGINTERNINLINE PyObject *
2752 SWIG_From_int (int value)
2753 {
2754 return SWIG_From_long (value);
2755 }
2756
2757
2758 #include <limits.h>
2759 #ifndef LLONG_MIN
2760 # define LLONG_MIN LONG_LONG_MIN
2761 #endif
2762 #ifndef LLONG_MAX
2763 # define LLONG_MAX LONG_LONG_MAX
2764 #endif
2765 #ifndef ULLONG_MAX
2766 # define ULLONG_MAX ULONG_LONG_MAX
2767 #endif
2768
2769
2770 SWIGINTERN int
2771 SWIG_AsVal_long (PyObject* obj, long* val)
2772 {
2773 if (PyNumber_Check(obj)) {
2774 if (val) *val = PyInt_AsLong(obj);
2775 return SWIG_OK;
2776 }
2777 return SWIG_TypeError;
2778 }
2779
2780
2781 SWIGINTERN int
2782 SWIG_AsVal_int (PyObject * obj, int *val)
2783 {
2784 long v;
2785 int res = SWIG_AsVal_long (obj, &v);
2786 if (SWIG_IsOK(res)) {
2787 if ((v < INT_MIN || v > INT_MAX)) {
2788 return SWIG_OverflowError;
2789 } else {
2790 if (val) *val = static_cast< int >(v);
2791 }
2792 }
2793 return res;
2794 }
2795
2796 static const wxString wxPyWINDOW_DEFAULT_VARIANT(wxWINDOW_DEFAULT_VARIANT);
2797
2798 #include <wx/stockitem.h>
2799
2800 static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
2801 static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
2802 static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
2803
2804 SWIGINTERN int
2805 SWIG_AsVal_bool (PyObject *obj, bool *val)
2806 {
2807 if (obj == Py_True) {
2808 if (val) *val = true;
2809 return SWIG_OK;
2810 } else if (obj == Py_False) {
2811 if (val) *val = false;
2812 return SWIG_OK;
2813 } else {
2814 long v = 0;
2815 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
2816 if (SWIG_IsOK(res) && val) *val = v ? true : false;
2817 return res;
2818 }
2819 }
2820
2821
2822 wxMemorySize wxGetFreeMemory()
2823 { wxPyRaiseNotImplemented(); return 0; }
2824
2825
2826 SWIGINTERN int
2827 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
2828 {
2829 long v = 0;
2830 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2831 return SWIG_TypeError;
2832 }
2833 else if (val)
2834 *val = (unsigned long)v;
2835 return SWIG_OK;
2836 }
2837
2838
2839 SWIGINTERNINLINE PyObject*
2840 SWIG_From_unsigned_SS_long (unsigned long value)
2841 {
2842 return (value > LONG_MAX) ?
2843 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
2844 }
2845
2846
2847 void* wxGetXDisplay()
2848 {
2849 #ifdef __WXGTK__
2850 return wxGetDisplay();
2851 #else
2852 return NULL;
2853 #endif
2854 }
2855
2856
2857 wxWindow* FindWindowAtPointer() {
2858 wxPoint unused;
2859 return wxFindWindowAtPointer(unused);
2860 }
2861
2862
2863 void wxWakeUpMainThread() {}
2864
2865
2866 bool wxThread_IsMain() {
2867 #ifdef WXP_WITH_THREAD
2868 return wxThread::IsMain();
2869 #else
2870 return true;
2871 #endif
2872 }
2873
2874 SWIGINTERN void wxCaret_Destroy(wxCaret *self){
2875 delete self;
2876 }
2877
2878 #include <wx/snglinst.h>
2879
2880
2881 #ifdef __WXMSW__
2882 #include <wx/msw/private.h>
2883 #include <wx/dynload.h>
2884 #endif
2885
2886
2887
2888 bool wxDrawWindowOnDC(wxWindow* window, const wxDC& dc
2889 #if 0
2890 , int method
2891 #endif
2892 )
2893 {
2894 #ifdef __WXMSW__
2895 #if 0
2896 switch (method)
2897 {
2898 case 1:
2899 // This one only partially works. Appears to be an undocumented
2900 // "standard" convention that not all widgets adhear to. For
2901 // example, for some widgets backgrounds or non-client areas may
2902 // not be painted.
2903 ::SendMessage(GetHwndOf(window), WM_PAINT, (long)GetHdcOf(dc), 0);
2904 break;
2905
2906 case 2:
2907 #endif
2908 // This one works much better, nearly all widgets and their
2909 // children are captured correctly[**]. Prior to the big
2910 // background erase changes that Vadim did in 2004-2005 this
2911 // method failed badly on XP with Themes activated, most native
2912 // widgets draw only partially, if at all. Without themes it
2913 // worked just like on Win2k. After those changes this method
2914 // works very well.
2915 //
2916 // ** For example the radio buttons in a wxRadioBox are not its
2917 // children by default, but you can capture it via the panel
2918 // instead, or change RADIOBTN_PARENT_IS_RADIOBOX in radiobox.cpp.
2919 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2920 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2921 PRF_ERASEBKGND | PRF_OWNED );
2922 return true;
2923 #if 0
2924 break;
2925
2926 case 3:
2927 // This one is only defined in the latest SDK and is only
2928 // available on XP. MSDN says it is similar to sending WM_PRINT
2929 // so I expect that it will work similar to the above. Since it
2930 // is avaialble only on XP, it can't be compiled like this and
2931 // will have to be loaded dynamically.
2932 // //::PrintWindow(GetHwndOf(window), GetHdcOf(dc), 0); //break;
2933
2934 // fall through
2935
2936 case 4:
2937 // Use PrintWindow if available, or fallback to WM_PRINT
2938 // otherwise. Unfortunately using PrintWindow is even worse than
2939 // WM_PRINT. For most native widgets nothing is drawn to the dc
2940 // at all, with or without Themes.
2941 typedef BOOL (WINAPI *PrintWindow_t)(HWND, HDC, UINT);
2942 static bool s_triedToLoad = false;
2943 static PrintWindow_t pfnPrintWindow = NULL;
2944 if ( !s_triedToLoad )
2945 {
2946
2947 s_triedToLoad = true;
2948 wxDynamicLibrary dllUser32(_T("user32.dll"));
2949 if ( dllUser32.IsLoaded() )
2950 {
2951 wxLogNull nolog; // Don't report errors here
2952 pfnPrintWindow = (PrintWindow_t)dllUser32.GetSymbol(_T("PrintWindow"));
2953 }
2954 }
2955 if (pfnPrintWindow)
2956 {
2957 //printf("Using PrintWindow\n");
2958 pfnPrintWindow(GetHwndOf(window), GetHdcOf(dc), 0);
2959 }
2960 else
2961 {
2962 //printf("Using WM_PRINT\n");
2963 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2964 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2965 PRF_ERASEBKGND | PRF_OWNED );
2966 }
2967 }
2968 #endif // 0
2969 #else
2970 return false;
2971 #endif // __WXMSW__
2972 }
2973
2974
2975
2976 #include <wx/tipdlg.h>
2977
2978
2979 SWIGINTERNINLINE PyObject *
2980 SWIG_From_size_t (size_t value)
2981 {
2982 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
2983 }
2984
2985
2986 class wxPyTipProvider : public wxTipProvider {
2987 public:
2988 wxPyTipProvider(size_t currentTip)
2989 : wxTipProvider(currentTip) {}
2990
2991 DEC_PYCALLBACK_STRING__pure(GetTip);
2992 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
2993 PYPRIVATE;
2994 };
2995
2996 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
2997 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
2998
2999
3000 SWIGINTERNINLINE int
3001 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3002 {
3003 unsigned long v;
3004 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3005 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3006 return res;
3007 }
3008
3009
3010 IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
3011
3012 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
3013
3014 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
3015 : wxTimer(owner, id)
3016 {
3017 if (owner == NULL)
3018 SetOwner(this);
3019 }
3020
3021 wxPyTimer::~wxPyTimer()
3022 {
3023 // printf("-=* ~wxPyTimer\n");
3024 }
3025
3026
3027
3028 SWIGINTERN swig_type_info*
3029 SWIG_pchar_descriptor()
3030 {
3031 static int init = 0;
3032 static swig_type_info* info = 0;
3033 if (!init) {
3034 info = SWIG_TypeQuery("_p_char");
3035 init = 1;
3036 }
3037 return info;
3038 }
3039
3040
3041 SWIGINTERNINLINE PyObject *
3042 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3043 {
3044 if (carray) {
3045 if (size > INT_MAX) {
3046 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3047 return pchar_descriptor ?
3048 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3049 } else {
3050 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3051 }
3052 } else {
3053 return SWIG_Py_Void();
3054 }
3055 }
3056
3057
3058 SWIGINTERNINLINE PyObject *
3059 SWIG_FromCharPtr(const char *cptr)
3060 {
3061 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3062 }
3063
3064
3065 SWIGINTERN int
3066 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3067 {
3068 unsigned long v;
3069 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3070 if (SWIG_IsOK(res)) {
3071 if ((v > UINT_MAX)) {
3072 return SWIG_OverflowError;
3073 } else {
3074 if (val) *val = static_cast< unsigned int >(v);
3075 }
3076 }
3077 return res;
3078 }
3079
3080 SWIGINTERN wxString wxLog_TimeStamp(){
3081 wxString msg;
3082 wxLog::TimeStamp(&msg);
3083 return msg;
3084 }
3085 SWIGINTERN void wxLog_Destroy(wxLog *self){ delete self; }
3086 // Make some wrappers that double any % signs so they are 'escaped'
3087 void wxPyLogFatalError(const wxString& msg)
3088 {
3089 wxString m(msg);
3090 m.Replace(wxT("%"), wxT("%%"));
3091 wxLogFatalError(m);
3092 }
3093
3094 void wxPyLogError(const wxString& msg)
3095 {
3096 wxString m(msg);
3097 m.Replace(wxT("%"), wxT("%%"));
3098 wxLogError(m);
3099 }
3100
3101 void wxPyLogWarning(const wxString& msg)
3102 {
3103 wxString m(msg);
3104 m.Replace(wxT("%"), wxT("%%"));
3105 wxLogWarning(m);
3106 }
3107
3108 void wxPyLogMessage(const wxString& msg)
3109 {
3110 wxString m(msg);
3111 m.Replace(wxT("%"), wxT("%%"));
3112 wxLogMessage(m);
3113 }
3114
3115 void wxPyLogInfo(const wxString& msg)
3116 {
3117 wxString m(msg);
3118 m.Replace(wxT("%"), wxT("%%"));
3119 wxLogInfo(m);
3120 }
3121
3122 void wxPyLogDebug(const wxString& msg)
3123 {
3124 wxString m(msg);
3125 m.Replace(wxT("%"), wxT("%%"));
3126 wxLogDebug(m);
3127 }
3128
3129 void wxPyLogVerbose(const wxString& msg)
3130 {
3131 wxString m(msg);
3132 m.Replace(wxT("%"), wxT("%%"));
3133 wxLogVerbose(m);
3134 }
3135
3136 void wxPyLogStatus(const wxString& msg)
3137 {
3138 wxString m(msg);
3139 m.Replace(wxT("%"), wxT("%%"));
3140 wxLogStatus(m);
3141 }
3142
3143 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
3144 {
3145 wxString m(msg);
3146 m.Replace(wxT("%"), wxT("%%"));
3147 wxLogStatus(pFrame, m);
3148 }
3149
3150 void wxPyLogSysError(const wxString& msg)
3151 {
3152 wxString m(msg);
3153 m.Replace(wxT("%"), wxT("%%"));
3154 wxLogSysError(m);
3155 }
3156
3157 void wxPyLogGeneric(unsigned long level, const wxString& msg)
3158 {
3159 wxString m(msg);
3160 m.Replace(wxT("%"), wxT("%%"));
3161 wxLogGeneric(level, m);
3162 }
3163
3164 void wxPyLogTrace(unsigned long mask, const wxString& msg)
3165 {
3166 wxString m(msg);
3167 m.Replace(wxT("%"), wxT("%%"));
3168 wxLogTrace(mask, m);
3169 }
3170
3171 void wxPyLogTrace(const wxString& mask, const wxString& msg)
3172 {
3173 wxString m(msg);
3174 m.Replace(wxT("%"), wxT("%%"));
3175 wxLogTrace(mask, m);
3176 }
3177
3178
3179
3180 // A wxLog class that can be derived from in wxPython
3181 class wxPyLog : public wxLog {
3182 public:
3183 wxPyLog() : wxLog() {}
3184
3185 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
3186 bool found;
3187 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3188 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
3189 PyObject* s = wx2PyString(szString);
3190 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
3191 Py_DECREF(s);
3192 }
3193 wxPyEndBlockThreads(blocked);
3194 if (! found)
3195 wxLog::DoLog(level, szString, t);
3196 }
3197
3198 virtual void DoLogString(const wxChar *szString, time_t t) {
3199 bool found;
3200 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3201 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
3202 PyObject* s = wx2PyString(szString);
3203 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
3204 Py_DECREF(s);
3205 }
3206 wxPyEndBlockThreads(blocked);
3207 if (! found)
3208 wxLog::DoLogString(szString, t);
3209 }
3210
3211 DEC_PYCALLBACK_VOID_(Flush);
3212 PYPRIVATE;
3213 };
3214 IMP_PYCALLBACK_VOID_(wxPyLog, wxLog, Flush);
3215
3216
3217
3218
3219 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
3220
3221
3222 #include <wx/joystick.h>
3223
3224
3225 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
3226 // A C++ stub class for wxJoystick for platforms that don't have it.
3227 class wxJoystick : public wxObject {
3228 public:
3229 wxJoystick(int joystick = wxJOYSTICK1) {
3230 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3231 PyErr_SetString(PyExc_NotImplementedError,
3232 "wxJoystick is not available on this platform.");
3233 wxPyEndBlockThreads(blocked);
3234 }
3235 wxPoint GetPosition() { return wxPoint(-1,-1); }
3236 int GetZPosition() { return -1; }
3237 int GetButtonState() { return -1; }
3238 int GetPOVPosition() { return -1; }
3239 int GetPOVCTSPosition() { return -1; }
3240 int GetRudderPosition() { return -1; }
3241 int GetUPosition() { return -1; }
3242 int GetVPosition() { return -1; }
3243 int GetMovementThreshold() { return -1; }
3244 void SetMovementThreshold(int threshold) {}
3245
3246 bool IsOk(void) { return false; }
3247 int GetNumberJoysticks() { return -1; }
3248 int GetManufacturerId() { return -1; }
3249 int GetProductId() { return -1; }
3250 wxString GetProductName() { return wxEmptyString; }
3251 int GetXMin() { return -1; }
3252 int GetYMin() { return -1; }
3253 int GetZMin() { return -1; }
3254 int GetXMax() { return -1; }
3255 int GetYMax() { return -1; }
3256 int GetZMax() { return -1; }
3257 int GetNumberButtons() { return -1; }
3258 int GetNumberAxes() { return -1; }
3259 int GetMaxButtons() { return -1; }
3260 int GetMaxAxes() { return -1; }
3261 int GetPollingMin() { return -1; }
3262 int GetPollingMax() { return -1; }
3263 int GetRudderMin() { return -1; }
3264 int GetRudderMax() { return -1; }
3265 int GetUMin() { return -1; }
3266 int GetUMax() { return -1; }
3267 int GetVMin() { return -1; }
3268 int GetVMax() { return -1; }
3269
3270 bool HasRudder() { return false; }
3271 bool HasZ() { return false; }
3272 bool HasU() { return false; }
3273 bool HasV() { return false; }
3274 bool HasPOV() { return false; }
3275 bool HasPOV4Dir() { return false; }
3276 bool HasPOVCTS() { return false; }
3277
3278 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
3279 bool ReleaseCapture() { return false; }
3280 };
3281 #endif
3282
3283
3284 #include <wx/sound.h>
3285
3286
3287 #if !wxUSE_SOUND
3288 // A C++ stub class for wxWave for platforms that don't have it.
3289 class wxSound : public wxObject
3290 {
3291 public:
3292 wxSound() {
3293 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3294 PyErr_SetString(PyExc_NotImplementedError,
3295 "wxSound is not available on this platform.");
3296 wxPyEndBlockThreads(blocked);
3297 }
3298 wxSound(const wxString&/*, bool*/) {
3299 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3300 PyErr_SetString(PyExc_NotImplementedError,
3301 "wxSound is not available on this platform.");
3302 wxPyEndBlockThreads(blocked);
3303 }
3304 wxSound(int, const wxByte*) {
3305 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3306 PyErr_SetString(PyExc_NotImplementedError,
3307 "wxSound is not available on this platform.");
3308 wxPyEndBlockThreads(blocked);
3309 }
3310
3311 ~wxSound() {};
3312
3313 bool Create(const wxString&/*, bool*/) { return false; }
3314 bool Create(int, const wxByte*) { return false; };
3315 bool IsOk() { return false; };
3316 bool Play(unsigned) const { return false; }
3317 static bool Play(const wxString&, unsigned) { return false; }
3318 static void Stop() {}
3319 };
3320
3321 #endif
3322
3323 SWIGINTERN wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
3324 if (fileName.Length() == 0)
3325 return new wxSound;
3326 else
3327 return new wxSound(fileName);
3328 }
3329 SWIGINTERN wxSound *new_wxSound(PyObject *data){
3330 unsigned char* buffer; int size;
3331 wxSound *sound = NULL;
3332
3333 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3334 if (!PyArg_Parse(data, "t#", &buffer, &size))
3335 goto done;
3336 sound = new wxSound(size, buffer);
3337 done:
3338 wxPyEndBlockThreads(blocked);
3339 return sound;
3340 }
3341 SWIGINTERN bool wxSound_CreateFromData(wxSound *self,PyObject *data){
3342 #ifndef __WXMAC__
3343 unsigned char* buffer;
3344 int size;
3345 bool rv = false;
3346
3347 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3348 if (!PyArg_Parse(data, "t#", &buffer, &size))
3349 goto done;
3350 rv = self->Create(size, buffer);
3351 done:
3352 wxPyEndBlockThreads(blocked);
3353 return rv;
3354 #else
3355 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3356 PyErr_SetString(PyExc_NotImplementedError,
3357 "Create from data is not available on this platform.");
3358 wxPyEndBlockThreads(blocked);
3359 return false;
3360 #endif
3361 }
3362
3363 #include <wx/mimetype.h>
3364
3365 SWIGINTERN PyObject *wxFileType_GetMimeType(wxFileType *self){
3366 wxString str;
3367 if (self->GetMimeType(&str))
3368 return wx2PyString(str);
3369 else
3370 RETURN_NONE();
3371 }
3372 SWIGINTERN PyObject *wxFileType_GetMimeTypes(wxFileType *self){
3373 wxArrayString arr;
3374 if (self->GetMimeTypes(arr))
3375 return wxArrayString2PyList_helper(arr);
3376 else
3377 RETURN_NONE();
3378 }
3379 SWIGINTERN PyObject *wxFileType_GetExtensions(wxFileType *self){
3380 wxArrayString arr;
3381 if (self->GetExtensions(arr))
3382 return wxArrayString2PyList_helper(arr);
3383 else
3384 RETURN_NONE();
3385 }
3386 SWIGINTERN wxIcon *wxFileType_GetIcon(wxFileType *self){
3387 wxIconLocation loc;
3388 if (self->GetIcon(&loc))
3389 return new wxIcon(loc);
3390 else
3391 return NULL;
3392 }
3393 SWIGINTERN PyObject *wxFileType_GetIconInfo(wxFileType *self){
3394 wxIconLocation loc;
3395 if (self->GetIcon(&loc)) {
3396 wxString iconFile = loc.GetFileName();
3397 int iconIndex = -1;
3398
3399
3400
3401 // Make a tuple and put the values in it
3402 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3403 PyObject* tuple = PyTuple_New(3);
3404 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
3405 wxT("wxIcon"), true));
3406 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
3407 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
3408 wxPyEndBlockThreads(blocked);
3409 return tuple;
3410 }
3411 else
3412 RETURN_NONE();
3413 }
3414 SWIGINTERN PyObject *wxFileType_GetDescription(wxFileType *self){
3415 wxString str;
3416 if (self->GetDescription(&str))
3417 return wx2PyString(str);
3418 else
3419 RETURN_NONE();
3420 }
3421 SWIGINTERN PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3422 wxString str;
3423 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3424 return wx2PyString(str);
3425 else
3426 RETURN_NONE();
3427 }
3428 SWIGINTERN PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3429 wxString str;
3430 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3431 return wx2PyString(str);
3432 else
3433 RETURN_NONE();
3434 }
3435 SWIGINTERN PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3436 wxArrayString verbs;
3437 wxArrayString commands;
3438 if (self->GetAllCommands(&verbs, &commands,
3439 wxFileType::MessageParameters(filename, mimetype))) {
3440 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3441 PyObject* tuple = PyTuple_New(2);
3442 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
3443 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
3444 wxPyEndBlockThreads(blocked);
3445 return tuple;
3446 }
3447 else
3448 RETURN_NONE();
3449 }
3450 SWIGINTERN wxString wxFileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3451 return wxFileType::ExpandCommand(command,
3452 wxFileType::MessageParameters(filename, mimetype));
3453 }
3454 SWIGINTERN PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
3455 wxArrayString arr;
3456 self->EnumAllFileTypes(arr);
3457 return wxArrayString2PyList_helper(arr);
3458 }
3459
3460 #include <wx/artprov.h>
3461
3462 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
3463 static const wxString wxPyART_MENU(wxART_MENU);
3464 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
3465 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
3466 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
3467 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
3468 static const wxString wxPyART_BUTTON(wxART_BUTTON);
3469 static const wxString wxPyART_OTHER(wxART_OTHER);
3470 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
3471 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
3472 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
3473 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
3474 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
3475 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
3476 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
3477 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
3478 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
3479 static const wxString wxPyART_GO_UP(wxART_GO_UP);
3480 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
3481 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
3482 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
3483 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
3484 static const wxString wxPyART_FILE_SAVE(wxART_FILE_SAVE);
3485 static const wxString wxPyART_FILE_SAVE_AS(wxART_FILE_SAVE_AS);
3486 static const wxString wxPyART_PRINT(wxART_PRINT);
3487 static const wxString wxPyART_HELP(wxART_HELP);
3488 static const wxString wxPyART_TIP(wxART_TIP);
3489 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
3490 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
3491 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
3492 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
3493 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
3494 static const wxString wxPyART_CDROM(wxART_CDROM);
3495 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
3496 static const wxString wxPyART_FOLDER(wxART_FOLDER);
3497 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
3498 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
3499 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
3500 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
3501 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
3502 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
3503 static const wxString wxPyART_ERROR(wxART_ERROR);
3504 static const wxString wxPyART_QUESTION(wxART_QUESTION);
3505 static const wxString wxPyART_WARNING(wxART_WARNING);
3506 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
3507 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
3508 static const wxString wxPyART_COPY(wxART_COPY);
3509 static const wxString wxPyART_CUT(wxART_CUT);
3510 static const wxString wxPyART_PASTE(wxART_PASTE);
3511 static const wxString wxPyART_DELETE(wxART_DELETE);
3512 static const wxString wxPyART_NEW(wxART_NEW);
3513 static const wxString wxPyART_UNDO(wxART_UNDO);
3514 static const wxString wxPyART_REDO(wxART_REDO);
3515 static const wxString wxPyART_QUIT(wxART_QUIT);
3516 static const wxString wxPyART_FIND(wxART_FIND);
3517 static const wxString wxPyART_FIND_AND_REPLACE(wxART_FIND_AND_REPLACE);
3518 // Python aware wxArtProvider
3519 class wxPyArtProvider : public wxArtProvider {
3520 public:
3521
3522 virtual wxBitmap CreateBitmap(const wxArtID& id,
3523 const wxArtClient& client,
3524 const wxSize& size) {
3525 wxBitmap rval = wxNullBitmap;
3526 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3527 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
3528 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
3529 PyObject* ro;
3530 wxBitmap* ptr;
3531 PyObject* s1, *s2;
3532 s1 = wx2PyString(id);
3533 s2 = wx2PyString(client);
3534 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
3535 Py_DECREF(so);
3536 Py_DECREF(s1);
3537 Py_DECREF(s2);
3538 if (ro) {
3539 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
3540 rval = *ptr;
3541 Py_DECREF(ro);
3542 }
3543 }
3544 wxPyEndBlockThreads(blocked);
3545 return rval;
3546 }
3547
3548 PYPRIVATE;
3549 };
3550
3551 SWIGINTERN void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
3552
3553
3554
3555 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
3556 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3557 PyObject* ret = PyTuple_New(3);
3558 if (ret) {
3559 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
3560 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
3561 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
3562 }
3563 wxPyEndBlockThreads(blocked);
3564 return ret;
3565 }
3566
3567 SWIGINTERN PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
3568 bool cont;
3569 long index = 0;
3570 wxString value;
3571
3572 cont = self->GetFirstGroup(value, index);
3573 return __EnumerationHelper(cont, value, index);
3574 }
3575 SWIGINTERN PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
3576 bool cont;
3577 wxString value;
3578
3579 cont = self->GetNextGroup(value, index);
3580 return __EnumerationHelper(cont, value, index);
3581 }
3582 SWIGINTERN PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
3583 bool cont;
3584 long index = 0;
3585 wxString value;
3586
3587 cont = self->GetFirstEntry(value, index);
3588 return __EnumerationHelper(cont, value, index);
3589 }
3590 SWIGINTERN PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
3591 bool cont;
3592 wxString value;
3593
3594 cont = self->GetNextEntry(value, index);
3595 return __EnumerationHelper(cont, value, index);
3596 }
3597 SWIGINTERN long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
3598 long rv;
3599 self->Read(key, &rv, defaultVal);
3600 return rv;
3601 }
3602
3603 SWIGINTERN int
3604 SWIG_AsVal_double (PyObject *obj, double* val)
3605 {
3606 if (PyNumber_Check(obj)) {
3607 if (val) *val = PyFloat_AsDouble(obj);
3608 return SWIG_OK;
3609 }
3610 return SWIG_TypeError;
3611 }
3612
3613 SWIGINTERN double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
3614 double rv;
3615 self->Read(key, &rv, defaultVal);
3616 return rv;
3617 }
3618
3619 #define SWIG_From_double PyFloat_FromDouble
3620
3621 SWIGINTERN bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
3622 bool rv;
3623 self->Read(key, &rv, defaultVal);
3624 return rv;
3625 }
3626
3627 #include <wx/datetime.h>
3628
3629 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
3630 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
3631
3632 #define LOCAL_TZ wxDateTime::Local
3633
3634 SWIGINTERN PyObject *wxDateTime_GetAmPmStrings(){
3635 wxString am;
3636 wxString pm;
3637 wxDateTime::GetAmPmStrings(&am, &pm);
3638 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3639 PyObject* tup = PyTuple_New(2);
3640 PyTuple_SET_ITEM(tup, 0, wx2PyString(am));
3641 PyTuple_SET_ITEM(tup, 1, wx2PyString(pm));
3642 wxPyEndBlockThreads(blocked);
3643 return tup;
3644 }
3645
3646 SWIGINTERNINLINE PyObject *
3647 SWIG_From_unsigned_SS_int (unsigned int value)
3648 {
3649 return SWIG_From_unsigned_SS_long (value);
3650 }
3651
3652 SWIGINTERN wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
3653 SWIGINTERN wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
3654 SWIGINTERN wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
3655 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
3656 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
3657 SWIGINTERN bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
3658 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
3659 return (*self < *other);
3660 }
3661 SWIGINTERN bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
3662 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
3663 return (*self <= *other);
3664 }
3665 SWIGINTERN bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
3666 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
3667 return (*self > *other);
3668 }
3669 SWIGINTERN bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
3670 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
3671 return (*self >= *other);
3672 }
3673 SWIGINTERN bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
3674 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
3675 return (*self == *other);
3676 }
3677 SWIGINTERN bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
3678 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
3679 return (*self != *other);
3680 }
3681 SWIGINTERN int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
3682 const wxChar* rv;
3683 const wxChar* _date = date;
3684 rv = self->ParseRfc822Date(_date);
3685 if (rv == NULL) return -1;
3686 return rv - _date;
3687 }
3688 SWIGINTERN int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
3689 const wxChar* rv;
3690 const wxChar* _date = date;
3691 rv = self->ParseFormat(_date, format, dateDef);
3692 if (rv == NULL) return -1;
3693 return rv - _date;
3694 }
3695 SWIGINTERN int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
3696 const wxChar* rv;
3697 const wxChar* _datetime = datetime;
3698 rv = self->ParseDateTime(_datetime);
3699 if (rv == NULL) return -1;
3700 return rv - _datetime;
3701 }
3702 SWIGINTERN int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
3703 const wxChar* rv;
3704 const wxChar* _date = date;
3705 rv = self->ParseDate(_date);
3706 if (rv == NULL) return -1;
3707 return rv - _date;
3708 }
3709 SWIGINTERN int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
3710 const wxChar* rv;
3711 const wxChar* _time = time;
3712 rv = self->ParseTime(_time);
3713 if (rv == NULL) return -1;
3714 return rv - _time;
3715 }
3716 SWIGINTERN wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
3717 SWIGINTERN wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
3718 SWIGINTERN wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
3719 SWIGINTERN wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
3720 SWIGINTERN bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
3721 SWIGINTERN bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
3722 SWIGINTERN bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
3723 SWIGINTERN bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
3724 SWIGINTERN bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
3725 SWIGINTERN bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
3726 SWIGINTERN wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
3727 SWIGINTERN wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
3728 SWIGINTERN wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
3729 SWIGINTERN wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
3730 SWIGINTERN bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
3731 SWIGINTERN bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
3732
3733 #include <wx/dataobj.h>
3734
3735 SWIGINTERN PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
3736 size_t count = self->GetFormatCount(dir);
3737 wxDataFormat* formats = new wxDataFormat[count];
3738 self->GetAllFormats(formats, dir);
3739
3740 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3741 PyObject* list = PyList_New(count);
3742 for (size_t i=0; i<count; i++) {
3743 wxDataFormat* format = new wxDataFormat(formats[i]);
3744 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
3745 PyList_SET_ITEM(list, i, obj); // PyList_SET_ITEM steals a reference
3746 }
3747 wxPyEndBlockThreads(blocked);
3748 delete [] formats;
3749 return list;
3750 }
3751 SWIGINTERN PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
3752 PyObject* rval = NULL;
3753 size_t size = self->GetDataSize(format);
3754 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3755 if (size) {
3756 char* buf = new char[size];
3757 if (self->GetDataHere(format, buf))
3758 rval = PyString_FromStringAndSize(buf, size);
3759 delete [] buf;
3760 }
3761 if (! rval) {
3762 rval = Py_None;
3763 Py_INCREF(rval);
3764 }
3765 wxPyEndBlockThreads(blocked);
3766 return rval;
3767 }
3768 SWIGINTERN bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
3769 bool rval;
3770 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3771 if (PyString_Check(data)) {
3772 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
3773 }
3774 else {
3775 // raise a TypeError if not a string
3776 PyErr_SetString(PyExc_TypeError, "String expected.");
3777 rval = false;
3778 }
3779 wxPyEndBlockThreads(blocked);
3780 return rval;
3781 }
3782 SWIGINTERN PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
3783 PyObject* rval = NULL;
3784 size_t size = self->GetDataSize();
3785 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3786 if (size) {
3787 char* buf = new char[size];
3788 if (self->GetDataHere(buf))
3789 rval = PyString_FromStringAndSize(buf, size);
3790 delete [] buf;
3791 }
3792 if (! rval) {
3793 rval = Py_None;
3794 Py_INCREF(rval);
3795 }
3796 wxPyEndBlockThreads(blocked);
3797 return rval;
3798 }
3799 SWIGINTERN bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
3800 bool rval;
3801 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3802 if (PyString_Check(data)) {
3803 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3804 }
3805 else {
3806 // raise a TypeError if not a string
3807 PyErr_SetString(PyExc_TypeError, "String expected.");
3808 rval = false;
3809 }
3810 wxPyEndBlockThreads(blocked);
3811 return rval;
3812 }
3813 // Create a new class for wxPython to use
3814 class wxPyDataObjectSimple : public wxDataObjectSimple {
3815 public:
3816 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
3817 : wxDataObjectSimple(format) {}
3818
3819 DEC_PYCALLBACK_SIZET__const(GetDataSize);
3820 bool GetDataHere(void *buf) const;
3821 bool SetData(size_t len, const void *buf);
3822 PYPRIVATE;
3823 };
3824
3825 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
3826
3827 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
3828 // We need to get the data for this object and write it to buf. I think
3829 // the best way to do this for wxPython is to have the Python method
3830 // return either a string or None and then act appropriately with the
3831 // C++ version.
3832
3833 bool rval = false;
3834 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3835 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
3836 PyObject* ro;
3837 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3838 if (ro) {
3839 rval = (ro != Py_None && PyString_Check(ro));
3840 if (rval)
3841 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
3842 Py_DECREF(ro);
3843 }
3844 }
3845 wxPyEndBlockThreads(blocked);
3846 return rval;
3847 }
3848
3849 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) {
3850 // For this one we simply need to make a string from buf and len
3851 // and send it to the Python method.
3852 bool rval = false;
3853 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3854 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
3855 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
3856 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
3857 Py_DECREF(data);
3858 }
3859 wxPyEndBlockThreads(blocked);
3860 return rval;
3861 }
3862
3863 // Create a new class for wxPython to use
3864 class wxPyTextDataObject : public wxTextDataObject {
3865 public:
3866 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
3867 : wxTextDataObject(text) {}
3868
3869 DEC_PYCALLBACK_SIZET__const(GetTextLength);
3870 DEC_PYCALLBACK_STRING__const(GetText);
3871 DEC_PYCALLBACK__STRING(SetText);
3872 PYPRIVATE;
3873 };
3874
3875 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
3876 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
3877 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
3878
3879
3880 // Create a new class for wxPython to use
3881 class wxPyBitmapDataObject : public wxBitmapDataObject {
3882 public:
3883 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
3884 : wxBitmapDataObject(bitmap) {}
3885
3886 wxBitmap GetBitmap() const;
3887 void SetBitmap(const wxBitmap& bitmap);
3888 PYPRIVATE;
3889 };
3890
3891 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
3892 wxBitmap* rval = &wxNullBitmap;
3893 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3894 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
3895 PyObject* ro;
3896 wxBitmap* ptr;
3897 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3898 if (ro) {
3899 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
3900 rval = ptr;
3901 Py_DECREF(ro);
3902 }
3903 }
3904 wxPyEndBlockThreads(blocked);
3905 return *rval;
3906 }
3907
3908 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
3909 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3910 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
3911 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
3912 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
3913 Py_DECREF(bo);
3914 }
3915 wxPyEndBlockThreads(blocked);
3916 }
3917
3918 SWIGINTERN wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
3919 return new wxCustomDataObject(wxDataFormat(formatName));
3920 }
3921 SWIGINTERN bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
3922 bool rval;
3923 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3924 if (PyString_Check(data)) {
3925 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3926 }
3927 else {
3928 // raise a TypeError if not a string
3929 PyErr_SetString(PyExc_TypeError, "String expected.");
3930 rval = false;
3931 }
3932 wxPyEndBlockThreads(blocked);
3933 return rval;
3934 }
3935 SWIGINTERN PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
3936 PyObject* obj;
3937 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3938 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
3939 wxPyEndBlockThreads(blocked);
3940 return obj;
3941 }
3942
3943 class wxMetafileDataObject : public wxDataObjectSimple
3944 {
3945 public:
3946 wxMetafileDataObject() { wxPyRaiseNotImplemented(); }
3947 };
3948
3949
3950 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
3951
3952
3953 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
3954 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
3955 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
3956 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
3957 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
3958
3959
3960 class wxPyTextDropTarget : public wxTextDropTarget {
3961 public:
3962 wxPyTextDropTarget() {}
3963
3964 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
3965
3966 DEC_PYCALLBACK__(OnLeave);
3967 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3968 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3969 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3970 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3971
3972 PYPRIVATE;
3973 };
3974
3975 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
3976 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
3977 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
3978 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
3979 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
3980 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
3981
3982
3983
3984 class wxPyFileDropTarget : public wxFileDropTarget {
3985 public:
3986 wxPyFileDropTarget() {}
3987
3988 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
3989
3990 DEC_PYCALLBACK__(OnLeave);
3991 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3992 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3993 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3994 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3995
3996 PYPRIVATE;
3997 };
3998
3999 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
4000 const wxArrayString& filenames) {
4001 bool rval = false;
4002 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4003 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
4004 PyObject* list = wxArrayString2PyList_helper(filenames);
4005 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
4006 Py_DECREF(list);
4007 }
4008 wxPyEndBlockThreads(blocked);
4009 return rval;
4010 }
4011
4012
4013
4014 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
4015 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
4016 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
4017 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
4018 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
4019
4020
4021
4022
4023 SWIGINTERN bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
4024
4025 #include <wx/display.h>
4026 #include <wx/vidmode.h>
4027
4028 SWIGINTERN bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
4029 SWIGINTERN bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
4030
4031 #if !wxUSE_DISPLAY
4032 const wxVideoMode wxDefaultVideoMode;
4033 #endif
4034
4035 SWIGINTERN PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4036 #if wxUSE_DISPLAY
4037 PyObject* pyList = NULL;
4038 wxArrayVideoModes arr = self->GetModes(mode);
4039 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4040 pyList = PyList_New(0);
4041 for (size_t i=0; i < arr.GetCount(); i++)
4042 {
4043 wxVideoMode* m = new wxVideoMode(arr.Item(i));
4044 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
4045 PyList_Append(pyList, pyObj);
4046 Py_DECREF(pyObj);
4047 }
4048 wxPyEndBlockThreads(blocked);
4049 return pyList;
4050 #else
4051 wxPyRaiseNotImplemented();
4052 return NULL;
4053 #endif
4054 }
4055 SWIGINTERN wxVideoMode wxDisplay_GetCurrentMode(wxDisplay const *self){
4056 #if wxUSE_DISPLAY
4057 return self->GetCurrentMode();
4058 #else
4059 wxPyRaiseNotImplemented();
4060 return wxDefaultVideoMode;
4061 #endif
4062 }
4063 SWIGINTERN bool wxDisplay_ChangeMode(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4064 #if wxUSE_DISPLAY
4065 return self->ChangeMode(mode);
4066 #else
4067 wxPyRaiseNotImplemented();
4068 return false;
4069 #endif
4070 }
4071 SWIGINTERN void wxDisplay_ResetMode(wxDisplay *self){
4072 #if wxUSE_DISPLAY
4073 self->ResetMode();
4074 #else
4075 wxPyRaiseNotImplemented();
4076 #endif
4077 }
4078
4079 #include <wx/stdpaths.h>
4080
4081 SWIGINTERN wxStandardPaths *wxStandardPaths_Get(){
4082 return (wxStandardPaths*) &wxStandardPaths::Get();
4083 }
4084
4085 #ifndef wxHAS_POWER_EVENTS
4086 // Dummy class and other definitions for platforms that don't have them
4087
4088 // See wxPython_int.h for wxPowerEvent
4089
4090 enum {
4091 wxEVT_POWER_SUSPENDING,
4092 wxEVT_POWER_SUSPENDED,
4093 wxEVT_POWER_SUSPEND_CANCEL,
4094 wxEVT_POWER_RESUME,
4095 };
4096
4097 wxPowerType wxGetPowerType() { return wxPOWER_UNKNOWN; }
4098 wxBatteryState wxGetBatteryState() { return wxBATTERY_UNKNOWN_STATE; }
4099
4100 #endif
4101
4102
4103 #include <wx/aboutdlg.h>
4104
4105 #ifdef __cplusplus
4106 extern "C" {
4107 #endif
4108 SWIGINTERN PyObject *_wrap_SystemSettings_GetColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4109 PyObject *resultobj = 0;
4110 wxSystemColour arg1 ;
4111 wxColour result;
4112 int val1 ;
4113 int ecode1 = 0 ;
4114 PyObject * obj0 = 0 ;
4115 char * kwnames[] = {
4116 (char *) "index", NULL
4117 };
4118
4119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) SWIG_fail;
4120 ecode1 = SWIG_AsVal_int(obj0, &val1);
4121 if (!SWIG_IsOK(ecode1)) {
4122 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetColour" "', expected argument " "1"" of type '" "wxSystemColour""'");
4123 }
4124 arg1 = static_cast< wxSystemColour >(val1);
4125 {
4126 if (!wxPyCheckForApp()) SWIG_fail;
4127 PyThreadState* __tstate = wxPyBeginAllowThreads();
4128 result = wxSystemSettings::GetColour(arg1);
4129 wxPyEndAllowThreads(__tstate);
4130 if (PyErr_Occurred()) SWIG_fail;
4131 }
4132 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
4133 return resultobj;
4134 fail:
4135 return NULL;
4136 }
4137
4138
4139 SWIGINTERN PyObject *_wrap_SystemSettings_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4140 PyObject *resultobj = 0;
4141 wxSystemFont arg1 ;
4142 wxFont result;
4143 int val1 ;
4144 int ecode1 = 0 ;
4145 PyObject * obj0 = 0 ;
4146 char * kwnames[] = {
4147 (char *) "index", NULL
4148 };
4149
4150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) SWIG_fail;
4151 ecode1 = SWIG_AsVal_int(obj0, &val1);
4152 if (!SWIG_IsOK(ecode1)) {
4153 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetFont" "', expected argument " "1"" of type '" "wxSystemFont""'");
4154 }
4155 arg1 = static_cast< wxSystemFont >(val1);
4156 {
4157 if (!wxPyCheckForApp()) SWIG_fail;
4158 PyThreadState* __tstate = wxPyBeginAllowThreads();
4159 result = wxSystemSettings::GetFont(arg1);
4160 wxPyEndAllowThreads(__tstate);
4161 if (PyErr_Occurred()) SWIG_fail;
4162 }
4163 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
4164 return resultobj;
4165 fail:
4166 return NULL;
4167 }
4168
4169
4170 SWIGINTERN PyObject *_wrap_SystemSettings_GetMetric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4171 PyObject *resultobj = 0;
4172 wxSystemMetric arg1 ;
4173 wxWindow *arg2 = (wxWindow *) NULL ;
4174 int result;
4175 int val1 ;
4176 int ecode1 = 0 ;
4177 void *argp2 = 0 ;
4178 int res2 = 0 ;
4179 PyObject * obj0 = 0 ;
4180 PyObject * obj1 = 0 ;
4181 char * kwnames[] = {
4182 (char *) "index",(char *) "win", NULL
4183 };
4184
4185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SystemSettings_GetMetric",kwnames,&obj0,&obj1)) SWIG_fail;
4186 ecode1 = SWIG_AsVal_int(obj0, &val1);
4187 if (!SWIG_IsOK(ecode1)) {
4188 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetMetric" "', expected argument " "1"" of type '" "wxSystemMetric""'");
4189 }
4190 arg1 = static_cast< wxSystemMetric >(val1);
4191 if (obj1) {
4192 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
4193 if (!SWIG_IsOK(res2)) {
4194 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SystemSettings_GetMetric" "', expected argument " "2"" of type '" "wxWindow *""'");
4195 }
4196 arg2 = reinterpret_cast< wxWindow * >(argp2);
4197 }
4198 {
4199 if (!wxPyCheckForApp()) SWIG_fail;
4200 PyThreadState* __tstate = wxPyBeginAllowThreads();
4201 result = (int)wxSystemSettings::GetMetric(arg1,arg2);
4202 wxPyEndAllowThreads(__tstate);
4203 if (PyErr_Occurred()) SWIG_fail;
4204 }
4205 resultobj = SWIG_From_int(static_cast< int >(result));
4206 return resultobj;
4207 fail:
4208 return NULL;
4209 }
4210
4211
4212 SWIGINTERN PyObject *_wrap_SystemSettings_HasFeature(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4213 PyObject *resultobj = 0;
4214 wxSystemFeature arg1 ;
4215 bool result;
4216 int val1 ;
4217 int ecode1 = 0 ;
4218 PyObject * obj0 = 0 ;
4219 char * kwnames[] = {
4220 (char *) "index", NULL
4221 };
4222
4223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) SWIG_fail;
4224 ecode1 = SWIG_AsVal_int(obj0, &val1);
4225 if (!SWIG_IsOK(ecode1)) {
4226 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_HasFeature" "', expected argument " "1"" of type '" "wxSystemFeature""'");
4227 }
4228 arg1 = static_cast< wxSystemFeature >(val1);
4229 {
4230 if (!wxPyCheckForApp()) SWIG_fail;
4231 PyThreadState* __tstate = wxPyBeginAllowThreads();
4232 result = (bool)wxSystemSettings::HasFeature(arg1);
4233 wxPyEndAllowThreads(__tstate);
4234 if (PyErr_Occurred()) SWIG_fail;
4235 }
4236 {
4237 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4238 }
4239 return resultobj;
4240 fail:
4241 return NULL;
4242 }
4243
4244
4245 SWIGINTERN PyObject *_wrap_SystemSettings_GetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4246 PyObject *resultobj = 0;
4247 wxSystemScreenType result;
4248
4249 if (!SWIG_Python_UnpackTuple(args,"SystemSettings_GetScreenType",0,0,0)) SWIG_fail;
4250 {
4251 if (!wxPyCheckForApp()) SWIG_fail;
4252 PyThreadState* __tstate = wxPyBeginAllowThreads();
4253 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
4254 wxPyEndAllowThreads(__tstate);
4255 if (PyErr_Occurred()) SWIG_fail;
4256 }
4257 resultobj = SWIG_From_int(static_cast< int >(result));
4258 return resultobj;
4259 fail:
4260 return NULL;
4261 }
4262
4263
4264 SWIGINTERN PyObject *_wrap_SystemSettings_SetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4265 PyObject *resultobj = 0;
4266 wxSystemScreenType arg1 ;
4267 int val1 ;
4268 int ecode1 = 0 ;
4269 PyObject * obj0 = 0 ;
4270 char * kwnames[] = {
4271 (char *) "screen", NULL
4272 };
4273
4274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) SWIG_fail;
4275 ecode1 = SWIG_AsVal_int(obj0, &val1);
4276 if (!SWIG_IsOK(ecode1)) {
4277 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_SetScreenType" "', expected argument " "1"" of type '" "wxSystemScreenType""'");
4278 }
4279 arg1 = static_cast< wxSystemScreenType >(val1);
4280 {
4281 if (!wxPyCheckForApp()) SWIG_fail;
4282 PyThreadState* __tstate = wxPyBeginAllowThreads();
4283 wxSystemSettings::SetScreenType(arg1);
4284 wxPyEndAllowThreads(__tstate);
4285 if (PyErr_Occurred()) SWIG_fail;
4286 }
4287 resultobj = SWIG_Py_Void();
4288 return resultobj;
4289 fail:
4290 return NULL;
4291 }
4292
4293
4294 SWIGINTERN PyObject *SystemSettings_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4295 PyObject *obj;
4296 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4297 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemSettings, SWIG_NewClientData(obj));
4298 return SWIG_Py_Void();
4299 }
4300
4301 SWIGINTERN int WINDOW_DEFAULT_VARIANT_set(PyObject *) {
4302 SWIG_Error(SWIG_AttributeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
4303 return 1;
4304 }
4305
4306
4307 SWIGINTERN PyObject *WINDOW_DEFAULT_VARIANT_get(void) {
4308 PyObject *pyobj = 0;
4309
4310 {
4311 #if wxUSE_UNICODE
4312 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4313 #else
4314 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4315 #endif
4316 }
4317 return pyobj;
4318 }
4319
4320
4321 SWIGINTERN PyObject *_wrap_new_SystemOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4322 PyObject *resultobj = 0;
4323 wxSystemOptions *result = 0 ;
4324
4325 if (!SWIG_Python_UnpackTuple(args,"new_SystemOptions",0,0,0)) SWIG_fail;
4326 {
4327 PyThreadState* __tstate = wxPyBeginAllowThreads();
4328 result = (wxSystemOptions *)new wxSystemOptions();
4329 wxPyEndAllowThreads(__tstate);
4330 if (PyErr_Occurred()) SWIG_fail;
4331 }
4332 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSystemOptions, SWIG_POINTER_NEW | 0 );
4333 return resultobj;
4334 fail:
4335 return NULL;
4336 }
4337
4338
4339 SWIGINTERN PyObject *_wrap_SystemOptions_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4340 PyObject *resultobj = 0;
4341 wxString *arg1 = 0 ;
4342 wxString *arg2 = 0 ;
4343 bool temp1 = false ;
4344 bool temp2 = false ;
4345 PyObject * obj0 = 0 ;
4346 PyObject * obj1 = 0 ;
4347 char * kwnames[] = {
4348 (char *) "name",(char *) "value", NULL
4349 };
4350
4351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) SWIG_fail;
4352 {
4353 arg1 = wxString_in_helper(obj0);
4354 if (arg1 == NULL) SWIG_fail;
4355 temp1 = true;
4356 }
4357 {
4358 arg2 = wxString_in_helper(obj1);
4359 if (arg2 == NULL) SWIG_fail;
4360 temp2 = true;
4361 }
4362 {
4363 PyThreadState* __tstate = wxPyBeginAllowThreads();
4364 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
4365 wxPyEndAllowThreads(__tstate);
4366 if (PyErr_Occurred()) SWIG_fail;
4367 }
4368 resultobj = SWIG_Py_Void();
4369 {
4370 if (temp1)
4371 delete arg1;
4372 }
4373 {
4374 if (temp2)
4375 delete arg2;
4376 }
4377 return resultobj;
4378 fail:
4379 {
4380 if (temp1)
4381 delete arg1;
4382 }
4383 {
4384 if (temp2)
4385 delete arg2;
4386 }
4387 return NULL;
4388 }
4389
4390
4391 SWIGINTERN PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4392 PyObject *resultobj = 0;
4393 wxString *arg1 = 0 ;
4394 int arg2 ;
4395 bool temp1 = false ;
4396 int val2 ;
4397 int ecode2 = 0 ;
4398 PyObject * obj0 = 0 ;
4399 PyObject * obj1 = 0 ;
4400 char * kwnames[] = {
4401 (char *) "name",(char *) "value", NULL
4402 };
4403
4404 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
4405 {
4406 arg1 = wxString_in_helper(obj0);
4407 if (arg1 == NULL) SWIG_fail;
4408 temp1 = true;
4409 }
4410 ecode2 = SWIG_AsVal_int(obj1, &val2);
4411 if (!SWIG_IsOK(ecode2)) {
4412 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SystemOptions_SetOptionInt" "', expected argument " "2"" of type '" "int""'");
4413 }
4414 arg2 = static_cast< int >(val2);
4415 {
4416 PyThreadState* __tstate = wxPyBeginAllowThreads();
4417 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
4418 wxPyEndAllowThreads(__tstate);
4419 if (PyErr_Occurred()) SWIG_fail;
4420 }
4421 resultobj = SWIG_Py_Void();
4422 {
4423 if (temp1)
4424 delete arg1;
4425 }
4426 return resultobj;
4427 fail:
4428 {
4429 if (temp1)
4430 delete arg1;
4431 }
4432 return NULL;
4433 }
4434
4435
4436 SWIGINTERN PyObject *_wrap_SystemOptions_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4437 PyObject *resultobj = 0;
4438 wxString *arg1 = 0 ;
4439 wxString result;
4440 bool temp1 = false ;
4441 PyObject * obj0 = 0 ;
4442 char * kwnames[] = {
4443 (char *) "name", NULL
4444 };
4445
4446 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) SWIG_fail;
4447 {
4448 arg1 = wxString_in_helper(obj0);
4449 if (arg1 == NULL) SWIG_fail;
4450 temp1 = true;
4451 }
4452 {
4453 PyThreadState* __tstate = wxPyBeginAllowThreads();
4454 result = wxSystemOptions::GetOption((wxString const &)*arg1);
4455 wxPyEndAllowThreads(__tstate);
4456 if (PyErr_Occurred()) SWIG_fail;
4457 }
4458 {
4459 #if wxUSE_UNICODE
4460 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4461 #else
4462 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4463 #endif
4464 }
4465 {
4466 if (temp1)
4467 delete arg1;
4468 }
4469 return resultobj;
4470 fail:
4471 {
4472 if (temp1)
4473 delete arg1;
4474 }
4475 return NULL;
4476 }
4477
4478
4479 SWIGINTERN PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4480 PyObject *resultobj = 0;
4481 wxString *arg1 = 0 ;
4482 int result;
4483 bool temp1 = false ;
4484 PyObject * obj0 = 0 ;
4485 char * kwnames[] = {
4486 (char *) "name", NULL
4487 };
4488
4489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) SWIG_fail;
4490 {
4491 arg1 = wxString_in_helper(obj0);
4492 if (arg1 == NULL) SWIG_fail;
4493 temp1 = true;
4494 }
4495 {
4496 PyThreadState* __tstate = wxPyBeginAllowThreads();
4497 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
4498 wxPyEndAllowThreads(__tstate);
4499 if (PyErr_Occurred()) SWIG_fail;
4500 }
4501 resultobj = SWIG_From_int(static_cast< int >(result));
4502 {
4503 if (temp1)
4504 delete arg1;
4505 }
4506 return resultobj;
4507 fail:
4508 {
4509 if (temp1)
4510 delete arg1;
4511 }
4512 return NULL;
4513 }
4514
4515
4516 SWIGINTERN PyObject *_wrap_SystemOptions_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4517 PyObject *resultobj = 0;
4518 wxString *arg1 = 0 ;
4519 bool result;
4520 bool temp1 = false ;
4521 PyObject * obj0 = 0 ;
4522 char * kwnames[] = {
4523 (char *) "name", NULL
4524 };
4525
4526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) SWIG_fail;
4527 {
4528 arg1 = wxString_in_helper(obj0);
4529 if (arg1 == NULL) SWIG_fail;
4530 temp1 = true;
4531 }
4532 {
4533 PyThreadState* __tstate = wxPyBeginAllowThreads();
4534 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
4535 wxPyEndAllowThreads(__tstate);
4536 if (PyErr_Occurred()) SWIG_fail;
4537 }
4538 {
4539 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4540 }
4541 {
4542 if (temp1)
4543 delete arg1;
4544 }
4545 return resultobj;
4546 fail:
4547 {
4548 if (temp1)
4549 delete arg1;
4550 }
4551 return NULL;
4552 }
4553
4554
4555 SWIGINTERN PyObject *_wrap_SystemOptions_IsFalse(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4556 PyObject *resultobj = 0;
4557 wxString *arg1 = 0 ;
4558 bool result;
4559 bool temp1 = false ;
4560 PyObject * obj0 = 0 ;
4561 char * kwnames[] = {
4562 (char *) "name", NULL
4563 };
4564
4565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_IsFalse",kwnames,&obj0)) SWIG_fail;
4566 {
4567 arg1 = wxString_in_helper(obj0);
4568 if (arg1 == NULL) SWIG_fail;
4569 temp1 = true;
4570 }
4571 {
4572 PyThreadState* __tstate = wxPyBeginAllowThreads();
4573 result = (bool)wxSystemOptions::IsFalse((wxString const &)*arg1);
4574 wxPyEndAllowThreads(__tstate);
4575 if (PyErr_Occurred()) SWIG_fail;
4576 }
4577 {
4578 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4579 }
4580 {
4581 if (temp1)
4582 delete arg1;
4583 }
4584 return resultobj;
4585 fail:
4586 {
4587 if (temp1)
4588 delete arg1;
4589 }
4590 return NULL;
4591 }
4592
4593
4594 SWIGINTERN PyObject *SystemOptions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4595 PyObject *obj;
4596 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4597 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemOptions, SWIG_NewClientData(obj));
4598 return SWIG_Py_Void();
4599 }
4600
4601 SWIGINTERN PyObject *SystemOptions_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4602 return SWIG_Python_InitShadowInstance(args);
4603 }
4604
4605 SWIGINTERN int FileSelectorPromptStr_set(PyObject *) {
4606 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorPromptStr is read-only.");
4607 return 1;
4608 }
4609
4610
4611 SWIGINTERN PyObject *FileSelectorPromptStr_get(void) {
4612 PyObject *pyobj = 0;
4613
4614 {
4615 #if wxUSE_UNICODE
4616 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4617 #else
4618 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4619 #endif
4620 }
4621 return pyobj;
4622 }
4623
4624
4625 SWIGINTERN int FileSelectorDefaultWildcardStr_set(PyObject *) {
4626 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
4627 return 1;
4628 }
4629
4630
4631 SWIGINTERN PyObject *FileSelectorDefaultWildcardStr_get(void) {
4632 PyObject *pyobj = 0;
4633
4634 {
4635 #if wxUSE_UNICODE
4636 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4637 #else
4638 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4639 #endif
4640 }
4641 return pyobj;
4642 }
4643
4644
4645 SWIGINTERN int DirSelectorPromptStr_set(PyObject *) {
4646 SWIG_Error(SWIG_AttributeError,"Variable DirSelectorPromptStr is read-only.");
4647 return 1;
4648 }
4649
4650
4651 SWIGINTERN PyObject *DirSelectorPromptStr_get(void) {
4652 PyObject *pyobj = 0;
4653
4654 {
4655 #if wxUSE_UNICODE
4656 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4657 #else
4658 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4659 #endif
4660 }
4661 return pyobj;
4662 }
4663
4664
4665 SWIGINTERN PyObject *_wrap_NewId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4666 PyObject *resultobj = 0;
4667 long result;
4668
4669 if (!SWIG_Python_UnpackTuple(args,"NewId",0,0,0)) SWIG_fail;
4670 {
4671 PyThreadState* __tstate = wxPyBeginAllowThreads();
4672 result = (long)wxNewId();
4673 wxPyEndAllowThreads(__tstate);
4674 if (PyErr_Occurred()) SWIG_fail;
4675 }
4676 resultobj = SWIG_From_long(static_cast< long >(result));
4677 return resultobj;
4678 fail:
4679 return NULL;
4680 }
4681
4682
4683 SWIGINTERN PyObject *_wrap_RegisterId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4684 PyObject *resultobj = 0;
4685 long arg1 ;
4686 long val1 ;
4687 int ecode1 = 0 ;
4688 PyObject * obj0 = 0 ;
4689 char * kwnames[] = {
4690 (char *) "id", NULL
4691 };
4692
4693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) SWIG_fail;
4694 ecode1 = SWIG_AsVal_long(obj0, &val1);
4695 if (!SWIG_IsOK(ecode1)) {
4696 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "RegisterId" "', expected argument " "1"" of type '" "long""'");
4697 }
4698 arg1 = static_cast< long >(val1);
4699 {
4700 PyThreadState* __tstate = wxPyBeginAllowThreads();
4701 wxRegisterId(arg1);
4702 wxPyEndAllowThreads(__tstate);
4703 if (PyErr_Occurred()) SWIG_fail;
4704 }
4705 resultobj = SWIG_Py_Void();
4706 return resultobj;
4707 fail:
4708 return NULL;
4709 }
4710
4711
4712 SWIGINTERN PyObject *_wrap_GetCurrentId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4713 PyObject *resultobj = 0;
4714 long result;
4715
4716 if (!SWIG_Python_UnpackTuple(args,"GetCurrentId",0,0,0)) SWIG_fail;
4717 {
4718 PyThreadState* __tstate = wxPyBeginAllowThreads();
4719 result = (long)wxGetCurrentId();
4720 wxPyEndAllowThreads(__tstate);
4721 if (PyErr_Occurred()) SWIG_fail;
4722 }
4723 resultobj = SWIG_From_long(static_cast< long >(result));
4724 return resultobj;
4725 fail:
4726 return NULL;
4727 }
4728
4729
4730 SWIGINTERN PyObject *_wrap_IsStockID(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4731 PyObject *resultobj = 0;
4732 int arg1 ;
4733 bool result;
4734 int val1 ;
4735 int ecode1 = 0 ;
4736 PyObject * obj0 = 0 ;
4737 char * kwnames[] = {
4738 (char *) "id", NULL
4739 };
4740
4741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) SWIG_fail;
4742 ecode1 = SWIG_AsVal_int(obj0, &val1);
4743 if (!SWIG_IsOK(ecode1)) {
4744 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockID" "', expected argument " "1"" of type '" "int""'");
4745 }
4746 arg1 = static_cast< int >(val1);
4747 {
4748 PyThreadState* __tstate = wxPyBeginAllowThreads();
4749 result = (bool)wxIsStockID(arg1);
4750 wxPyEndAllowThreads(__tstate);
4751 if (PyErr_Occurred()) SWIG_fail;
4752 }
4753 {
4754 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4755 }
4756 return resultobj;
4757 fail:
4758 return NULL;
4759 }
4760
4761
4762 SWIGINTERN PyObject *_wrap_IsStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4763 PyObject *resultobj = 0;
4764 int arg1 ;
4765 wxString *arg2 = 0 ;
4766 bool result;
4767 int val1 ;
4768 int ecode1 = 0 ;
4769 bool temp2 = false ;
4770 PyObject * obj0 = 0 ;
4771 PyObject * obj1 = 0 ;
4772 char * kwnames[] = {
4773 (char *) "id",(char *) "label", NULL
4774 };
4775
4776 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) SWIG_fail;
4777 ecode1 = SWIG_AsVal_int(obj0, &val1);
4778 if (!SWIG_IsOK(ecode1)) {
4779 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockLabel" "', expected argument " "1"" of type '" "int""'");
4780 }
4781 arg1 = static_cast< int >(val1);
4782 {
4783 arg2 = wxString_in_helper(obj1);
4784 if (arg2 == NULL) SWIG_fail;
4785 temp2 = true;
4786 }
4787 {
4788 PyThreadState* __tstate = wxPyBeginAllowThreads();
4789 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
4790 wxPyEndAllowThreads(__tstate);
4791 if (PyErr_Occurred()) SWIG_fail;
4792 }
4793 {
4794 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4795 }
4796 {
4797 if (temp2)
4798 delete arg2;
4799 }
4800 return resultobj;
4801 fail:
4802 {
4803 if (temp2)
4804 delete arg2;
4805 }
4806 return NULL;
4807 }
4808
4809
4810 SWIGINTERN PyObject *_wrap_GetStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4811 PyObject *resultobj = 0;
4812 int arg1 ;
4813 long arg2 = (long) wxSTOCK_WITH_MNEMONIC ;
4814 wxString result;
4815 int val1 ;
4816 int ecode1 = 0 ;
4817 long val2 ;
4818 int ecode2 = 0 ;
4819 PyObject * obj0 = 0 ;
4820 PyObject * obj1 = 0 ;
4821 char * kwnames[] = {
4822 (char *) "id",(char *) "flags", NULL
4823 };
4824
4825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GetStockLabel",kwnames,&obj0,&obj1)) SWIG_fail;
4826 ecode1 = SWIG_AsVal_int(obj0, &val1);
4827 if (!SWIG_IsOK(ecode1)) {
4828 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetStockLabel" "', expected argument " "1"" of type '" "int""'");
4829 }
4830 arg1 = static_cast< int >(val1);
4831 if (obj1) {
4832 ecode2 = SWIG_AsVal_long(obj1, &val2);
4833 if (!SWIG_IsOK(ecode2)) {
4834 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetStockLabel" "', expected argument " "2"" of type '" "long""'");
4835 }
4836 arg2 = static_cast< long >(val2);
4837 }
4838 {
4839 PyThreadState* __tstate = wxPyBeginAllowThreads();
4840 result = wxGetStockLabel(arg1,arg2);
4841 wxPyEndAllowThreads(__tstate);
4842 if (PyErr_Occurred()) SWIG_fail;
4843 }
4844 {
4845 #if wxUSE_UNICODE
4846 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4847 #else
4848 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4849 #endif
4850 }
4851 return resultobj;
4852 fail:
4853 return NULL;
4854 }
4855
4856
4857 SWIGINTERN PyObject *_wrap_GetStockHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4858 PyObject *resultobj = 0;
4859 int arg1 ;
4860 wxStockHelpStringClient arg2 = (wxStockHelpStringClient) wxSTOCK_MENU ;
4861 wxString result;
4862 int val1 ;
4863 int ecode1 = 0 ;
4864 int val2 ;
4865 int ecode2 = 0 ;
4866 PyObject * obj0 = 0 ;
4867 PyObject * obj1 = 0 ;
4868 char * kwnames[] = {
4869 (char *) "id",(char *) "client", NULL
4870 };
4871
4872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GetStockHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
4873 ecode1 = SWIG_AsVal_int(obj0, &val1);
4874 if (!SWIG_IsOK(ecode1)) {
4875 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetStockHelpString" "', expected argument " "1"" of type '" "int""'");
4876 }
4877 arg1 = static_cast< int >(val1);
4878 if (obj1) {
4879 ecode2 = SWIG_AsVal_int(obj1, &val2);
4880 if (!SWIG_IsOK(ecode2)) {
4881 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetStockHelpString" "', expected argument " "2"" of type '" "wxStockHelpStringClient""'");
4882 }
4883 arg2 = static_cast< wxStockHelpStringClient >(val2);
4884 }
4885 {
4886 PyThreadState* __tstate = wxPyBeginAllowThreads();
4887 result = wxGetStockHelpString(arg1,arg2);
4888 wxPyEndAllowThreads(__tstate);
4889 if (PyErr_Occurred()) SWIG_fail;
4890 }
4891 {
4892 #if wxUSE_UNICODE
4893 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4894 #else
4895 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4896 #endif
4897 }
4898 return resultobj;
4899 fail:
4900 return NULL;
4901 }
4902
4903
4904 SWIGINTERN PyObject *_wrap_Bell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4905 PyObject *resultobj = 0;
4906
4907 if (!SWIG_Python_UnpackTuple(args,"Bell",0,0,0)) SWIG_fail;
4908 {
4909 if (!wxPyCheckForApp()) SWIG_fail;
4910 PyThreadState* __tstate = wxPyBeginAllowThreads();
4911 wxBell();
4912 wxPyEndAllowThreads(__tstate);
4913 if (PyErr_Occurred()) SWIG_fail;
4914 }
4915 resultobj = SWIG_Py_Void();
4916 return resultobj;
4917 fail:
4918 return NULL;
4919 }
4920
4921
4922 SWIGINTERN PyObject *_wrap_EndBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4923 PyObject *resultobj = 0;
4924
4925 if (!SWIG_Python_UnpackTuple(args,"EndBusyCursor",0,0,0)) SWIG_fail;
4926 {
4927 if (!wxPyCheckForApp()) SWIG_fail;
4928 PyThreadState* __tstate = wxPyBeginAllowThreads();
4929 wxEndBusyCursor();
4930 wxPyEndAllowThreads(__tstate);
4931 if (PyErr_Occurred()) SWIG_fail;
4932 }
4933 resultobj = SWIG_Py_Void();
4934 return resultobj;
4935 fail:
4936 return NULL;
4937 }
4938
4939
4940 SWIGINTERN PyObject *_wrap_GetElapsedTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4941 PyObject *resultobj = 0;
4942 bool arg1 = (bool) true ;
4943 long result;
4944 bool val1 ;
4945 int ecode1 = 0 ;
4946 PyObject * obj0 = 0 ;
4947 char * kwnames[] = {
4948 (char *) "resetTimer", NULL
4949 };
4950
4951 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) SWIG_fail;
4952 if (obj0) {
4953 ecode1 = SWIG_AsVal_bool(obj0, &val1);
4954 if (!SWIG_IsOK(ecode1)) {
4955 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetElapsedTime" "', expected argument " "1"" of type '" "bool""'");
4956 }
4957 arg1 = static_cast< bool >(val1);
4958 }
4959 {
4960 PyThreadState* __tstate = wxPyBeginAllowThreads();
4961 result = (long)wxGetElapsedTime(arg1);
4962 wxPyEndAllowThreads(__tstate);
4963 if (PyErr_Occurred()) SWIG_fail;
4964 }
4965 resultobj = SWIG_From_long(static_cast< long >(result));
4966 return resultobj;
4967 fail:
4968 return NULL;
4969 }
4970
4971
4972 SWIGINTERN PyObject *_wrap_IsBusy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4973 PyObject *resultobj = 0;
4974 bool result;
4975
4976 if (!SWIG_Python_UnpackTuple(args,"IsBusy",0,0,0)) SWIG_fail;
4977 {
4978 PyThreadState* __tstate = wxPyBeginAllowThreads();
4979 result = (bool)wxIsBusy();
4980 wxPyEndAllowThreads(__tstate);
4981 if (PyErr_Occurred()) SWIG_fail;
4982 }
4983 {
4984 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4985 }
4986 return resultobj;
4987 fail:
4988 return NULL;
4989 }
4990
4991
4992 SWIGINTERN PyObject *_wrap_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4993 PyObject *resultobj = 0;
4994 wxString result;
4995
4996 if (!SWIG_Python_UnpackTuple(args,"Now",0,0,0)) SWIG_fail;
4997 {
4998 PyThreadState* __tstate = wxPyBeginAllowThreads();
4999 result = wxNow();
5000 wxPyEndAllowThreads(__tstate);
5001 if (PyErr_Occurred()) SWIG_fail;
5002 }
5003 {
5004 #if wxUSE_UNICODE
5005 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5006 #else
5007 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5008 #endif
5009 }
5010 return resultobj;
5011 fail:
5012 return NULL;
5013 }
5014
5015
5016 SWIGINTERN PyObject *_wrap_Shell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5017 PyObject *resultobj = 0;
5018 wxString const &arg1_defvalue = wxPyEmptyString ;
5019 wxString *arg1 = (wxString *) &arg1_defvalue ;
5020 bool result;
5021 bool temp1 = false ;
5022 PyObject * obj0 = 0 ;
5023 char * kwnames[] = {
5024 (char *) "command", NULL
5025 };
5026
5027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) SWIG_fail;
5028 if (obj0) {
5029 {
5030 arg1 = wxString_in_helper(obj0);
5031 if (arg1 == NULL) SWIG_fail;
5032 temp1 = true;
5033 }
5034 }
5035 {
5036 PyThreadState* __tstate = wxPyBeginAllowThreads();
5037 result = (bool)wxShell((wxString const &)*arg1);
5038 wxPyEndAllowThreads(__tstate);
5039 if (PyErr_Occurred()) SWIG_fail;
5040 }
5041 {
5042 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5043 }
5044 {
5045 if (temp1)
5046 delete arg1;
5047 }
5048 return resultobj;
5049 fail:
5050 {
5051 if (temp1)
5052 delete arg1;
5053 }
5054 return NULL;
5055 }
5056
5057
5058 SWIGINTERN PyObject *_wrap_StartTimer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5059 PyObject *resultobj = 0;
5060
5061 if (!SWIG_Python_UnpackTuple(args,"StartTimer",0,0,0)) SWIG_fail;
5062 {
5063 PyThreadState* __tstate = wxPyBeginAllowThreads();
5064 wxStartTimer();
5065 wxPyEndAllowThreads(__tstate);
5066 if (PyErr_Occurred()) SWIG_fail;
5067 }
5068 resultobj = SWIG_Py_Void();
5069 return resultobj;
5070 fail:
5071 return NULL;
5072 }
5073
5074
5075 SWIGINTERN PyObject *_wrap_GetOsVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5076 PyObject *resultobj = 0;
5077 int *arg1 = (int *) 0 ;
5078 int *arg2 = (int *) 0 ;
5079 int result;
5080 int temp1 ;
5081 int res1 = SWIG_TMPOBJ ;
5082 int temp2 ;
5083 int res2 = SWIG_TMPOBJ ;
5084
5085 arg1 = &temp1;
5086 arg2 = &temp2;
5087 if (!SWIG_Python_UnpackTuple(args,"GetOsVersion",0,0,0)) SWIG_fail;
5088 {
5089 PyThreadState* __tstate = wxPyBeginAllowThreads();
5090 result = (int)wxGetOsVersion(arg1,arg2);
5091 wxPyEndAllowThreads(__tstate);
5092 if (PyErr_Occurred()) SWIG_fail;
5093 }
5094 resultobj = SWIG_From_int(static_cast< int >(result));
5095 if (SWIG_IsTmpObj(res1)) {
5096 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
5097 } else {
5098 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5099 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
5100 }
5101 if (SWIG_IsTmpObj(res2)) {
5102 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
5103 } else {
5104 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5105 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
5106 }
5107 return resultobj;
5108 fail:
5109 return NULL;
5110 }
5111
5112
5113 SWIGINTERN PyObject *_wrap_GetOsDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5114 PyObject *resultobj = 0;
5115 wxString result;
5116
5117 if (!SWIG_Python_UnpackTuple(args,"GetOsDescription",0,0,0)) SWIG_fail;
5118 {
5119 PyThreadState* __tstate = wxPyBeginAllowThreads();
5120 result = wxGetOsDescription();
5121 wxPyEndAllowThreads(__tstate);
5122 if (PyErr_Occurred()) SWIG_fail;
5123 }
5124 {
5125 #if wxUSE_UNICODE
5126 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5127 #else
5128 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5129 #endif
5130 }
5131 return resultobj;
5132 fail:
5133 return NULL;
5134 }
5135
5136
5137 SWIGINTERN PyObject *_wrap_IsPlatformLittleEndian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5138 PyObject *resultobj = 0;
5139 bool result;
5140
5141 if (!SWIG_Python_UnpackTuple(args,"IsPlatformLittleEndian",0,0,0)) SWIG_fail;
5142 {
5143 PyThreadState* __tstate = wxPyBeginAllowThreads();
5144 result = (bool)wxIsPlatformLittleEndian();
5145 wxPyEndAllowThreads(__tstate);
5146 if (PyErr_Occurred()) SWIG_fail;
5147 }
5148 {
5149 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5150 }
5151 return resultobj;
5152 fail:
5153 return NULL;
5154 }
5155
5156
5157 SWIGINTERN PyObject *_wrap_IsPlatform64Bit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5158 PyObject *resultobj = 0;
5159 bool result;
5160
5161 if (!SWIG_Python_UnpackTuple(args,"IsPlatform64Bit",0,0,0)) SWIG_fail;
5162 {
5163 PyThreadState* __tstate = wxPyBeginAllowThreads();
5164 result = (bool)wxIsPlatform64Bit();
5165 wxPyEndAllowThreads(__tstate);
5166 if (PyErr_Occurred()) SWIG_fail;
5167 }
5168 {
5169 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5170 }
5171 return resultobj;
5172 fail:
5173 return NULL;
5174 }
5175
5176
5177 SWIGINTERN PyObject *_wrap_GetFreeMemory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5178 PyObject *resultobj = 0;
5179 wxMemorySize result;
5180
5181 if (!SWIG_Python_UnpackTuple(args,"GetFreeMemory",0,0,0)) SWIG_fail;
5182 {
5183 PyThreadState* __tstate = wxPyBeginAllowThreads();
5184 result = wxGetFreeMemory();
5185 wxPyEndAllowThreads(__tstate);
5186 if (PyErr_Occurred()) SWIG_fail;
5187 }
5188 {
5189 #if wxUSE_LONGLONG
5190 resultobj = PyLong_FromLongLong((&result)->GetValue());
5191 #else
5192 resultobj = PyInt_FromLong(result);
5193 #endif
5194 }
5195 return resultobj;
5196 fail:
5197 return NULL;
5198 }
5199
5200
5201 SWIGINTERN PyObject *_wrap_Shutdown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5202 PyObject *resultobj = 0;
5203 wxShutdownFlags arg1 ;
5204 bool result;
5205 int val1 ;
5206 int ecode1 = 0 ;
5207 PyObject * obj0 = 0 ;
5208 char * kwnames[] = {
5209 (char *) "wFlags", NULL
5210 };
5211
5212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) SWIG_fail;
5213 ecode1 = SWIG_AsVal_int(obj0, &val1);
5214 if (!SWIG_IsOK(ecode1)) {
5215 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Shutdown" "', expected argument " "1"" of type '" "wxShutdownFlags""'");
5216 }
5217 arg1 = static_cast< wxShutdownFlags >(val1);
5218 {
5219 if (!wxPyCheckForApp()) SWIG_fail;
5220 PyThreadState* __tstate = wxPyBeginAllowThreads();
5221 result = (bool)wxShutdown(arg1);
5222 wxPyEndAllowThreads(__tstate);
5223 if (PyErr_Occurred()) SWIG_fail;
5224 }
5225 {
5226 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5227 }
5228 return resultobj;
5229 fail:
5230 return NULL;
5231 }
5232
5233
5234 SWIGINTERN PyObject *_wrap_Sleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5235 PyObject *resultobj = 0;
5236 int arg1 ;
5237 int val1 ;
5238 int ecode1 = 0 ;
5239 PyObject * obj0 = 0 ;
5240 char * kwnames[] = {
5241 (char *) "secs", NULL
5242 };
5243
5244 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) SWIG_fail;
5245 ecode1 = SWIG_AsVal_int(obj0, &val1);
5246 if (!SWIG_IsOK(ecode1)) {
5247 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Sleep" "', expected argument " "1"" of type '" "int""'");
5248 }
5249 arg1 = static_cast< int >(val1);
5250 {
5251 PyThreadState* __tstate = wxPyBeginAllowThreads();
5252 wxSleep(arg1);
5253 wxPyEndAllowThreads(__tstate);
5254 if (PyErr_Occurred()) SWIG_fail;
5255 }
5256 resultobj = SWIG_Py_Void();
5257 return resultobj;
5258 fail:
5259 return NULL;
5260 }
5261
5262
5263 SWIGINTERN PyObject *_wrap_MilliSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5264 PyObject *resultobj = 0;
5265 unsigned long arg1 ;
5266 unsigned long val1 ;
5267 int ecode1 = 0 ;
5268 PyObject * obj0 = 0 ;
5269 char * kwnames[] = {
5270 (char *) "milliseconds", NULL
5271 };
5272
5273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) SWIG_fail;
5274 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5275 if (!SWIG_IsOK(ecode1)) {
5276 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MilliSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5277 }
5278 arg1 = static_cast< unsigned long >(val1);
5279 {
5280 PyThreadState* __tstate = wxPyBeginAllowThreads();
5281 wxMilliSleep(arg1);
5282 wxPyEndAllowThreads(__tstate);
5283 if (PyErr_Occurred()) SWIG_fail;
5284 }
5285 resultobj = SWIG_Py_Void();
5286 return resultobj;
5287 fail:
5288 return NULL;
5289 }
5290
5291
5292 SWIGINTERN PyObject *_wrap_MicroSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5293 PyObject *resultobj = 0;
5294 unsigned long arg1 ;
5295 unsigned long val1 ;
5296 int ecode1 = 0 ;
5297 PyObject * obj0 = 0 ;
5298 char * kwnames[] = {
5299 (char *) "microseconds", NULL
5300 };
5301
5302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) SWIG_fail;
5303 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5304 if (!SWIG_IsOK(ecode1)) {
5305 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MicroSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5306 }
5307 arg1 = static_cast< unsigned long >(val1);
5308 {
5309 PyThreadState* __tstate = wxPyBeginAllowThreads();
5310 wxMicroSleep(arg1);
5311 wxPyEndAllowThreads(__tstate);
5312 if (PyErr_Occurred()) SWIG_fail;
5313 }
5314 resultobj = SWIG_Py_Void();
5315 return resultobj;
5316 fail:
5317 return NULL;
5318 }
5319
5320
5321 SWIGINTERN PyObject *_wrap_EnableTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5322 PyObject *resultobj = 0;
5323 bool arg1 ;
5324 bool val1 ;
5325 int ecode1 = 0 ;
5326 PyObject * obj0 = 0 ;
5327 char * kwnames[] = {
5328 (char *) "enable", NULL
5329 };
5330
5331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) SWIG_fail;
5332 ecode1 = SWIG_AsVal_bool(obj0, &val1);
5333 if (!SWIG_IsOK(ecode1)) {
5334 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "EnableTopLevelWindows" "', expected argument " "1"" of type '" "bool""'");
5335 }
5336 arg1 = static_cast< bool >(val1);
5337 {
5338 PyThreadState* __tstate = wxPyBeginAllowThreads();
5339 wxEnableTopLevelWindows(arg1);
5340 wxPyEndAllowThreads(__tstate);
5341 if (PyErr_Occurred()) SWIG_fail;
5342 }
5343 resultobj = SWIG_Py_Void();
5344 return resultobj;
5345 fail:
5346 return NULL;
5347 }
5348
5349
5350 SWIGINTERN PyObject *_wrap_StripMenuCodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5351 PyObject *resultobj = 0;
5352 wxString *arg1 = 0 ;
5353 wxString result;
5354 bool temp1 = false ;
5355 PyObject * obj0 = 0 ;
5356 char * kwnames[] = {
5357 (char *) "in", NULL
5358 };
5359
5360 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) SWIG_fail;
5361 {
5362 arg1 = wxString_in_helper(obj0);
5363 if (arg1 == NULL) SWIG_fail;
5364 temp1 = true;
5365 }
5366 {
5367 PyThreadState* __tstate = wxPyBeginAllowThreads();
5368 result = wxStripMenuCodes((wxString const &)*arg1);
5369 wxPyEndAllowThreads(__tstate);
5370 if (PyErr_Occurred()) SWIG_fail;
5371 }
5372 {
5373 #if wxUSE_UNICODE
5374 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5375 #else
5376 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5377 #endif
5378 }
5379 {
5380 if (temp1)
5381 delete arg1;
5382 }
5383 return resultobj;
5384 fail:
5385 {
5386 if (temp1)
5387 delete arg1;
5388 }
5389 return NULL;
5390 }
5391
5392
5393 SWIGINTERN PyObject *_wrap_GetEmailAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5394 PyObject *resultobj = 0;
5395 wxString result;
5396
5397 if (!SWIG_Python_UnpackTuple(args,"GetEmailAddress",0,0,0)) SWIG_fail;
5398 {
5399 PyThreadState* __tstate = wxPyBeginAllowThreads();
5400 result = wxGetEmailAddress();
5401 wxPyEndAllowThreads(__tstate);
5402 if (PyErr_Occurred()) SWIG_fail;
5403 }
5404 {
5405 #if wxUSE_UNICODE
5406 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5407 #else
5408 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5409 #endif
5410 }
5411 return resultobj;
5412 fail:
5413 return NULL;
5414 }
5415
5416
5417 SWIGINTERN PyObject *_wrap_GetHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5418 PyObject *resultobj = 0;
5419 wxString result;
5420
5421 if (!SWIG_Python_UnpackTuple(args,"GetHostName",0,0,0)) SWIG_fail;
5422 {
5423 PyThreadState* __tstate = wxPyBeginAllowThreads();
5424 result = wxGetHostName();
5425 wxPyEndAllowThreads(__tstate);
5426 if (PyErr_Occurred()) SWIG_fail;
5427 }
5428 {
5429 #if wxUSE_UNICODE
5430 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5431 #else
5432 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5433 #endif
5434 }
5435 return resultobj;
5436 fail:
5437 return NULL;
5438 }
5439
5440
5441 SWIGINTERN PyObject *_wrap_GetFullHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5442 PyObject *resultobj = 0;
5443 wxString result;
5444
5445 if (!SWIG_Python_UnpackTuple(args,"GetFullHostName",0,0,0)) SWIG_fail;
5446 {
5447 PyThreadState* __tstate = wxPyBeginAllowThreads();
5448 result = wxGetFullHostName();
5449 wxPyEndAllowThreads(__tstate);
5450 if (PyErr_Occurred()) SWIG_fail;
5451 }
5452 {
5453 #if wxUSE_UNICODE
5454 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5455 #else
5456 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5457 #endif
5458 }
5459 return resultobj;
5460 fail:
5461 return NULL;
5462 }
5463
5464
5465 SWIGINTERN PyObject *_wrap_GetUserId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5466 PyObject *resultobj = 0;
5467 wxString result;
5468
5469 if (!SWIG_Python_UnpackTuple(args,"GetUserId",0,0,0)) SWIG_fail;
5470 {
5471 PyThreadState* __tstate = wxPyBeginAllowThreads();
5472 result = wxGetUserId();
5473 wxPyEndAllowThreads(__tstate);
5474 if (PyErr_Occurred()) SWIG_fail;
5475 }
5476 {
5477 #if wxUSE_UNICODE
5478 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5479 #else
5480 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5481 #endif
5482 }
5483 return resultobj;
5484 fail:
5485 return NULL;
5486 }
5487
5488
5489 SWIGINTERN PyObject *_wrap_GetUserName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5490 PyObject *resultobj = 0;
5491 wxString result;
5492
5493 if (!SWIG_Python_UnpackTuple(args,"GetUserName",0,0,0)) SWIG_fail;
5494 {
5495 PyThreadState* __tstate = wxPyBeginAllowThreads();
5496 result = wxGetUserName();
5497 wxPyEndAllowThreads(__tstate);
5498 if (PyErr_Occurred()) SWIG_fail;
5499 }
5500 {
5501 #if wxUSE_UNICODE
5502 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5503 #else
5504 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5505 #endif
5506 }
5507 return resultobj;
5508 fail:
5509 return NULL;
5510 }
5511
5512
5513 SWIGINTERN PyObject *_wrap_GetHomeDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5514 PyObject *resultobj = 0;
5515 wxString result;
5516
5517 if (!SWIG_Python_UnpackTuple(args,"GetHomeDir",0,0,0)) SWIG_fail;
5518 {
5519 PyThreadState* __tstate = wxPyBeginAllowThreads();
5520 result = wxGetHomeDir();
5521 wxPyEndAllowThreads(__tstate);
5522 if (PyErr_Occurred()) SWIG_fail;
5523 }
5524 {
5525 #if wxUSE_UNICODE
5526 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5527 #else
5528 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5529 #endif
5530 }
5531 return resultobj;
5532 fail:
5533 return NULL;
5534 }
5535
5536
5537 SWIGINTERN PyObject *_wrap_GetUserHome(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5538 PyObject *resultobj = 0;
5539 wxString const &arg1_defvalue = wxPyEmptyString ;
5540 wxString *arg1 = (wxString *) &arg1_defvalue ;
5541 wxString result;
5542 bool temp1 = false ;
5543 PyObject * obj0 = 0 ;
5544 char * kwnames[] = {
5545 (char *) "user", NULL
5546 };
5547
5548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) SWIG_fail;
5549 if (obj0) {
5550 {
5551 arg1 = wxString_in_helper(obj0);
5552 if (arg1 == NULL) SWIG_fail;
5553 temp1 = true;
5554 }
5555 }
5556 {
5557 PyThreadState* __tstate = wxPyBeginAllowThreads();
5558 result = wxGetUserHome((wxString const &)*arg1);
5559 wxPyEndAllowThreads(__tstate);
5560 if (PyErr_Occurred()) SWIG_fail;
5561 }
5562 {
5563 #if wxUSE_UNICODE
5564 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5565 #else
5566 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5567 #endif
5568 }
5569 {
5570 if (temp1)
5571 delete arg1;
5572 }
5573 return resultobj;
5574 fail:
5575 {
5576 if (temp1)
5577 delete arg1;
5578 }
5579 return NULL;
5580 }
5581
5582
5583 SWIGINTERN PyObject *_wrap_GetProcessId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5584 PyObject *resultobj = 0;
5585 unsigned long result;
5586
5587 if (!SWIG_Python_UnpackTuple(args,"GetProcessId",0,0,0)) SWIG_fail;
5588 {
5589 PyThreadState* __tstate = wxPyBeginAllowThreads();
5590 result = (unsigned long)wxGetProcessId();
5591 wxPyEndAllowThreads(__tstate);
5592 if (PyErr_Occurred()) SWIG_fail;
5593 }
5594 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
5595 return resultobj;
5596 fail:
5597 return NULL;
5598 }
5599
5600
5601 SWIGINTERN PyObject *_wrap_Trap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5602 PyObject *resultobj = 0;
5603
5604 if (!SWIG_Python_UnpackTuple(args,"Trap",0,0,0)) SWIG_fail;
5605 {
5606 PyThreadState* __tstate = wxPyBeginAllowThreads();
5607 wxTrap();
5608 wxPyEndAllowThreads(__tstate);
5609 if (PyErr_Occurred()) SWIG_fail;
5610 }
5611 resultobj = SWIG_Py_Void();
5612 return resultobj;
5613 fail:
5614 return NULL;
5615 }
5616
5617
5618 SWIGINTERN PyObject *_wrap_FileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5619 PyObject *resultobj = 0;
5620 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
5621 wxString *arg1 = (wxString *) &arg1_defvalue ;
5622 wxString const &arg2_defvalue = wxPyEmptyString ;
5623 wxString *arg2 = (wxString *) &arg2_defvalue ;
5624 wxString const &arg3_defvalue = wxPyEmptyString ;
5625 wxString *arg3 = (wxString *) &arg3_defvalue ;
5626 wxString const &arg4_defvalue = wxPyEmptyString ;
5627 wxString *arg4 = (wxString *) &arg4_defvalue ;
5628 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
5629 wxString *arg5 = (wxString *) &arg5_defvalue ;
5630 int arg6 = (int) 0 ;
5631 wxWindow *arg7 = (wxWindow *) NULL ;
5632 int arg8 = (int) -1 ;
5633 int arg9 = (int) -1 ;
5634 wxString result;
5635 bool temp1 = false ;
5636 bool temp2 = false ;
5637 bool temp3 = false ;
5638 bool temp4 = false ;
5639 bool temp5 = false ;
5640 int val6 ;
5641 int ecode6 = 0 ;
5642 void *argp7 = 0 ;
5643 int res7 = 0 ;
5644 int val8 ;
5645 int ecode8 = 0 ;
5646 int val9 ;
5647 int ecode9 = 0 ;
5648 PyObject * obj0 = 0 ;
5649 PyObject * obj1 = 0 ;
5650 PyObject * obj2 = 0 ;
5651 PyObject * obj3 = 0 ;
5652 PyObject * obj4 = 0 ;
5653 PyObject * obj5 = 0 ;
5654 PyObject * obj6 = 0 ;
5655 PyObject * obj7 = 0 ;
5656 PyObject * obj8 = 0 ;
5657 char * kwnames[] = {
5658 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
5659 };
5660
5661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
5662 if (obj0) {
5663 {
5664 arg1 = wxString_in_helper(obj0);
5665 if (arg1 == NULL) SWIG_fail;
5666 temp1 = true;
5667 }
5668 }
5669 if (obj1) {
5670 {
5671 arg2 = wxString_in_helper(obj1);
5672 if (arg2 == NULL) SWIG_fail;
5673 temp2 = true;
5674 }
5675 }
5676 if (obj2) {
5677 {
5678 arg3 = wxString_in_helper(obj2);
5679 if (arg3 == NULL) SWIG_fail;
5680 temp3 = true;
5681 }
5682 }
5683 if (obj3) {
5684 {
5685 arg4 = wxString_in_helper(obj3);
5686 if (arg4 == NULL) SWIG_fail;
5687 temp4 = true;
5688 }
5689 }
5690 if (obj4) {
5691 {
5692 arg5 = wxString_in_helper(obj4);
5693 if (arg5 == NULL) SWIG_fail;
5694 temp5 = true;
5695 }
5696 }
5697 if (obj5) {
5698 ecode6 = SWIG_AsVal_int(obj5, &val6);
5699 if (!SWIG_IsOK(ecode6)) {
5700 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "FileSelector" "', expected argument " "6"" of type '" "int""'");
5701 }
5702 arg6 = static_cast< int >(val6);
5703 }
5704 if (obj6) {
5705 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_wxWindow, 0 | 0 );
5706 if (!SWIG_IsOK(res7)) {
5707 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "FileSelector" "', expected argument " "7"" of type '" "wxWindow *""'");
5708 }
5709 arg7 = reinterpret_cast< wxWindow * >(argp7);
5710 }
5711 if (obj7) {
5712 ecode8 = SWIG_AsVal_int(obj7, &val8);
5713 if (!SWIG_IsOK(ecode8)) {
5714 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "FileSelector" "', expected argument " "8"" of type '" "int""'");
5715 }
5716 arg8 = static_cast< int >(val8);
5717 }
5718 if (obj8) {
5719 ecode9 = SWIG_AsVal_int(obj8, &val9);
5720 if (!SWIG_IsOK(ecode9)) {
5721 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "FileSelector" "', expected argument " "9"" of type '" "int""'");
5722 }
5723 arg9 = static_cast< int >(val9);
5724 }
5725 {
5726 if (!wxPyCheckForApp()) SWIG_fail;
5727 PyThreadState* __tstate = wxPyBeginAllowThreads();
5728 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
5729 wxPyEndAllowThreads(__tstate);
5730 if (PyErr_Occurred()) SWIG_fail;
5731 }
5732 {
5733 #if wxUSE_UNICODE
5734 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5735 #else
5736 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5737 #endif
5738 }
5739 {
5740 if (temp1)
5741 delete arg1;
5742 }
5743 {
5744 if (temp2)
5745 delete arg2;
5746 }
5747 {
5748 if (temp3)
5749 delete arg3;
5750 }
5751 {
5752 if (temp4)
5753 delete arg4;
5754 }
5755 {
5756 if (temp5)
5757 delete arg5;
5758 }
5759 return resultobj;
5760 fail:
5761 {
5762 if (temp1)
5763 delete arg1;
5764 }
5765 {
5766 if (temp2)
5767 delete arg2;
5768 }
5769 {
5770 if (temp3)
5771 delete arg3;
5772 }
5773 {
5774 if (temp4)
5775 delete arg4;
5776 }
5777 {
5778 if (temp5)
5779 delete arg5;
5780 }
5781 return NULL;
5782 }
5783
5784
5785 SWIGINTERN PyObject *_wrap_LoadFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5786 PyObject *resultobj = 0;
5787 wxString *arg1 = 0 ;
5788 wxString *arg2 = 0 ;
5789 wxString const &arg3_defvalue = wxPyEmptyString ;
5790 wxString *arg3 = (wxString *) &arg3_defvalue ;
5791 wxWindow *arg4 = (wxWindow *) NULL ;
5792 wxString result;
5793 bool temp1 = false ;
5794 bool temp2 = false ;
5795 bool temp3 = false ;
5796 void *argp4 = 0 ;
5797 int res4 = 0 ;
5798 PyObject * obj0 = 0 ;
5799 PyObject * obj1 = 0 ;
5800 PyObject * obj2 = 0 ;
5801 PyObject * obj3 = 0 ;
5802 char * kwnames[] = {
5803 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5804 };
5805
5806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5807 {
5808 arg1 = wxString_in_helper(obj0);
5809 if (arg1 == NULL) SWIG_fail;
5810 temp1 = true;
5811 }
5812 {
5813 arg2 = wxString_in_helper(obj1);
5814 if (arg2 == NULL) SWIG_fail;
5815 temp2 = true;
5816 }
5817 if (obj2) {
5818 {
5819 arg3 = wxString_in_helper(obj2);
5820 if (arg3 == NULL) SWIG_fail;
5821 temp3 = true;
5822 }
5823 }
5824 if (obj3) {
5825 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5826 if (!SWIG_IsOK(res4)) {
5827 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LoadFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5828 }
5829 arg4 = reinterpret_cast< wxWindow * >(argp4);
5830 }
5831 {
5832 if (!wxPyCheckForApp()) SWIG_fail;
5833 PyThreadState* __tstate = wxPyBeginAllowThreads();
5834 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5835 wxPyEndAllowThreads(__tstate);
5836 if (PyErr_Occurred()) SWIG_fail;
5837 }
5838 {
5839 #if wxUSE_UNICODE
5840 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5841 #else
5842 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5843 #endif
5844 }
5845 {
5846 if (temp1)
5847 delete arg1;
5848 }
5849 {
5850 if (temp2)
5851 delete arg2;
5852 }
5853 {
5854 if (temp3)
5855 delete arg3;
5856 }
5857 return resultobj;
5858 fail:
5859 {
5860 if (temp1)
5861 delete arg1;
5862 }
5863 {
5864 if (temp2)
5865 delete arg2;
5866 }
5867 {
5868 if (temp3)
5869 delete arg3;
5870 }
5871 return NULL;
5872 }
5873
5874
5875 SWIGINTERN PyObject *_wrap_SaveFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5876 PyObject *resultobj = 0;
5877 wxString *arg1 = 0 ;
5878 wxString *arg2 = 0 ;
5879 wxString const &arg3_defvalue = wxPyEmptyString ;
5880 wxString *arg3 = (wxString *) &arg3_defvalue ;
5881 wxWindow *arg4 = (wxWindow *) NULL ;
5882 wxString result;
5883 bool temp1 = false ;
5884 bool temp2 = false ;
5885 bool temp3 = false ;
5886 void *argp4 = 0 ;
5887 int res4 = 0 ;
5888 PyObject * obj0 = 0 ;
5889 PyObject * obj1 = 0 ;
5890 PyObject * obj2 = 0 ;
5891 PyObject * obj3 = 0 ;
5892 char * kwnames[] = {
5893 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5894 };
5895
5896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5897 {
5898 arg1 = wxString_in_helper(obj0);
5899 if (arg1 == NULL) SWIG_fail;
5900 temp1 = true;
5901 }
5902 {
5903 arg2 = wxString_in_helper(obj1);
5904 if (arg2 == NULL) SWIG_fail;
5905 temp2 = true;
5906 }
5907 if (obj2) {
5908 {
5909 arg3 = wxString_in_helper(obj2);
5910 if (arg3 == NULL) SWIG_fail;
5911 temp3 = true;
5912 }
5913 }
5914 if (obj3) {
5915 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5916 if (!SWIG_IsOK(res4)) {
5917 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SaveFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5918 }
5919 arg4 = reinterpret_cast< wxWindow * >(argp4);
5920 }
5921 {
5922 if (!wxPyCheckForApp()) SWIG_fail;
5923 PyThreadState* __tstate = wxPyBeginAllowThreads();
5924 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5925 wxPyEndAllowThreads(__tstate);
5926 if (PyErr_Occurred()) SWIG_fail;
5927 }
5928 {
5929 #if wxUSE_UNICODE
5930 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5931 #else
5932 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5933 #endif
5934 }
5935 {
5936 if (temp1)
5937 delete arg1;
5938 }
5939 {
5940 if (temp2)
5941 delete arg2;
5942 }
5943 {
5944 if (temp3)
5945 delete arg3;
5946 }
5947 return resultobj;
5948 fail:
5949 {
5950 if (temp1)
5951 delete arg1;
5952 }
5953 {
5954 if (temp2)
5955 delete arg2;
5956 }
5957 {
5958 if (temp3)
5959 delete arg3;
5960 }
5961 return NULL;
5962 }
5963
5964
5965 SWIGINTERN PyObject *_wrap_DirSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5966 PyObject *resultobj = 0;
5967 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
5968 wxString *arg1 = (wxString *) &arg1_defvalue ;
5969 wxString const &arg2_defvalue = wxPyEmptyString ;
5970 wxString *arg2 = (wxString *) &arg2_defvalue ;
5971 long arg3 = (long) wxDD_DEFAULT_STYLE ;
5972 wxPoint const &arg4_defvalue = wxDefaultPosition ;
5973 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
5974 wxWindow *arg5 = (wxWindow *) NULL ;
5975 wxString result;
5976 bool temp1 = false ;
5977 bool temp2 = false ;
5978 long val3 ;
5979 int ecode3 = 0 ;
5980 wxPoint temp4 ;
5981 void *argp5 = 0 ;
5982 int res5 = 0 ;
5983 PyObject * obj0 = 0 ;
5984 PyObject * obj1 = 0 ;
5985 PyObject * obj2 = 0 ;
5986 PyObject * obj3 = 0 ;
5987 PyObject * obj4 = 0 ;
5988 char * kwnames[] = {
5989 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
5990 };
5991
5992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
5993 if (obj0) {
5994 {
5995 arg1 = wxString_in_helper(obj0);
5996 if (arg1 == NULL) SWIG_fail;
5997 temp1 = true;
5998 }
5999 }
6000 if (obj1) {
6001 {
6002 arg2 = wxString_in_helper(obj1);
6003 if (arg2 == NULL) SWIG_fail;
6004 temp2 = true;
6005 }
6006 }
6007 if (obj2) {
6008 ecode3 = SWIG_AsVal_long(obj2, &val3);
6009 if (!SWIG_IsOK(ecode3)) {
6010 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DirSelector" "', expected argument " "3"" of type '" "long""'");
6011 }
6012 arg3 = static_cast< long >(val3);
6013 }
6014 if (obj3) {
6015 {
6016 arg4 = &temp4;
6017 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
6018 }
6019 }
6020 if (obj4) {
6021 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6022 if (!SWIG_IsOK(res5)) {
6023 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DirSelector" "', expected argument " "5"" of type '" "wxWindow *""'");
6024 }
6025 arg5 = reinterpret_cast< wxWindow * >(argp5);
6026 }
6027 {
6028 if (!wxPyCheckForApp()) SWIG_fail;
6029 PyThreadState* __tstate = wxPyBeginAllowThreads();
6030 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
6031 wxPyEndAllowThreads(__tstate);
6032 if (PyErr_Occurred()) SWIG_fail;
6033 }
6034 {
6035 #if wxUSE_UNICODE
6036 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6037 #else
6038 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6039 #endif
6040 }
6041 {
6042 if (temp1)
6043 delete arg1;
6044 }
6045 {
6046 if (temp2)
6047 delete arg2;
6048 }
6049 return resultobj;
6050 fail:
6051 {
6052 if (temp1)
6053 delete arg1;
6054 }
6055 {
6056 if (temp2)
6057 delete arg2;
6058 }
6059 return NULL;
6060 }
6061
6062
6063 SWIGINTERN PyObject *_wrap_GetTextFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6064 PyObject *resultobj = 0;
6065 wxString *arg1 = 0 ;
6066 wxString const &arg2_defvalue = wxPyEmptyString ;
6067 wxString *arg2 = (wxString *) &arg2_defvalue ;
6068 wxString const &arg3_defvalue = wxPyEmptyString ;
6069 wxString *arg3 = (wxString *) &arg3_defvalue ;
6070 wxWindow *arg4 = (wxWindow *) NULL ;
6071 int arg5 = (int) -1 ;
6072 int arg6 = (int) -1 ;
6073 bool arg7 = (bool) true ;
6074 wxString result;
6075 bool temp1 = false ;
6076 bool temp2 = false ;
6077 bool temp3 = false ;
6078 void *argp4 = 0 ;
6079 int res4 = 0 ;
6080 int val5 ;
6081 int ecode5 = 0 ;
6082 int val6 ;
6083 int ecode6 = 0 ;
6084 bool val7 ;
6085 int ecode7 = 0 ;
6086 PyObject * obj0 = 0 ;
6087 PyObject * obj1 = 0 ;
6088 PyObject * obj2 = 0 ;
6089 PyObject * obj3 = 0 ;
6090 PyObject * obj4 = 0 ;
6091 PyObject * obj5 = 0 ;
6092 PyObject * obj6 = 0 ;
6093 char * kwnames[] = {
6094 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
6095 };
6096
6097 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
6098 {
6099 arg1 = wxString_in_helper(obj0);
6100 if (arg1 == NULL) SWIG_fail;
6101 temp1 = true;
6102 }
6103 if (obj1) {
6104 {
6105 arg2 = wxString_in_helper(obj1);
6106 if (arg2 == NULL) SWIG_fail;
6107 temp2 = true;
6108 }
6109 }
6110 if (obj2) {
6111 {
6112 arg3 = wxString_in_helper(obj2);
6113 if (arg3 == NULL) SWIG_fail;
6114 temp3 = true;
6115 }
6116 }
6117 if (obj3) {
6118 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6119 if (!SWIG_IsOK(res4)) {
6120 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetTextFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6121 }
6122 arg4 = reinterpret_cast< wxWindow * >(argp4);
6123 }
6124 if (obj4) {
6125 ecode5 = SWIG_AsVal_int(obj4, &val5);
6126 if (!SWIG_IsOK(ecode5)) {
6127 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetTextFromUser" "', expected argument " "5"" of type '" "int""'");
6128 }
6129 arg5 = static_cast< int >(val5);
6130 }
6131 if (obj5) {
6132 ecode6 = SWIG_AsVal_int(obj5, &val6);
6133 if (!SWIG_IsOK(ecode6)) {
6134 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetTextFromUser" "', expected argument " "6"" of type '" "int""'");
6135 }
6136 arg6 = static_cast< int >(val6);
6137 }
6138 if (obj6) {
6139 ecode7 = SWIG_AsVal_bool(obj6, &val7);
6140 if (!SWIG_IsOK(ecode7)) {
6141 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetTextFromUser" "', expected argument " "7"" of type '" "bool""'");
6142 }
6143 arg7 = static_cast< bool >(val7);
6144 }
6145 {
6146 if (!wxPyCheckForApp()) SWIG_fail;
6147 PyThreadState* __tstate = wxPyBeginAllowThreads();
6148 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
6149 wxPyEndAllowThreads(__tstate);
6150 if (PyErr_Occurred()) SWIG_fail;
6151 }
6152 {
6153 #if wxUSE_UNICODE
6154 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6155 #else
6156 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6157 #endif
6158 }
6159 {
6160 if (temp1)
6161 delete arg1;
6162 }
6163 {
6164 if (temp2)
6165 delete arg2;
6166 }
6167 {
6168 if (temp3)
6169 delete arg3;
6170 }
6171 return resultobj;
6172 fail:
6173 {
6174 if (temp1)
6175 delete arg1;
6176 }
6177 {
6178 if (temp2)
6179 delete arg2;
6180 }
6181 {
6182 if (temp3)
6183 delete arg3;
6184 }
6185 return NULL;
6186 }
6187
6188
6189 SWIGINTERN PyObject *_wrap_GetPasswordFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6190 PyObject *resultobj = 0;
6191 wxString *arg1 = 0 ;
6192 wxString const &arg2_defvalue = wxPyEmptyString ;
6193 wxString *arg2 = (wxString *) &arg2_defvalue ;
6194 wxString const &arg3_defvalue = wxPyEmptyString ;
6195 wxString *arg3 = (wxString *) &arg3_defvalue ;
6196 wxWindow *arg4 = (wxWindow *) NULL ;
6197 wxString result;
6198 bool temp1 = false ;
6199 bool temp2 = false ;
6200 bool temp3 = false ;
6201 void *argp4 = 0 ;
6202 int res4 = 0 ;
6203 PyObject * obj0 = 0 ;
6204 PyObject * obj1 = 0 ;
6205 PyObject * obj2 = 0 ;
6206 PyObject * obj3 = 0 ;
6207 char * kwnames[] = {
6208 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
6209 };
6210
6211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6212 {
6213 arg1 = wxString_in_helper(obj0);
6214 if (arg1 == NULL) SWIG_fail;
6215 temp1 = true;
6216 }
6217 if (obj1) {
6218 {
6219 arg2 = wxString_in_helper(obj1);
6220 if (arg2 == NULL) SWIG_fail;
6221 temp2 = true;
6222 }
6223 }
6224 if (obj2) {
6225 {
6226 arg3 = wxString_in_helper(obj2);
6227 if (arg3 == NULL) SWIG_fail;
6228 temp3 = true;
6229 }
6230 }
6231 if (obj3) {
6232 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6233 if (!SWIG_IsOK(res4)) {
6234 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetPasswordFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6235 }
6236 arg4 = reinterpret_cast< wxWindow * >(argp4);
6237 }
6238 {
6239 if (!wxPyCheckForApp()) SWIG_fail;
6240 PyThreadState* __tstate = wxPyBeginAllowThreads();
6241 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
6242 wxPyEndAllowThreads(__tstate);
6243 if (PyErr_Occurred()) SWIG_fail;
6244 }
6245 {
6246 #if wxUSE_UNICODE
6247 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6248 #else
6249 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6250 #endif
6251 }
6252 {
6253 if (temp1)
6254 delete arg1;
6255 }
6256 {
6257 if (temp2)
6258 delete arg2;
6259 }
6260 {
6261 if (temp3)
6262 delete arg3;
6263 }
6264 return resultobj;
6265 fail:
6266 {
6267 if (temp1)
6268 delete arg1;
6269 }
6270 {
6271 if (temp2)
6272 delete arg2;
6273 }
6274 {
6275 if (temp3)
6276 delete arg3;
6277 }
6278 return NULL;
6279 }
6280
6281
6282 SWIGINTERN PyObject *_wrap_GetSingleChoice(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6283 PyObject *resultobj = 0;
6284 wxString *arg1 = 0 ;
6285 wxString *arg2 = 0 ;
6286 int arg3 ;
6287 wxString *arg4 = (wxString *) 0 ;
6288 wxWindow *arg5 = (wxWindow *) NULL ;
6289 int arg6 = (int) -1 ;
6290 int arg7 = (int) -1 ;
6291 bool arg8 = (bool) true ;
6292 int arg9 = (int) 150 ;
6293 int arg10 = (int) 200 ;
6294 wxString result;
6295 bool temp1 = false ;
6296 bool temp2 = false ;
6297 void *argp5 = 0 ;
6298 int res5 = 0 ;
6299 int val6 ;
6300 int ecode6 = 0 ;
6301 int val7 ;
6302 int ecode7 = 0 ;
6303 bool val8 ;
6304 int ecode8 = 0 ;
6305 int val9 ;
6306 int ecode9 = 0 ;
6307 int val10 ;
6308 int ecode10 = 0 ;
6309 PyObject * obj0 = 0 ;
6310 PyObject * obj1 = 0 ;
6311 PyObject * obj2 = 0 ;
6312 PyObject * obj3 = 0 ;
6313 PyObject * obj4 = 0 ;
6314 PyObject * obj5 = 0 ;
6315 PyObject * obj6 = 0 ;
6316 PyObject * obj7 = 0 ;
6317 PyObject * obj8 = 0 ;
6318 char * kwnames[] = {
6319 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6320 };
6321
6322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6323 {
6324 arg1 = wxString_in_helper(obj0);
6325 if (arg1 == NULL) SWIG_fail;
6326 temp1 = true;
6327 }
6328 {
6329 arg2 = wxString_in_helper(obj1);
6330 if (arg2 == NULL) SWIG_fail;
6331 temp2 = true;
6332 }
6333 {
6334 arg3 = PyList_Size(obj2);
6335 arg4 = wxString_LIST_helper(obj2);
6336 if (arg4 == NULL) SWIG_fail;
6337 }
6338 if (obj3) {
6339 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6340 if (!SWIG_IsOK(res5)) {
6341 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoice" "', expected argument " "5"" of type '" "wxWindow *""'");
6342 }
6343 arg5 = reinterpret_cast< wxWindow * >(argp5);
6344 }
6345 if (obj4) {
6346 ecode6 = SWIG_AsVal_int(obj4, &val6);
6347 if (!SWIG_IsOK(ecode6)) {
6348 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoice" "', expected argument " "6"" of type '" "int""'");
6349 }
6350 arg6 = static_cast< int >(val6);
6351 }
6352 if (obj5) {
6353 ecode7 = SWIG_AsVal_int(obj5, &val7);
6354 if (!SWIG_IsOK(ecode7)) {
6355 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoice" "', expected argument " "7"" of type '" "int""'");
6356 }
6357 arg7 = static_cast< int >(val7);
6358 }
6359 if (obj6) {
6360 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6361 if (!SWIG_IsOK(ecode8)) {
6362 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoice" "', expected argument " "8"" of type '" "bool""'");
6363 }
6364 arg8 = static_cast< bool >(val8);
6365 }
6366 if (obj7) {
6367 ecode9 = SWIG_AsVal_int(obj7, &val9);
6368 if (!SWIG_IsOK(ecode9)) {
6369 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoice" "', expected argument " "9"" of type '" "int""'");
6370 }
6371 arg9 = static_cast< int >(val9);
6372 }
6373 if (obj8) {
6374 ecode10 = SWIG_AsVal_int(obj8, &val10);
6375 if (!SWIG_IsOK(ecode10)) {
6376 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoice" "', expected argument " "10"" of type '" "int""'");
6377 }
6378 arg10 = static_cast< int >(val10);
6379 }
6380 {
6381 if (!wxPyCheckForApp()) SWIG_fail;
6382 PyThreadState* __tstate = wxPyBeginAllowThreads();
6383 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6384 wxPyEndAllowThreads(__tstate);
6385 if (PyErr_Occurred()) SWIG_fail;
6386 }
6387 {
6388 #if wxUSE_UNICODE
6389 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6390 #else
6391 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6392 #endif
6393 }
6394 {
6395 if (temp1)
6396 delete arg1;
6397 }
6398 {
6399 if (temp2)
6400 delete arg2;
6401 }
6402 {
6403 if (arg4) delete [] arg4;
6404 }
6405 return resultobj;
6406 fail:
6407 {
6408 if (temp1)
6409 delete arg1;
6410 }
6411 {
6412 if (temp2)
6413 delete arg2;
6414 }
6415 {
6416 if (arg4) delete [] arg4;
6417 }
6418 return NULL;
6419 }
6420
6421
6422 SWIGINTERN PyObject *_wrap_GetSingleChoiceIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6423 PyObject *resultobj = 0;
6424 wxString *arg1 = 0 ;
6425 wxString *arg2 = 0 ;
6426 int arg3 ;
6427 wxString *arg4 = (wxString *) 0 ;
6428 wxWindow *arg5 = (wxWindow *) NULL ;
6429 int arg6 = (int) -1 ;
6430 int arg7 = (int) -1 ;
6431 bool arg8 = (bool) true ;
6432 int arg9 = (int) 150 ;
6433 int arg10 = (int) 200 ;
6434 int result;
6435 bool temp1 = false ;
6436 bool temp2 = false ;
6437 void *argp5 = 0 ;
6438 int res5 = 0 ;
6439 int val6 ;
6440 int ecode6 = 0 ;
6441 int val7 ;
6442 int ecode7 = 0 ;
6443 bool val8 ;
6444 int ecode8 = 0 ;
6445 int val9 ;
6446 int ecode9 = 0 ;
6447 int val10 ;
6448 int ecode10 = 0 ;
6449 PyObject * obj0 = 0 ;
6450 PyObject * obj1 = 0 ;
6451 PyObject * obj2 = 0 ;
6452 PyObject * obj3 = 0 ;
6453 PyObject * obj4 = 0 ;
6454 PyObject * obj5 = 0 ;
6455 PyObject * obj6 = 0 ;
6456 PyObject * obj7 = 0 ;
6457 PyObject * obj8 = 0 ;
6458 char * kwnames[] = {
6459 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6460 };
6461
6462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6463 {
6464 arg1 = wxString_in_helper(obj0);
6465 if (arg1 == NULL) SWIG_fail;
6466 temp1 = true;
6467 }
6468 {
6469 arg2 = wxString_in_helper(obj1);
6470 if (arg2 == NULL) SWIG_fail;
6471 temp2 = true;
6472 }
6473 {
6474 arg3 = PyList_Size(obj2);
6475 arg4 = wxString_LIST_helper(obj2);
6476 if (arg4 == NULL) SWIG_fail;
6477 }
6478 if (obj3) {
6479 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6480 if (!SWIG_IsOK(res5)) {
6481 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoiceIndex" "', expected argument " "5"" of type '" "wxWindow *""'");
6482 }
6483 arg5 = reinterpret_cast< wxWindow * >(argp5);
6484 }
6485 if (obj4) {
6486 ecode6 = SWIG_AsVal_int(obj4, &val6);
6487 if (!SWIG_IsOK(ecode6)) {
6488 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoiceIndex" "', expected argument " "6"" of type '" "int""'");
6489 }
6490 arg6 = static_cast< int >(val6);
6491 }
6492 if (obj5) {
6493 ecode7 = SWIG_AsVal_int(obj5, &val7);
6494 if (!SWIG_IsOK(ecode7)) {
6495 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoiceIndex" "', expected argument " "7"" of type '" "int""'");
6496 }
6497 arg7 = static_cast< int >(val7);
6498 }
6499 if (obj6) {
6500 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6501 if (!SWIG_IsOK(ecode8)) {
6502 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoiceIndex" "', expected argument " "8"" of type '" "bool""'");
6503 }
6504 arg8 = static_cast< bool >(val8);
6505 }
6506 if (obj7) {
6507 ecode9 = SWIG_AsVal_int(obj7, &val9);
6508 if (!SWIG_IsOK(ecode9)) {
6509 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoiceIndex" "', expected argument " "9"" of type '" "int""'");
6510 }
6511 arg9 = static_cast< int >(val9);
6512 }
6513 if (obj8) {
6514 ecode10 = SWIG_AsVal_int(obj8, &val10);
6515 if (!SWIG_IsOK(ecode10)) {
6516 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoiceIndex" "', expected argument " "10"" of type '" "int""'");
6517 }
6518 arg10 = static_cast< int >(val10);
6519 }
6520 {
6521 if (!wxPyCheckForApp()) SWIG_fail;
6522 PyThreadState* __tstate = wxPyBeginAllowThreads();
6523 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6524 wxPyEndAllowThreads(__tstate);
6525 if (PyErr_Occurred()) SWIG_fail;
6526 }
6527 resultobj = SWIG_From_int(static_cast< int >(result));
6528 {
6529 if (temp1)
6530 delete arg1;
6531 }
6532 {
6533 if (temp2)
6534 delete arg2;
6535 }
6536 {
6537 if (arg4) delete [] arg4;
6538 }
6539 return resultobj;
6540 fail:
6541 {
6542 if (temp1)
6543 delete arg1;
6544 }
6545 {
6546 if (temp2)
6547 delete arg2;
6548 }
6549 {
6550 if (arg4) delete [] arg4;
6551 }
6552 return NULL;
6553 }
6554
6555
6556 SWIGINTERN PyObject *_wrap_MessageBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6557 PyObject *resultobj = 0;
6558 wxString *arg1 = 0 ;
6559 wxString const &arg2_defvalue = wxPyEmptyString ;
6560 wxString *arg2 = (wxString *) &arg2_defvalue ;
6561 int arg3 = (int) wxOK|wxCENTRE ;
6562 wxWindow *arg4 = (wxWindow *) NULL ;
6563 int arg5 = (int) -1 ;
6564 int arg6 = (int) -1 ;
6565 int result;
6566 bool temp1 = false ;
6567 bool temp2 = false ;
6568 int val3 ;
6569 int ecode3 = 0 ;
6570 void *argp4 = 0 ;
6571 int res4 = 0 ;
6572 int val5 ;
6573 int ecode5 = 0 ;
6574 int val6 ;
6575 int ecode6 = 0 ;
6576 PyObject * obj0 = 0 ;
6577 PyObject * obj1 = 0 ;
6578 PyObject * obj2 = 0 ;
6579 PyObject * obj3 = 0 ;
6580 PyObject * obj4 = 0 ;
6581 PyObject * obj5 = 0 ;
6582 char * kwnames[] = {
6583 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
6584 };
6585
6586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
6587 {
6588 arg1 = wxString_in_helper(obj0);
6589 if (arg1 == NULL) SWIG_fail;
6590 temp1 = true;
6591 }
6592 if (obj1) {
6593 {
6594 arg2 = wxString_in_helper(obj1);
6595 if (arg2 == NULL) SWIG_fail;
6596 temp2 = true;
6597 }
6598 }
6599 if (obj2) {
6600 ecode3 = SWIG_AsVal_int(obj2, &val3);
6601 if (!SWIG_IsOK(ecode3)) {
6602 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MessageBox" "', expected argument " "3"" of type '" "int""'");
6603 }
6604 arg3 = static_cast< int >(val3);
6605 }
6606 if (obj3) {
6607 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6608 if (!SWIG_IsOK(res4)) {
6609 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MessageBox" "', expected argument " "4"" of type '" "wxWindow *""'");
6610 }
6611 arg4 = reinterpret_cast< wxWindow * >(argp4);
6612 }
6613 if (obj4) {
6614 ecode5 = SWIG_AsVal_int(obj4, &val5);
6615 if (!SWIG_IsOK(ecode5)) {
6616 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "MessageBox" "', expected argument " "5"" of type '" "int""'");
6617 }
6618 arg5 = static_cast< int >(val5);
6619 }
6620 if (obj5) {
6621 ecode6 = SWIG_AsVal_int(obj5, &val6);
6622 if (!SWIG_IsOK(ecode6)) {
6623 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "MessageBox" "', expected argument " "6"" of type '" "int""'");
6624 }
6625 arg6 = static_cast< int >(val6);
6626 }
6627 {
6628 if (!wxPyCheckForApp()) SWIG_fail;
6629 PyThreadState* __tstate = wxPyBeginAllowThreads();
6630 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
6631 wxPyEndAllowThreads(__tstate);
6632 if (PyErr_Occurred()) SWIG_fail;
6633 }
6634 resultobj = SWIG_From_int(static_cast< int >(result));
6635 {
6636 if (temp1)
6637 delete arg1;
6638 }
6639 {
6640 if (temp2)
6641 delete arg2;
6642 }
6643 return resultobj;
6644 fail:
6645 {
6646 if (temp1)
6647 delete arg1;
6648 }
6649 {
6650 if (temp2)
6651 delete arg2;
6652 }
6653 return NULL;
6654 }
6655
6656
6657 SWIGINTERN PyObject *_wrap_GetNumberFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6658 PyObject *resultobj = 0;
6659 wxString *arg1 = 0 ;
6660 wxString *arg2 = 0 ;
6661 wxString *arg3 = 0 ;
6662 long arg4 ;
6663 long arg5 = (long) 0 ;
6664 long arg6 = (long) 100 ;
6665 wxWindow *arg7 = (wxWindow *) NULL ;
6666 wxPoint const &arg8_defvalue = wxDefaultPosition ;
6667 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
6668 long result;
6669 bool temp1 = false ;
6670 bool temp2 = false ;
6671 bool temp3 = false ;
6672 long val4 ;
6673 int ecode4 = 0 ;
6674 long val5 ;
6675 int ecode5 = 0 ;
6676 long val6 ;
6677 int ecode6 = 0 ;
6678 void *argp7 = 0 ;
6679 int res7 = 0 ;
6680 wxPoint temp8 ;
6681 PyObject * obj0 = 0 ;
6682 PyObject * obj1 = 0 ;
6683 PyObject * obj2 = 0 ;
6684 PyObject * obj3 = 0 ;
6685 PyObject * obj4 = 0 ;
6686 PyObject * obj5 = 0 ;
6687 PyObject * obj6 = 0 ;
6688 PyObject * obj7 = 0 ;
6689 char * kwnames[] = {
6690 (char *) "message",(char *) "prompt",(char *) "caption",(char *) "value",(char *) "min",(char *) "max",(char *) "parent",(char *) "pos", NULL
6691 };
6692
6693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOOO:GetNumberFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
6694 {
6695 arg1 = wxString_in_helper(obj0);
6696 if (arg1 == NULL) SWIG_fail;
6697 temp1 = true;
6698 }
6699 {
6700 arg2 = wxString_in_helper(obj1);
6701 if (arg2 == NULL) SWIG_fail;
6702 temp2 = true;
6703 }
6704 {
6705 arg3 = wxString_in_helper(obj2);
6706 if (arg3 == NULL) SWIG_fail;
6707 temp3 = true;
6708 }
6709 ecode4 = SWIG_AsVal_long(obj3, &val4);
6710 if (!SWIG_IsOK(ecode4)) {
6711 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GetNumberFromUser" "', expected argument " "4"" of type '" "long""'");
6712 }
6713 arg4 = static_cast< long >(val4);
6714 if (obj4) {
6715 ecode5 = SWIG_AsVal_long(obj4, &val5);
6716 if (!SWIG_IsOK(ecode5)) {
6717 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetNumberFromUser" "', expected argument " "5"" of type '" "long""'");
6718 }
6719 arg5 = static_cast< long >(val5);
6720 }
6721 if (obj5) {
6722 ecode6 = SWIG_AsVal_long(obj5, &val6);
6723 if (!SWIG_IsOK(ecode6)) {
6724 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetNumberFromUser" "', expected argument " "6"" of type '" "long""'");
6725 }
6726 arg6 = static_cast< long >(val6);
6727 }
6728 if (obj6) {
6729 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_wxWindow, 0 | 0 );
6730 if (!SWIG_IsOK(res7)) {
6731 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "GetNumberFromUser" "', expected argument " "7"" of type '" "wxWindow *""'");
6732 }
6733 arg7 = reinterpret_cast< wxWindow * >(argp7);
6734 }
6735 if (obj7) {
6736 {
6737 arg8 = &temp8;
6738 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
6739 }
6740 }
6741 {
6742 if (!wxPyCheckForApp()) SWIG_fail;
6743 PyThreadState* __tstate = wxPyBeginAllowThreads();
6744 result = (long)wxGetNumberFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7,(wxPoint const &)*arg8);
6745 wxPyEndAllowThreads(__tstate);
6746 if (PyErr_Occurred()) SWIG_fail;
6747 }
6748 resultobj = SWIG_From_long(static_cast< long >(result));
6749 {
6750 if (temp1)
6751 delete arg1;
6752 }
6753 {
6754 if (temp2)
6755 delete arg2;
6756 }
6757 {
6758 if (temp3)
6759 delete arg3;
6760 }
6761 return resultobj;
6762 fail:
6763 {
6764 if (temp1)
6765 delete arg1;
6766 }
6767 {
6768 if (temp2)
6769 delete arg2;
6770 }
6771 {
6772 if (temp3)
6773 delete arg3;
6774 }
6775 return NULL;
6776 }
6777
6778
6779 SWIGINTERN PyObject *_wrap_ColourDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6780 PyObject *resultobj = 0;
6781 bool result;
6782
6783 if (!SWIG_Python_UnpackTuple(args,"ColourDisplay",0,0,0)) SWIG_fail;
6784 {
6785 if (!wxPyCheckForApp()) SWIG_fail;
6786 PyThreadState* __tstate = wxPyBeginAllowThreads();
6787 result = (bool)wxColourDisplay();
6788 wxPyEndAllowThreads(__tstate);
6789 if (PyErr_Occurred()) SWIG_fail;
6790 }
6791 {
6792 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6793 }
6794 return resultobj;
6795 fail:
6796 return NULL;
6797 }
6798
6799
6800 SWIGINTERN PyObject *_wrap_DisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6801 PyObject *resultobj = 0;
6802 int result;
6803
6804 if (!SWIG_Python_UnpackTuple(args,"DisplayDepth",0,0,0)) SWIG_fail;
6805 {
6806 if (!wxPyCheckForApp()) SWIG_fail;
6807 PyThreadState* __tstate = wxPyBeginAllowThreads();
6808 result = (int)wxDisplayDepth();
6809 wxPyEndAllowThreads(__tstate);
6810 if (PyErr_Occurred()) SWIG_fail;
6811 }
6812 resultobj = SWIG_From_int(static_cast< int >(result));
6813 return resultobj;
6814 fail:
6815 return NULL;
6816 }
6817
6818
6819 SWIGINTERN PyObject *_wrap_GetDisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6820 PyObject *resultobj = 0;
6821 int result;
6822
6823 if (!SWIG_Python_UnpackTuple(args,"GetDisplayDepth",0,0,0)) SWIG_fail;
6824 {
6825 if (!wxPyCheckForApp()) SWIG_fail;
6826 PyThreadState* __tstate = wxPyBeginAllowThreads();
6827 result = (int)wxGetDisplayDepth();
6828 wxPyEndAllowThreads(__tstate);
6829 if (PyErr_Occurred()) SWIG_fail;
6830 }
6831 resultobj = SWIG_From_int(static_cast< int >(result));
6832 return resultobj;
6833 fail:
6834 return NULL;
6835 }
6836
6837
6838 SWIGINTERN PyObject *_wrap_DisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6839 PyObject *resultobj = 0;
6840 int *arg1 = (int *) 0 ;
6841 int *arg2 = (int *) 0 ;
6842 int temp1 ;
6843 int res1 = SWIG_TMPOBJ ;
6844 int temp2 ;
6845 int res2 = SWIG_TMPOBJ ;
6846
6847 arg1 = &temp1;
6848 arg2 = &temp2;
6849 if (!SWIG_Python_UnpackTuple(args,"DisplaySize",0,0,0)) SWIG_fail;
6850 {
6851 if (!wxPyCheckForApp()) SWIG_fail;
6852 PyThreadState* __tstate = wxPyBeginAllowThreads();
6853 wxDisplaySize(arg1,arg2);
6854 wxPyEndAllowThreads(__tstate);
6855 if (PyErr_Occurred()) SWIG_fail;
6856 }
6857 resultobj = SWIG_Py_Void();
6858 if (SWIG_IsTmpObj(res1)) {
6859 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6860 } else {
6861 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6862 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6863 }
6864 if (SWIG_IsTmpObj(res2)) {
6865 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6866 } else {
6867 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6868 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6869 }
6870 return resultobj;
6871 fail:
6872 return NULL;
6873 }
6874
6875
6876 SWIGINTERN PyObject *_wrap_GetDisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6877 PyObject *resultobj = 0;
6878 wxSize result;
6879
6880 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySize",0,0,0)) SWIG_fail;
6881 {
6882 if (!wxPyCheckForApp()) SWIG_fail;
6883 PyThreadState* __tstate = wxPyBeginAllowThreads();
6884 result = wxGetDisplaySize();
6885 wxPyEndAllowThreads(__tstate);
6886 if (PyErr_Occurred()) SWIG_fail;
6887 }
6888 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6889 return resultobj;
6890 fail:
6891 return NULL;
6892 }
6893
6894
6895 SWIGINTERN PyObject *_wrap_DisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6896 PyObject *resultobj = 0;
6897 int *arg1 = (int *) 0 ;
6898 int *arg2 = (int *) 0 ;
6899 int temp1 ;
6900 int res1 = SWIG_TMPOBJ ;
6901 int temp2 ;
6902 int res2 = SWIG_TMPOBJ ;
6903
6904 arg1 = &temp1;
6905 arg2 = &temp2;
6906 if (!SWIG_Python_UnpackTuple(args,"DisplaySizeMM",0,0,0)) SWIG_fail;
6907 {
6908 if (!wxPyCheckForApp()) SWIG_fail;
6909 PyThreadState* __tstate = wxPyBeginAllowThreads();
6910 wxDisplaySizeMM(arg1,arg2);
6911 wxPyEndAllowThreads(__tstate);
6912 if (PyErr_Occurred()) SWIG_fail;
6913 }
6914 resultobj = SWIG_Py_Void();
6915 if (SWIG_IsTmpObj(res1)) {
6916 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6917 } else {
6918 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6919 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6920 }
6921 if (SWIG_IsTmpObj(res2)) {
6922 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6923 } else {
6924 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6925 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6926 }
6927 return resultobj;
6928 fail:
6929 return NULL;
6930 }
6931
6932
6933 SWIGINTERN PyObject *_wrap_GetDisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6934 PyObject *resultobj = 0;
6935 wxSize result;
6936
6937 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySizeMM",0,0,0)) SWIG_fail;
6938 {
6939 if (!wxPyCheckForApp()) SWIG_fail;
6940 PyThreadState* __tstate = wxPyBeginAllowThreads();
6941 result = wxGetDisplaySizeMM();
6942 wxPyEndAllowThreads(__tstate);
6943 if (PyErr_Occurred()) SWIG_fail;
6944 }
6945 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6946 return resultobj;
6947 fail:
6948 return NULL;
6949 }
6950
6951
6952 SWIGINTERN PyObject *_wrap_ClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6953 PyObject *resultobj = 0;
6954 int *arg1 = (int *) 0 ;
6955 int *arg2 = (int *) 0 ;
6956 int *arg3 = (int *) 0 ;
6957 int *arg4 = (int *) 0 ;
6958 int temp1 ;
6959 int res1 = SWIG_TMPOBJ ;
6960 int temp2 ;
6961 int res2 = SWIG_TMPOBJ ;
6962 int temp3 ;
6963 int res3 = SWIG_TMPOBJ ;
6964 int temp4 ;
6965 int res4 = SWIG_TMPOBJ ;
6966
6967 arg1 = &temp1;
6968 arg2 = &temp2;
6969 arg3 = &temp3;
6970 arg4 = &temp4;
6971 if (!SWIG_Python_UnpackTuple(args,"ClientDisplayRect",0,0,0)) SWIG_fail;
6972 {
6973 if (!wxPyCheckForApp()) SWIG_fail;
6974 PyThreadState* __tstate = wxPyBeginAllowThreads();
6975 wxClientDisplayRect(arg1,arg2,arg3,arg4);
6976 wxPyEndAllowThreads(__tstate);
6977 if (PyErr_Occurred()) SWIG_fail;
6978 }
6979 resultobj = SWIG_Py_Void();
6980 if (SWIG_IsTmpObj(res1)) {
6981 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6982 } else {
6983 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6984 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6985 }
6986 if (SWIG_IsTmpObj(res2)) {
6987 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6988 } else {
6989 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6990 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6991 }
6992 if (SWIG_IsTmpObj(res3)) {
6993 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6994 } else {
6995 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6996 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6997 }
6998 if (SWIG_IsTmpObj(res4)) {
6999 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
7000 } else {
7001 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7002 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
7003 }
7004 return resultobj;
7005 fail:
7006 return NULL;
7007 }
7008
7009
7010 SWIGINTERN PyObject *_wrap_GetClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7011 PyObject *resultobj = 0;
7012 wxRect result;
7013
7014 if (!SWIG_Python_UnpackTuple(args,"GetClientDisplayRect",0,0,0)) SWIG_fail;
7015 {
7016 if (!wxPyCheckForApp()) SWIG_fail;
7017 PyThreadState* __tstate = wxPyBeginAllowThreads();
7018 result = wxGetClientDisplayRect();
7019 wxPyEndAllowThreads(__tstate);
7020 if (PyErr_Occurred()) SWIG_fail;
7021 }
7022 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7023 return resultobj;
7024 fail:
7025 return NULL;
7026 }
7027
7028
7029 SWIGINTERN PyObject *_wrap_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7030 PyObject *resultobj = 0;
7031 wxCursor *arg1 = 0 ;
7032 void *argp1 = 0 ;
7033 int res1 = 0 ;
7034 PyObject * obj0 = 0 ;
7035 char * kwnames[] = {
7036 (char *) "cursor", NULL
7037 };
7038
7039 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) SWIG_fail;
7040 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxCursor, 0 );
7041 if (!SWIG_IsOK(res1)) {
7042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
7043 }
7044 if (!argp1) {
7045 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
7046 }
7047 arg1 = reinterpret_cast< wxCursor * >(argp1);
7048 {
7049 if (!wxPyCheckForApp()) SWIG_fail;
7050 PyThreadState* __tstate = wxPyBeginAllowThreads();
7051 wxSetCursor(*arg1);
7052 wxPyEndAllowThreads(__tstate);
7053 if (PyErr_Occurred()) SWIG_fail;
7054 }
7055 resultobj = SWIG_Py_Void();
7056 return resultobj;
7057 fail:
7058 return NULL;
7059 }
7060
7061
7062 SWIGINTERN PyObject *_wrap_GetXDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7063 PyObject *resultobj = 0;
7064 void *result = 0 ;
7065
7066 if (!SWIG_Python_UnpackTuple(args,"GetXDisplay",0,0,0)) SWIG_fail;
7067 {
7068 if (!wxPyCheckForApp()) SWIG_fail;
7069 PyThreadState* __tstate = wxPyBeginAllowThreads();
7070 result = (void *)wxGetXDisplay();
7071 wxPyEndAllowThreads(__tstate);
7072 if (PyErr_Occurred()) SWIG_fail;
7073 }
7074 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
7075 return resultobj;
7076 fail:
7077 return NULL;
7078 }
7079
7080
7081 SWIGINTERN PyObject *_wrap_BeginBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7082 PyObject *resultobj = 0;
7083 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
7084 void *argp1 = 0 ;
7085 int res1 = 0 ;
7086 PyObject * obj0 = 0 ;
7087 char * kwnames[] = {
7088 (char *) "cursor", NULL
7089 };
7090
7091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) SWIG_fail;
7092 if (obj0) {
7093 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
7094 if (!SWIG_IsOK(res1)) {
7095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeginBusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
7096 }
7097 arg1 = reinterpret_cast< wxCursor * >(argp1);
7098 }
7099 {
7100 if (!wxPyCheckForApp()) SWIG_fail;
7101 PyThreadState* __tstate = wxPyBeginAllowThreads();
7102 wxBeginBusyCursor(arg1);
7103 wxPyEndAllowThreads(__tstate);
7104 if (PyErr_Occurred()) SWIG_fail;
7105 }
7106 resultobj = SWIG_Py_Void();
7107 return resultobj;
7108 fail:
7109 return NULL;
7110 }
7111
7112
7113 SWIGINTERN PyObject *_wrap_GetMousePosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7114 PyObject *resultobj = 0;
7115 wxPoint result;
7116
7117 if (!SWIG_Python_UnpackTuple(args,"GetMousePosition",0,0,0)) SWIG_fail;
7118 {
7119 if (!wxPyCheckForApp()) SWIG_fail;
7120 PyThreadState* __tstate = wxPyBeginAllowThreads();
7121 result = wxGetMousePosition();
7122 wxPyEndAllowThreads(__tstate);
7123 if (PyErr_Occurred()) SWIG_fail;
7124 }
7125 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
7126 return resultobj;
7127 fail:
7128 return NULL;
7129 }
7130
7131
7132 SWIGINTERN PyObject *_wrap_FindWindowAtPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7133 PyObject *resultobj = 0;
7134 wxWindow *result = 0 ;
7135
7136 if (!SWIG_Python_UnpackTuple(args,"FindWindowAtPointer",0,0,0)) SWIG_fail;
7137 {
7138 if (!wxPyCheckForApp()) SWIG_fail;
7139 PyThreadState* __tstate = wxPyBeginAllowThreads();
7140 result = (wxWindow *)FindWindowAtPointer();
7141 wxPyEndAllowThreads(__tstate);
7142 if (PyErr_Occurred()) SWIG_fail;
7143 }
7144 {
7145 resultobj = wxPyMake_wxObject(result, 0);
7146 }
7147 return resultobj;
7148 fail:
7149 return NULL;
7150 }
7151
7152
7153 SWIGINTERN PyObject *_wrap_GetActiveWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7154 PyObject *resultobj = 0;
7155 wxWindow *result = 0 ;
7156
7157 if (!SWIG_Python_UnpackTuple(args,"GetActiveWindow",0,0,0)) SWIG_fail;
7158 {
7159 if (!wxPyCheckForApp()) SWIG_fail;
7160 PyThreadState* __tstate = wxPyBeginAllowThreads();
7161 result = (wxWindow *)wxGetActiveWindow();
7162 wxPyEndAllowThreads(__tstate);
7163 if (PyErr_Occurred()) SWIG_fail;
7164 }
7165 {
7166 resultobj = wxPyMake_wxObject(result, 0);
7167 }
7168 return resultobj;
7169 fail:
7170 return NULL;
7171 }
7172
7173
7174 SWIGINTERN PyObject *_wrap_GenericFindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7175 PyObject *resultobj = 0;
7176 wxPoint *arg1 = 0 ;
7177 wxWindow *result = 0 ;
7178 wxPoint temp1 ;
7179 PyObject * obj0 = 0 ;
7180 char * kwnames[] = {
7181 (char *) "pt", NULL
7182 };
7183
7184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
7185 {
7186 arg1 = &temp1;
7187 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
7188 }
7189 {
7190 if (!wxPyCheckForApp()) SWIG_fail;
7191 PyThreadState* __tstate = wxPyBeginAllowThreads();
7192 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
7193 wxPyEndAllowThreads(__tstate);
7194 if (PyErr_Occurred()) SWIG_fail;
7195 }
7196 {
7197 resultobj = wxPyMake_wxObject(result, 0);
7198 }
7199 return resultobj;
7200 fail:
7201 return NULL;
7202 }
7203
7204
7205 SWIGINTERN PyObject *_wrap_FindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7206 PyObject *resultobj = 0;
7207 wxPoint *arg1 = 0 ;
7208 wxWindow *result = 0 ;
7209 wxPoint temp1 ;
7210 PyObject * obj0 = 0 ;
7211 char * kwnames[] = {
7212 (char *) "pt", NULL
7213 };
7214
7215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
7216 {
7217 arg1 = &temp1;
7218 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
7219 }
7220 {
7221 if (!wxPyCheckForApp()) SWIG_fail;
7222 PyThreadState* __tstate = wxPyBeginAllowThreads();
7223 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
7224 wxPyEndAllowThreads(__tstate);
7225 if (PyErr_Occurred()) SWIG_fail;
7226 }
7227 {
7228 resultobj = wxPyMake_wxObject(result, 0);
7229 }
7230 return resultobj;
7231 fail:
7232 return NULL;
7233 }
7234
7235
7236 SWIGINTERN PyObject *_wrap_GetTopLevelParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7237 PyObject *resultobj = 0;
7238 wxWindow *arg1 = (wxWindow *) 0 ;
7239 wxWindow *result = 0 ;
7240 void *argp1 = 0 ;
7241 int res1 = 0 ;
7242 PyObject * obj0 = 0 ;
7243 char * kwnames[] = {
7244 (char *) "win", NULL
7245 };
7246
7247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) SWIG_fail;
7248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
7249 if (!SWIG_IsOK(res1)) {
7250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetTopLevelParent" "', expected argument " "1"" of type '" "wxWindow *""'");
7251 }
7252 arg1 = reinterpret_cast< wxWindow * >(argp1);
7253 {
7254 if (!wxPyCheckForApp()) SWIG_fail;
7255 PyThreadState* __tstate = wxPyBeginAllowThreads();
7256 result = (wxWindow *)wxGetTopLevelParent(arg1);
7257 wxPyEndAllowThreads(__tstate);
7258 if (PyErr_Occurred()) SWIG_fail;
7259 }
7260 {
7261 resultobj = wxPyMake_wxObject(result, 0);
7262 }
7263 return resultobj;
7264 fail:
7265 return NULL;
7266 }
7267
7268
7269 SWIGINTERN PyObject *_wrap_LaunchDefaultBrowser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7270 PyObject *resultobj = 0;
7271 wxString *arg1 = 0 ;
7272 bool result;
7273 bool temp1 = false ;
7274 PyObject * obj0 = 0 ;
7275 char * kwnames[] = {
7276 (char *) "url", NULL
7277 };
7278
7279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LaunchDefaultBrowser",kwnames,&obj0)) SWIG_fail;
7280 {
7281 arg1 = wxString_in_helper(obj0);
7282 if (arg1 == NULL) SWIG_fail;
7283 temp1 = true;
7284 }
7285 {
7286 PyThreadState* __tstate = wxPyBeginAllowThreads();
7287 result = (bool)wxLaunchDefaultBrowser((wxString const &)*arg1);
7288 wxPyEndAllowThreads(__tstate);
7289 if (PyErr_Occurred()) SWIG_fail;
7290 }
7291 {
7292 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7293 }
7294 {
7295 if (temp1)
7296 delete arg1;
7297 }
7298 return resultobj;
7299 fail:
7300 {
7301 if (temp1)
7302 delete arg1;
7303 }
7304 return NULL;
7305 }
7306
7307
7308 SWIGINTERN PyObject *_wrap_GetKeyState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7309 PyObject *resultobj = 0;
7310 wxKeyCode arg1 ;
7311 bool result;
7312 int val1 ;
7313 int ecode1 = 0 ;
7314 PyObject * obj0 = 0 ;
7315 char * kwnames[] = {
7316 (char *) "key", NULL
7317 };
7318
7319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) SWIG_fail;
7320 ecode1 = SWIG_AsVal_int(obj0, &val1);
7321 if (!SWIG_IsOK(ecode1)) {
7322 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetKeyState" "', expected argument " "1"" of type '" "wxKeyCode""'");
7323 }
7324 arg1 = static_cast< wxKeyCode >(val1);
7325 {
7326 if (!wxPyCheckForApp()) SWIG_fail;
7327 PyThreadState* __tstate = wxPyBeginAllowThreads();
7328 result = (bool)wxGetKeyState(arg1);
7329 wxPyEndAllowThreads(__tstate);
7330 if (PyErr_Occurred()) SWIG_fail;
7331 }
7332 {
7333 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7334 }
7335 return resultobj;
7336 fail:
7337 return NULL;
7338 }
7339
7340
7341 SWIGINTERN PyObject *_wrap_new_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7342 PyObject *resultobj = 0;
7343 wxMouseState *result = 0 ;
7344
7345 if (!SWIG_Python_UnpackTuple(args,"new_MouseState",0,0,0)) SWIG_fail;
7346 {
7347 PyThreadState* __tstate = wxPyBeginAllowThreads();
7348 result = (wxMouseState *)new wxMouseState();
7349 wxPyEndAllowThreads(__tstate);
7350 if (PyErr_Occurred()) SWIG_fail;
7351 }
7352 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseState, SWIG_POINTER_NEW | 0 );
7353 return resultobj;
7354 fail:
7355 return NULL;
7356 }
7357
7358
7359 SWIGINTERN PyObject *_wrap_delete_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7360 PyObject *resultobj = 0;
7361 wxMouseState *arg1 = (wxMouseState *) 0 ;
7362 void *argp1 = 0 ;
7363 int res1 = 0 ;
7364 PyObject *swig_obj[1] ;
7365
7366 if (!args) SWIG_fail;
7367 swig_obj[0] = args;
7368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, SWIG_POINTER_DISOWN | 0 );
7369 if (!SWIG_IsOK(res1)) {
7370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MouseState" "', expected argument " "1"" of type '" "wxMouseState *""'");
7371 }
7372 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7373 {
7374 PyThreadState* __tstate = wxPyBeginAllowThreads();
7375 delete arg1;
7376
7377 wxPyEndAllowThreads(__tstate);
7378 if (PyErr_Occurred()) SWIG_fail;
7379 }
7380 resultobj = SWIG_Py_Void();
7381 return resultobj;
7382 fail:
7383 return NULL;
7384 }
7385
7386
7387 SWIGINTERN PyObject *_wrap_MouseState_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7388 PyObject *resultobj = 0;
7389 wxMouseState *arg1 = (wxMouseState *) 0 ;
7390 int result;
7391 void *argp1 = 0 ;
7392 int res1 = 0 ;
7393 PyObject *swig_obj[1] ;
7394
7395 if (!args) SWIG_fail;
7396 swig_obj[0] = args;
7397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7398 if (!SWIG_IsOK(res1)) {
7399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7400 }
7401 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7402 {
7403 PyThreadState* __tstate = wxPyBeginAllowThreads();
7404 result = (int)(arg1)->GetX();
7405 wxPyEndAllowThreads(__tstate);
7406 if (PyErr_Occurred()) SWIG_fail;
7407 }
7408 resultobj = SWIG_From_int(static_cast< int >(result));
7409 return resultobj;
7410 fail:
7411 return NULL;
7412 }
7413
7414
7415 SWIGINTERN PyObject *_wrap_MouseState_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7416 PyObject *resultobj = 0;
7417 wxMouseState *arg1 = (wxMouseState *) 0 ;
7418 int result;
7419 void *argp1 = 0 ;
7420 int res1 = 0 ;
7421 PyObject *swig_obj[1] ;
7422
7423 if (!args) SWIG_fail;
7424 swig_obj[0] = args;
7425 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7426 if (!SWIG_IsOK(res1)) {
7427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7428 }
7429 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7430 {
7431 PyThreadState* __tstate = wxPyBeginAllowThreads();
7432 result = (int)(arg1)->GetY();
7433 wxPyEndAllowThreads(__tstate);
7434 if (PyErr_Occurred()) SWIG_fail;
7435 }
7436 resultobj = SWIG_From_int(static_cast< int >(result));
7437 return resultobj;
7438 fail:
7439 return NULL;
7440 }
7441
7442
7443 SWIGINTERN PyObject *_wrap_MouseState_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7444 PyObject *resultobj = 0;
7445 wxMouseState *arg1 = (wxMouseState *) 0 ;
7446 bool result;
7447 void *argp1 = 0 ;
7448 int res1 = 0 ;
7449 PyObject *swig_obj[1] ;
7450
7451 if (!args) SWIG_fail;
7452 swig_obj[0] = args;
7453 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7454 if (!SWIG_IsOK(res1)) {
7455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_LeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7456 }
7457 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7458 {
7459 PyThreadState* __tstate = wxPyBeginAllowThreads();
7460 result = (bool)(arg1)->LeftDown();
7461 wxPyEndAllowThreads(__tstate);
7462 if (PyErr_Occurred()) SWIG_fail;
7463 }
7464 {
7465 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7466 }
7467 return resultobj;
7468 fail:
7469 return NULL;
7470 }
7471
7472
7473 SWIGINTERN PyObject *_wrap_MouseState_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7474 PyObject *resultobj = 0;
7475 wxMouseState *arg1 = (wxMouseState *) 0 ;
7476 bool result;
7477 void *argp1 = 0 ;
7478 int res1 = 0 ;
7479 PyObject *swig_obj[1] ;
7480
7481 if (!args) SWIG_fail;
7482 swig_obj[0] = args;
7483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7484 if (!SWIG_IsOK(res1)) {
7485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7486 }
7487 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7488 {
7489 PyThreadState* __tstate = wxPyBeginAllowThreads();
7490 result = (bool)(arg1)->MiddleDown();
7491 wxPyEndAllowThreads(__tstate);
7492 if (PyErr_Occurred()) SWIG_fail;
7493 }
7494 {
7495 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7496 }
7497 return resultobj;
7498 fail:
7499 return NULL;
7500 }
7501
7502
7503 SWIGINTERN PyObject *_wrap_MouseState_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7504 PyObject *resultobj = 0;
7505 wxMouseState *arg1 = (wxMouseState *) 0 ;
7506 bool result;
7507 void *argp1 = 0 ;
7508 int res1 = 0 ;
7509 PyObject *swig_obj[1] ;
7510
7511 if (!args) SWIG_fail;
7512 swig_obj[0] = args;
7513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7514 if (!SWIG_IsOK(res1)) {
7515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_RightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7516 }
7517 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7518 {
7519 PyThreadState* __tstate = wxPyBeginAllowThreads();
7520 result = (bool)(arg1)->RightDown();
7521 wxPyEndAllowThreads(__tstate);
7522 if (PyErr_Occurred()) SWIG_fail;
7523 }
7524 {
7525 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7526 }
7527 return resultobj;
7528 fail:
7529 return NULL;
7530 }
7531
7532
7533 SWIGINTERN PyObject *_wrap_MouseState_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7534 PyObject *resultobj = 0;
7535 wxMouseState *arg1 = (wxMouseState *) 0 ;
7536 bool result;
7537 void *argp1 = 0 ;
7538 int res1 = 0 ;
7539 PyObject *swig_obj[1] ;
7540
7541 if (!args) SWIG_fail;
7542 swig_obj[0] = args;
7543 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7544 if (!SWIG_IsOK(res1)) {
7545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7546 }
7547 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7548 {
7549 PyThreadState* __tstate = wxPyBeginAllowThreads();
7550 result = (bool)(arg1)->ControlDown();
7551 wxPyEndAllowThreads(__tstate);
7552 if (PyErr_Occurred()) SWIG_fail;
7553 }
7554 {
7555 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7556 }
7557 return resultobj;
7558 fail:
7559 return NULL;
7560 }
7561
7562
7563 SWIGINTERN PyObject *_wrap_MouseState_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7564 PyObject *resultobj = 0;
7565 wxMouseState *arg1 = (wxMouseState *) 0 ;
7566 bool result;
7567 void *argp1 = 0 ;
7568 int res1 = 0 ;
7569 PyObject *swig_obj[1] ;
7570
7571 if (!args) SWIG_fail;
7572 swig_obj[0] = args;
7573 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7574 if (!SWIG_IsOK(res1)) {
7575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7576 }
7577 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7578 {
7579 PyThreadState* __tstate = wxPyBeginAllowThreads();
7580 result = (bool)(arg1)->ShiftDown();
7581 wxPyEndAllowThreads(__tstate);
7582 if (PyErr_Occurred()) SWIG_fail;
7583 }
7584 {
7585 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7586 }
7587 return resultobj;
7588 fail:
7589 return NULL;
7590 }
7591
7592
7593 SWIGINTERN PyObject *_wrap_MouseState_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7594 PyObject *resultobj = 0;
7595 wxMouseState *arg1 = (wxMouseState *) 0 ;
7596 bool result;
7597 void *argp1 = 0 ;
7598 int res1 = 0 ;
7599 PyObject *swig_obj[1] ;
7600
7601 if (!args) SWIG_fail;
7602 swig_obj[0] = args;
7603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7604 if (!SWIG_IsOK(res1)) {
7605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_AltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7606 }
7607 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7608 {
7609 PyThreadState* __tstate = wxPyBeginAllowThreads();
7610 result = (bool)(arg1)->AltDown();
7611 wxPyEndAllowThreads(__tstate);
7612 if (PyErr_Occurred()) SWIG_fail;
7613 }
7614 {
7615 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7616 }
7617 return resultobj;
7618 fail:
7619 return NULL;
7620 }
7621
7622
7623 SWIGINTERN PyObject *_wrap_MouseState_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7624 PyObject *resultobj = 0;
7625 wxMouseState *arg1 = (wxMouseState *) 0 ;
7626 bool result;
7627 void *argp1 = 0 ;
7628 int res1 = 0 ;
7629 PyObject *swig_obj[1] ;
7630
7631 if (!args) SWIG_fail;
7632 swig_obj[0] = args;
7633 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7634 if (!SWIG_IsOK(res1)) {
7635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7636 }
7637 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7638 {
7639 PyThreadState* __tstate = wxPyBeginAllowThreads();
7640 result = (bool)(arg1)->MetaDown();
7641 wxPyEndAllowThreads(__tstate);
7642 if (PyErr_Occurred()) SWIG_fail;
7643 }
7644 {
7645 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7646 }
7647 return resultobj;
7648 fail:
7649 return NULL;
7650 }
7651
7652
7653 SWIGINTERN PyObject *_wrap_MouseState_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7654 PyObject *resultobj = 0;
7655 wxMouseState *arg1 = (wxMouseState *) 0 ;
7656 bool result;
7657 void *argp1 = 0 ;
7658 int res1 = 0 ;
7659 PyObject *swig_obj[1] ;
7660
7661 if (!args) SWIG_fail;
7662 swig_obj[0] = args;
7663 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7664 if (!SWIG_IsOK(res1)) {
7665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_CmdDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7666 }
7667 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7668 {
7669 PyThreadState* __tstate = wxPyBeginAllowThreads();
7670 result = (bool)(arg1)->CmdDown();
7671 wxPyEndAllowThreads(__tstate);
7672 if (PyErr_Occurred()) SWIG_fail;
7673 }
7674 {
7675 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7676 }
7677 return resultobj;
7678 fail:
7679 return NULL;
7680 }
7681
7682
7683 SWIGINTERN PyObject *_wrap_MouseState_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7684 PyObject *resultobj = 0;
7685 wxMouseState *arg1 = (wxMouseState *) 0 ;
7686 int arg2 ;
7687 void *argp1 = 0 ;
7688 int res1 = 0 ;
7689 int val2 ;
7690 int ecode2 = 0 ;
7691 PyObject * obj0 = 0 ;
7692 PyObject * obj1 = 0 ;
7693 char * kwnames[] = {
7694 (char *) "self",(char *) "x", NULL
7695 };
7696
7697 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
7698 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7699 if (!SWIG_IsOK(res1)) {
7700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7701 }
7702 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7703 ecode2 = SWIG_AsVal_int(obj1, &val2);
7704 if (!SWIG_IsOK(ecode2)) {
7705 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetX" "', expected argument " "2"" of type '" "int""'");
7706 }
7707 arg2 = static_cast< int >(val2);
7708 {
7709 PyThreadState* __tstate = wxPyBeginAllowThreads();
7710 (arg1)->SetX(arg2);
7711 wxPyEndAllowThreads(__tstate);
7712 if (PyErr_Occurred()) SWIG_fail;
7713 }
7714 resultobj = SWIG_Py_Void();
7715 return resultobj;
7716 fail:
7717 return NULL;
7718 }
7719
7720
7721 SWIGINTERN PyObject *_wrap_MouseState_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7722 PyObject *resultobj = 0;
7723 wxMouseState *arg1 = (wxMouseState *) 0 ;
7724 int arg2 ;
7725 void *argp1 = 0 ;
7726 int res1 = 0 ;
7727 int val2 ;
7728 int ecode2 = 0 ;
7729 PyObject * obj0 = 0 ;
7730 PyObject * obj1 = 0 ;
7731 char * kwnames[] = {
7732 (char *) "self",(char *) "y", NULL
7733 };
7734
7735 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
7736 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7737 if (!SWIG_IsOK(res1)) {
7738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7739 }
7740 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7741 ecode2 = SWIG_AsVal_int(obj1, &val2);
7742 if (!SWIG_IsOK(ecode2)) {
7743 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetY" "', expected argument " "2"" of type '" "int""'");
7744 }
7745 arg2 = static_cast< int >(val2);
7746 {
7747 PyThreadState* __tstate = wxPyBeginAllowThreads();
7748 (arg1)->SetY(arg2);
7749 wxPyEndAllowThreads(__tstate);
7750 if (PyErr_Occurred()) SWIG_fail;
7751 }
7752 resultobj = SWIG_Py_Void();
7753 return resultobj;
7754 fail:
7755 return NULL;
7756 }
7757
7758
7759 SWIGINTERN PyObject *_wrap_MouseState_SetLeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7760 PyObject *resultobj = 0;
7761 wxMouseState *arg1 = (wxMouseState *) 0 ;
7762 bool arg2 ;
7763 void *argp1 = 0 ;
7764 int res1 = 0 ;
7765 bool val2 ;
7766 int ecode2 = 0 ;
7767 PyObject * obj0 = 0 ;
7768 PyObject * obj1 = 0 ;
7769 char * kwnames[] = {
7770 (char *) "self",(char *) "down", NULL
7771 };
7772
7773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetLeftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7775 if (!SWIG_IsOK(res1)) {
7776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetLeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7777 }
7778 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7779 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7780 if (!SWIG_IsOK(ecode2)) {
7781 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetLeftDown" "', expected argument " "2"" of type '" "bool""'");
7782 }
7783 arg2 = static_cast< bool >(val2);
7784 {
7785 PyThreadState* __tstate = wxPyBeginAllowThreads();
7786 (arg1)->SetLeftDown(arg2);
7787 wxPyEndAllowThreads(__tstate);
7788 if (PyErr_Occurred()) SWIG_fail;
7789 }
7790 resultobj = SWIG_Py_Void();
7791 return resultobj;
7792 fail:
7793 return NULL;
7794 }
7795
7796
7797 SWIGINTERN PyObject *_wrap_MouseState_SetMiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7798 PyObject *resultobj = 0;
7799 wxMouseState *arg1 = (wxMouseState *) 0 ;
7800 bool arg2 ;
7801 void *argp1 = 0 ;
7802 int res1 = 0 ;
7803 bool val2 ;
7804 int ecode2 = 0 ;
7805 PyObject * obj0 = 0 ;
7806 PyObject * obj1 = 0 ;
7807 char * kwnames[] = {
7808 (char *) "self",(char *) "down", NULL
7809 };
7810
7811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMiddleDown",kwnames,&obj0,&obj1)) SWIG_fail;
7812 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7813 if (!SWIG_IsOK(res1)) {
7814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7815 }
7816 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7817 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7818 if (!SWIG_IsOK(ecode2)) {
7819 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMiddleDown" "', expected argument " "2"" of type '" "bool""'");
7820 }
7821 arg2 = static_cast< bool >(val2);
7822 {
7823 PyThreadState* __tstate = wxPyBeginAllowThreads();
7824 (arg1)->SetMiddleDown(arg2);
7825 wxPyEndAllowThreads(__tstate);
7826 if (PyErr_Occurred()) SWIG_fail;
7827 }
7828 resultobj = SWIG_Py_Void();
7829 return resultobj;
7830 fail:
7831 return NULL;
7832 }
7833
7834
7835 SWIGINTERN PyObject *_wrap_MouseState_SetRightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7836 PyObject *resultobj = 0;
7837 wxMouseState *arg1 = (wxMouseState *) 0 ;
7838 bool arg2 ;
7839 void *argp1 = 0 ;
7840 int res1 = 0 ;
7841 bool val2 ;
7842 int ecode2 = 0 ;
7843 PyObject * obj0 = 0 ;
7844 PyObject * obj1 = 0 ;
7845 char * kwnames[] = {
7846 (char *) "self",(char *) "down", NULL
7847 };
7848
7849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetRightDown",kwnames,&obj0,&obj1)) SWIG_fail;
7850 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7851 if (!SWIG_IsOK(res1)) {
7852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetRightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7853 }
7854 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7855 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7856 if (!SWIG_IsOK(ecode2)) {
7857 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetRightDown" "', expected argument " "2"" of type '" "bool""'");
7858 }
7859 arg2 = static_cast< bool >(val2);
7860 {
7861 PyThreadState* __tstate = wxPyBeginAllowThreads();
7862 (arg1)->SetRightDown(arg2);
7863 wxPyEndAllowThreads(__tstate);
7864 if (PyErr_Occurred()) SWIG_fail;
7865 }
7866 resultobj = SWIG_Py_Void();
7867 return resultobj;
7868 fail:
7869 return NULL;
7870 }
7871
7872
7873 SWIGINTERN PyObject *_wrap_MouseState_SetControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7874 PyObject *resultobj = 0;
7875 wxMouseState *arg1 = (wxMouseState *) 0 ;
7876 bool arg2 ;
7877 void *argp1 = 0 ;
7878 int res1 = 0 ;
7879 bool val2 ;
7880 int ecode2 = 0 ;
7881 PyObject * obj0 = 0 ;
7882 PyObject * obj1 = 0 ;
7883 char * kwnames[] = {
7884 (char *) "self",(char *) "down", NULL
7885 };
7886
7887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetControlDown",kwnames,&obj0,&obj1)) SWIG_fail;
7888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7889 if (!SWIG_IsOK(res1)) {
7890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7891 }
7892 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7893 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7894 if (!SWIG_IsOK(ecode2)) {
7895 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetControlDown" "', expected argument " "2"" of type '" "bool""'");
7896 }
7897 arg2 = static_cast< bool >(val2);
7898 {
7899 PyThreadState* __tstate = wxPyBeginAllowThreads();
7900 (arg1)->SetControlDown(arg2);
7901 wxPyEndAllowThreads(__tstate);
7902 if (PyErr_Occurred()) SWIG_fail;
7903 }
7904 resultobj = SWIG_Py_Void();
7905 return resultobj;
7906 fail:
7907 return NULL;
7908 }
7909
7910
7911 SWIGINTERN PyObject *_wrap_MouseState_SetShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7912 PyObject *resultobj = 0;
7913 wxMouseState *arg1 = (wxMouseState *) 0 ;
7914 bool arg2 ;
7915 void *argp1 = 0 ;
7916 int res1 = 0 ;
7917 bool val2 ;
7918 int ecode2 = 0 ;
7919 PyObject * obj0 = 0 ;
7920 PyObject * obj1 = 0 ;
7921 char * kwnames[] = {
7922 (char *) "self",(char *) "down", NULL
7923 };
7924
7925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetShiftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7926 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7927 if (!SWIG_IsOK(res1)) {
7928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7929 }
7930 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7931 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7932 if (!SWIG_IsOK(ecode2)) {
7933 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetShiftDown" "', expected argument " "2"" of type '" "bool""'");
7934 }
7935 arg2 = static_cast< bool >(val2);
7936 {
7937 PyThreadState* __tstate = wxPyBeginAllowThreads();
7938 (arg1)->SetShiftDown(arg2);
7939 wxPyEndAllowThreads(__tstate);
7940 if (PyErr_Occurred()) SWIG_fail;
7941 }
7942 resultobj = SWIG_Py_Void();
7943 return resultobj;
7944 fail:
7945 return NULL;
7946 }
7947
7948
7949 SWIGINTERN PyObject *_wrap_MouseState_SetAltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7950 PyObject *resultobj = 0;
7951 wxMouseState *arg1 = (wxMouseState *) 0 ;
7952 bool arg2 ;
7953 void *argp1 = 0 ;
7954 int res1 = 0 ;
7955 bool val2 ;
7956 int ecode2 = 0 ;
7957 PyObject * obj0 = 0 ;
7958 PyObject * obj1 = 0 ;
7959 char * kwnames[] = {
7960 (char *) "self",(char *) "down", NULL
7961 };
7962
7963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetAltDown",kwnames,&obj0,&obj1)) SWIG_fail;
7964 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7965 if (!SWIG_IsOK(res1)) {
7966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetAltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7967 }
7968 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7969 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7970 if (!SWIG_IsOK(ecode2)) {
7971 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetAltDown" "', expected argument " "2"" of type '" "bool""'");
7972 }
7973 arg2 = static_cast< bool >(val2);
7974 {
7975 PyThreadState* __tstate = wxPyBeginAllowThreads();
7976 (arg1)->SetAltDown(arg2);
7977 wxPyEndAllowThreads(__tstate);
7978 if (PyErr_Occurred()) SWIG_fail;
7979 }
7980 resultobj = SWIG_Py_Void();
7981 return resultobj;
7982 fail:
7983 return NULL;
7984 }
7985
7986
7987 SWIGINTERN PyObject *_wrap_MouseState_SetMetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7988 PyObject *resultobj = 0;
7989 wxMouseState *arg1 = (wxMouseState *) 0 ;
7990 bool arg2 ;
7991 void *argp1 = 0 ;
7992 int res1 = 0 ;
7993 bool val2 ;
7994 int ecode2 = 0 ;
7995 PyObject * obj0 = 0 ;
7996 PyObject * obj1 = 0 ;
7997 char * kwnames[] = {
7998 (char *) "self",(char *) "down", NULL
7999 };
8000
8001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMetaDown",kwnames,&obj0,&obj1)) SWIG_fail;
8002 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
8003 if (!SWIG_IsOK(res1)) {
8004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
8005 }
8006 arg1 = reinterpret_cast< wxMouseState * >(argp1);
8007 ecode2 = SWIG_AsVal_bool(obj1, &val2);
8008 if (!SWIG_IsOK(ecode2)) {
8009 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMetaDown" "', expected argument " "2"" of type '" "bool""'");
8010 }
8011 arg2 = static_cast< bool >(val2);
8012 {
8013 PyThreadState* __tstate = wxPyBeginAllowThreads();
8014 (arg1)->SetMetaDown(arg2);
8015 wxPyEndAllowThreads(__tstate);
8016 if (PyErr_Occurred()) SWIG_fail;
8017 }
8018 resultobj = SWIG_Py_Void();
8019 return resultobj;
8020 fail:
8021 return NULL;
8022 }
8023
8024
8025 SWIGINTERN PyObject *MouseState_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8026 PyObject *obj;
8027 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8028 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseState, SWIG_NewClientData(obj));
8029 return SWIG_Py_Void();
8030 }
8031
8032 SWIGINTERN PyObject *MouseState_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8033 return SWIG_Python_InitShadowInstance(args);
8034 }
8035
8036 SWIGINTERN PyObject *_wrap_GetMouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8037 PyObject *resultobj = 0;
8038 wxMouseState result;
8039
8040 if (!SWIG_Python_UnpackTuple(args,"GetMouseState",0,0,0)) SWIG_fail;
8041 {
8042 PyThreadState* __tstate = wxPyBeginAllowThreads();
8043 result = wxGetMouseState();
8044 wxPyEndAllowThreads(__tstate);
8045 if (PyErr_Occurred()) SWIG_fail;
8046 }
8047 resultobj = SWIG_NewPointerObj((new wxMouseState(static_cast< const wxMouseState& >(result))), SWIGTYPE_p_wxMouseState, SWIG_POINTER_OWN | 0 );
8048 return resultobj;
8049 fail:
8050 return NULL;
8051 }
8052
8053
8054 SWIGINTERN PyObject *_wrap_WakeUpMainThread(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8055 PyObject *resultobj = 0;
8056
8057 if (!SWIG_Python_UnpackTuple(args,"WakeUpMainThread",0,0,0)) SWIG_fail;
8058 {
8059 if (!wxPyCheckForApp()) SWIG_fail;
8060 PyThreadState* __tstate = wxPyBeginAllowThreads();
8061 wxWakeUpMainThread();
8062 wxPyEndAllowThreads(__tstate);
8063 if (PyErr_Occurred()) SWIG_fail;
8064 }
8065 resultobj = SWIG_Py_Void();
8066 return resultobj;
8067 fail:
8068 return NULL;
8069 }
8070
8071
8072 SWIGINTERN PyObject *_wrap_MutexGuiEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8073 PyObject *resultobj = 0;
8074
8075 if (!SWIG_Python_UnpackTuple(args,"MutexGuiEnter",0,0,0)) SWIG_fail;
8076 {
8077 if (!wxPyCheckForApp()) SWIG_fail;
8078 PyThreadState* __tstate = wxPyBeginAllowThreads();
8079 wxMutexGuiEnter();
8080 wxPyEndAllowThreads(__tstate);
8081 if (PyErr_Occurred()) SWIG_fail;
8082 }
8083 resultobj = SWIG_Py_Void();
8084 return resultobj;
8085 fail:
8086 return NULL;
8087 }
8088
8089
8090 SWIGINTERN PyObject *_wrap_MutexGuiLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8091 PyObject *resultobj = 0;
8092
8093 if (!SWIG_Python_UnpackTuple(args,"MutexGuiLeave",0,0,0)) SWIG_fail;
8094 {
8095 if (!wxPyCheckForApp()) SWIG_fail;
8096 PyThreadState* __tstate = wxPyBeginAllowThreads();
8097 wxMutexGuiLeave();
8098 wxPyEndAllowThreads(__tstate);
8099 if (PyErr_Occurred()) SWIG_fail;
8100 }
8101 resultobj = SWIG_Py_Void();
8102 return resultobj;
8103 fail:
8104 return NULL;
8105 }
8106
8107
8108 SWIGINTERN PyObject *_wrap_new_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8109 PyObject *resultobj = 0;
8110 wxMutexGuiLocker *result = 0 ;
8111
8112 if (!SWIG_Python_UnpackTuple(args,"new_MutexGuiLocker",0,0,0)) SWIG_fail;
8113 {
8114 if (!wxPyCheckForApp()) SWIG_fail;
8115 PyThreadState* __tstate = wxPyBeginAllowThreads();
8116 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
8117 wxPyEndAllowThreads(__tstate);
8118 if (PyErr_Occurred()) SWIG_fail;
8119 }
8120 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_NEW | 0 );
8121 return resultobj;
8122 fail:
8123 return NULL;
8124 }
8125
8126
8127 SWIGINTERN PyObject *_wrap_delete_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8128 PyObject *resultobj = 0;
8129 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
8130 void *argp1 = 0 ;
8131 int res1 = 0 ;
8132 PyObject *swig_obj[1] ;
8133
8134 if (!args) SWIG_fail;
8135 swig_obj[0] = args;
8136 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_DISOWN | 0 );
8137 if (!SWIG_IsOK(res1)) {
8138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MutexGuiLocker" "', expected argument " "1"" of type '" "wxMutexGuiLocker *""'");
8139 }
8140 arg1 = reinterpret_cast< wxMutexGuiLocker * >(argp1);
8141 {
8142 PyThreadState* __tstate = wxPyBeginAllowThreads();
8143 delete arg1;
8144
8145 wxPyEndAllowThreads(__tstate);
8146 if (PyErr_Occurred()) SWIG_fail;
8147 }
8148 resultobj = SWIG_Py_Void();
8149 return resultobj;
8150 fail:
8151 return NULL;
8152 }
8153
8154
8155 SWIGINTERN PyObject *MutexGuiLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8156 PyObject *obj;
8157 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8158 SWIG_TypeNewClientData(SWIGTYPE_p_wxMutexGuiLocker, SWIG_NewClientData(obj));
8159 return SWIG_Py_Void();
8160 }
8161
8162 SWIGINTERN PyObject *MutexGuiLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8163 return SWIG_Python_InitShadowInstance(args);
8164 }
8165
8166 SWIGINTERN PyObject *_wrap_Thread_IsMain(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8167 PyObject *resultobj = 0;
8168 bool result;
8169
8170 if (!SWIG_Python_UnpackTuple(args,"Thread_IsMain",0,0,0)) SWIG_fail;
8171 {
8172 PyThreadState* __tstate = wxPyBeginAllowThreads();
8173 result = (bool)wxThread_IsMain();
8174 wxPyEndAllowThreads(__tstate);
8175 if (PyErr_Occurred()) SWIG_fail;
8176 }
8177 {
8178 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8179 }
8180 return resultobj;
8181 fail:
8182 return NULL;
8183 }
8184
8185
8186 SWIGINTERN PyObject *_wrap_new_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8187 PyObject *resultobj = 0;
8188 wxString *arg1 = 0 ;
8189 wxToolTip *result = 0 ;
8190 bool temp1 = false ;
8191 PyObject * obj0 = 0 ;
8192 char * kwnames[] = {
8193 (char *) "tip", NULL
8194 };
8195
8196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) SWIG_fail;
8197 {
8198 arg1 = wxString_in_helper(obj0);
8199 if (arg1 == NULL) SWIG_fail;
8200 temp1 = true;
8201 }
8202 {
8203 if (!wxPyCheckForApp()) SWIG_fail;
8204 PyThreadState* __tstate = wxPyBeginAllowThreads();
8205 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
8206 wxPyEndAllowThreads(__tstate);
8207 if (PyErr_Occurred()) SWIG_fail;
8208 }
8209 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxToolTip, SWIG_POINTER_NEW | 0 );
8210 {
8211 if (temp1)
8212 delete arg1;
8213 }
8214 return resultobj;
8215 fail:
8216 {
8217 if (temp1)
8218 delete arg1;
8219 }
8220 return NULL;
8221 }
8222
8223
8224 SWIGINTERN PyObject *_wrap_delete_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8225 PyObject *resultobj = 0;
8226 wxToolTip *arg1 = (wxToolTip *) 0 ;
8227 void *argp1 = 0 ;
8228 int res1 = 0 ;
8229 PyObject *swig_obj[1] ;
8230
8231 if (!args) SWIG_fail;
8232 swig_obj[0] = args;
8233 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
8234 if (!SWIG_IsOK(res1)) {
8235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ToolTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8236 }
8237 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8238 {
8239 PyThreadState* __tstate = wxPyBeginAllowThreads();
8240 delete arg1;
8241
8242 wxPyEndAllowThreads(__tstate);
8243 if (PyErr_Occurred()) SWIG_fail;
8244 }
8245 resultobj = SWIG_Py_Void();
8246 return resultobj;
8247 fail:
8248 return NULL;
8249 }
8250
8251
8252 SWIGINTERN PyObject *_wrap_ToolTip_SetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8253 PyObject *resultobj = 0;
8254 wxToolTip *arg1 = (wxToolTip *) 0 ;
8255 wxString *arg2 = 0 ;
8256 void *argp1 = 0 ;
8257 int res1 = 0 ;
8258 bool temp2 = false ;
8259 PyObject * obj0 = 0 ;
8260 PyObject * obj1 = 0 ;
8261 char * kwnames[] = {
8262 (char *) "self",(char *) "tip", NULL
8263 };
8264
8265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) SWIG_fail;
8266 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8267 if (!SWIG_IsOK(res1)) {
8268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_SetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8269 }
8270 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8271 {
8272 arg2 = wxString_in_helper(obj1);
8273 if (arg2 == NULL) SWIG_fail;
8274 temp2 = true;
8275 }
8276 {
8277 PyThreadState* __tstate = wxPyBeginAllowThreads();
8278 (arg1)->SetTip((wxString const &)*arg2);
8279 wxPyEndAllowThreads(__tstate);
8280 if (PyErr_Occurred()) SWIG_fail;
8281 }
8282 resultobj = SWIG_Py_Void();
8283 {
8284 if (temp2)
8285 delete arg2;
8286 }
8287 return resultobj;
8288 fail:
8289 {
8290 if (temp2)
8291 delete arg2;
8292 }
8293 return NULL;
8294 }
8295
8296
8297 SWIGINTERN PyObject *_wrap_ToolTip_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8298 PyObject *resultobj = 0;
8299 wxToolTip *arg1 = (wxToolTip *) 0 ;
8300 wxString result;
8301 void *argp1 = 0 ;
8302 int res1 = 0 ;
8303 PyObject *swig_obj[1] ;
8304
8305 if (!args) SWIG_fail;
8306 swig_obj[0] = args;
8307 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8308 if (!SWIG_IsOK(res1)) {
8309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8310 }
8311 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8312 {
8313 PyThreadState* __tstate = wxPyBeginAllowThreads();
8314 result = (arg1)->GetTip();
8315 wxPyEndAllowThreads(__tstate);
8316 if (PyErr_Occurred()) SWIG_fail;
8317 }
8318 {
8319 #if wxUSE_UNICODE
8320 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8321 #else
8322 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8323 #endif
8324 }
8325 return resultobj;
8326 fail:
8327 return NULL;
8328 }
8329
8330
8331 SWIGINTERN PyObject *_wrap_ToolTip_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8332 PyObject *resultobj = 0;
8333 wxToolTip *arg1 = (wxToolTip *) 0 ;
8334 wxWindow *result = 0 ;
8335 void *argp1 = 0 ;
8336 int res1 = 0 ;
8337 PyObject *swig_obj[1] ;
8338
8339 if (!args) SWIG_fail;
8340 swig_obj[0] = args;
8341 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8342 if (!SWIG_IsOK(res1)) {
8343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetWindow" "', expected argument " "1"" of type '" "wxToolTip *""'");
8344 }
8345 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8346 {
8347 PyThreadState* __tstate = wxPyBeginAllowThreads();
8348 result = (wxWindow *)(arg1)->GetWindow();
8349 wxPyEndAllowThreads(__tstate);
8350 if (PyErr_Occurred()) SWIG_fail;
8351 }
8352 {
8353 resultobj = wxPyMake_wxObject(result, 0);
8354 }
8355 return resultobj;
8356 fail:
8357 return NULL;
8358 }
8359
8360
8361 SWIGINTERN PyObject *_wrap_ToolTip_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8362 PyObject *resultobj = 0;
8363 bool arg1 ;
8364 bool val1 ;
8365 int ecode1 = 0 ;
8366 PyObject * obj0 = 0 ;
8367 char * kwnames[] = {
8368 (char *) "flag", NULL
8369 };
8370
8371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) SWIG_fail;
8372 ecode1 = SWIG_AsVal_bool(obj0, &val1);
8373 if (!SWIG_IsOK(ecode1)) {
8374 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_Enable" "', expected argument " "1"" of type '" "bool""'");
8375 }
8376 arg1 = static_cast< bool >(val1);
8377 {
8378 PyThreadState* __tstate = wxPyBeginAllowThreads();
8379 wxToolTip::Enable(arg1);
8380 wxPyEndAllowThreads(__tstate);
8381 if (PyErr_Occurred()) SWIG_fail;
8382 }
8383 resultobj = SWIG_Py_Void();
8384 return resultobj;
8385 fail:
8386 return NULL;
8387 }
8388
8389
8390 SWIGINTERN PyObject *_wrap_ToolTip_SetDelay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8391 PyObject *resultobj = 0;
8392 long arg1 ;
8393 long val1 ;
8394 int ecode1 = 0 ;
8395 PyObject * obj0 = 0 ;
8396 char * kwnames[] = {
8397 (char *) "milliseconds", NULL
8398 };
8399
8400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) SWIG_fail;
8401 ecode1 = SWIG_AsVal_long(obj0, &val1);
8402 if (!SWIG_IsOK(ecode1)) {
8403 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_SetDelay" "', expected argument " "1"" of type '" "long""'");
8404 }
8405 arg1 = static_cast< long >(val1);
8406 {
8407 PyThreadState* __tstate = wxPyBeginAllowThreads();
8408 wxToolTip::SetDelay(arg1);
8409 wxPyEndAllowThreads(__tstate);
8410 if (PyErr_Occurred()) SWIG_fail;
8411 }
8412 resultobj = SWIG_Py_Void();
8413 return resultobj;
8414 fail:
8415 return NULL;
8416 }
8417
8418
8419 SWIGINTERN PyObject *ToolTip_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8420 PyObject *obj;
8421 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8422 SWIG_TypeNewClientData(SWIGTYPE_p_wxToolTip, SWIG_NewClientData(obj));
8423 return SWIG_Py_Void();
8424 }
8425
8426 SWIGINTERN PyObject *ToolTip_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8427 return SWIG_Python_InitShadowInstance(args);
8428 }
8429
8430 SWIGINTERN PyObject *_wrap_new_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8431 PyObject *resultobj = 0;
8432 wxWindow *arg1 = (wxWindow *) 0 ;
8433 wxSize *arg2 = 0 ;
8434 wxCaret *result = 0 ;
8435 void *argp1 = 0 ;
8436 int res1 = 0 ;
8437 wxSize temp2 ;
8438 PyObject * obj0 = 0 ;
8439 PyObject * obj1 = 0 ;
8440 char * kwnames[] = {
8441 (char *) "window",(char *) "size", NULL
8442 };
8443
8444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) SWIG_fail;
8445 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
8446 if (!SWIG_IsOK(res1)) {
8447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Caret" "', expected argument " "1"" of type '" "wxWindow *""'");
8448 }
8449 arg1 = reinterpret_cast< wxWindow * >(argp1);
8450 {
8451 arg2 = &temp2;
8452 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8453 }
8454 {
8455 if (!wxPyCheckForApp()) SWIG_fail;
8456 PyThreadState* __tstate = wxPyBeginAllowThreads();
8457 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
8458 wxPyEndAllowThreads(__tstate);
8459 if (PyErr_Occurred()) SWIG_fail;
8460 }
8461 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, SWIG_POINTER_NEW | 0 );
8462 return resultobj;
8463 fail:
8464 return NULL;
8465 }
8466
8467
8468 SWIGINTERN PyObject *_wrap_delete_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8469 PyObject *resultobj = 0;
8470 wxCaret *arg1 = (wxCaret *) 0 ;
8471 void *argp1 = 0 ;
8472 int res1 = 0 ;
8473 PyObject *swig_obj[1] ;
8474
8475 if (!args) SWIG_fail;
8476 swig_obj[0] = args;
8477 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
8478 if (!SWIG_IsOK(res1)) {
8479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Caret" "', expected argument " "1"" of type '" "wxCaret *""'");
8480 }
8481 arg1 = reinterpret_cast< wxCaret * >(argp1);
8482 {
8483 PyThreadState* __tstate = wxPyBeginAllowThreads();
8484 delete arg1;
8485
8486 wxPyEndAllowThreads(__tstate);
8487 if (PyErr_Occurred()) SWIG_fail;
8488 }
8489 resultobj = SWIG_Py_Void();
8490 return resultobj;
8491 fail:
8492 return NULL;
8493 }
8494
8495
8496 SWIGINTERN PyObject *_wrap_Caret_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8497 PyObject *resultobj = 0;
8498 wxCaret *arg1 = (wxCaret *) 0 ;
8499 void *argp1 = 0 ;
8500 int res1 = 0 ;
8501 PyObject *swig_obj[1] ;
8502
8503 if (!args) SWIG_fail;
8504 swig_obj[0] = args;
8505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8506 if (!SWIG_IsOK(res1)) {
8507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Destroy" "', expected argument " "1"" of type '" "wxCaret *""'");
8508 }
8509 arg1 = reinterpret_cast< wxCaret * >(argp1);
8510 {
8511 PyThreadState* __tstate = wxPyBeginAllowThreads();
8512 wxCaret_Destroy(arg1);
8513 wxPyEndAllowThreads(__tstate);
8514 if (PyErr_Occurred()) SWIG_fail;
8515 }
8516 resultobj = SWIG_Py_Void();
8517 return resultobj;
8518 fail:
8519 return NULL;
8520 }
8521
8522
8523 SWIGINTERN PyObject *_wrap_Caret_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8524 PyObject *resultobj = 0;
8525 wxCaret *arg1 = (wxCaret *) 0 ;
8526 bool result;
8527 void *argp1 = 0 ;
8528 int res1 = 0 ;
8529 PyObject *swig_obj[1] ;
8530
8531 if (!args) SWIG_fail;
8532 swig_obj[0] = args;
8533 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8534 if (!SWIG_IsOK(res1)) {
8535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsOk" "', expected argument " "1"" of type '" "wxCaret *""'");
8536 }
8537 arg1 = reinterpret_cast< wxCaret * >(argp1);
8538 {
8539 PyThreadState* __tstate = wxPyBeginAllowThreads();
8540 result = (bool)(arg1)->IsOk();
8541 wxPyEndAllowThreads(__tstate);
8542 if (PyErr_Occurred()) SWIG_fail;
8543 }
8544 {
8545 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8546 }
8547 return resultobj;
8548 fail:
8549 return NULL;
8550 }
8551
8552
8553 SWIGINTERN PyObject *_wrap_Caret_IsVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8554 PyObject *resultobj = 0;
8555 wxCaret *arg1 = (wxCaret *) 0 ;
8556 bool result;
8557 void *argp1 = 0 ;
8558 int res1 = 0 ;
8559 PyObject *swig_obj[1] ;
8560
8561 if (!args) SWIG_fail;
8562 swig_obj[0] = args;
8563 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8564 if (!SWIG_IsOK(res1)) {
8565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsVisible" "', expected argument " "1"" of type '" "wxCaret *""'");
8566 }
8567 arg1 = reinterpret_cast< wxCaret * >(argp1);
8568 {
8569 PyThreadState* __tstate = wxPyBeginAllowThreads();
8570 result = (bool)(arg1)->IsVisible();
8571 wxPyEndAllowThreads(__tstate);
8572 if (PyErr_Occurred()) SWIG_fail;
8573 }
8574 {
8575 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8576 }
8577 return resultobj;
8578 fail:
8579 return NULL;
8580 }
8581
8582
8583 SWIGINTERN PyObject *_wrap_Caret_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8584 PyObject *resultobj = 0;
8585 wxCaret *arg1 = (wxCaret *) 0 ;
8586 wxPoint result;
8587 void *argp1 = 0 ;
8588 int res1 = 0 ;
8589 PyObject *swig_obj[1] ;
8590
8591 if (!args) SWIG_fail;
8592 swig_obj[0] = args;
8593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8594 if (!SWIG_IsOK(res1)) {
8595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPosition" "', expected argument " "1"" of type '" "wxCaret *""'");
8596 }
8597 arg1 = reinterpret_cast< wxCaret * >(argp1);
8598 {
8599 PyThreadState* __tstate = wxPyBeginAllowThreads();
8600 result = (arg1)->GetPosition();
8601 wxPyEndAllowThreads(__tstate);
8602 if (PyErr_Occurred()) SWIG_fail;
8603 }
8604 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
8605 return resultobj;
8606 fail:
8607 return NULL;
8608 }
8609
8610
8611 SWIGINTERN PyObject *_wrap_Caret_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8612 PyObject *resultobj = 0;
8613 wxCaret *arg1 = (wxCaret *) 0 ;
8614 int *arg2 = (int *) 0 ;
8615 int *arg3 = (int *) 0 ;
8616 void *argp1 = 0 ;
8617 int res1 = 0 ;
8618 int temp2 ;
8619 int res2 = SWIG_TMPOBJ ;
8620 int temp3 ;
8621 int res3 = SWIG_TMPOBJ ;
8622 PyObject *swig_obj[1] ;
8623
8624 arg2 = &temp2;
8625 arg3 = &temp3;
8626 if (!args) SWIG_fail;
8627 swig_obj[0] = args;
8628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8629 if (!SWIG_IsOK(res1)) {
8630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPositionTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8631 }
8632 arg1 = reinterpret_cast< wxCaret * >(argp1);
8633 {
8634 PyThreadState* __tstate = wxPyBeginAllowThreads();
8635 (arg1)->GetPosition(arg2,arg3);
8636 wxPyEndAllowThreads(__tstate);
8637 if (PyErr_Occurred()) SWIG_fail;
8638 }
8639 resultobj = SWIG_Py_Void();
8640 if (SWIG_IsTmpObj(res2)) {
8641 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8642 } else {
8643 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8644 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8645 }
8646 if (SWIG_IsTmpObj(res3)) {
8647 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8648 } else {
8649 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8650 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8651 }
8652 return resultobj;
8653 fail:
8654 return NULL;
8655 }
8656
8657
8658 SWIGINTERN PyObject *_wrap_Caret_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8659 PyObject *resultobj = 0;
8660 wxCaret *arg1 = (wxCaret *) 0 ;
8661 wxSize result;
8662 void *argp1 = 0 ;
8663 int res1 = 0 ;
8664 PyObject *swig_obj[1] ;
8665
8666 if (!args) SWIG_fail;
8667 swig_obj[0] = args;
8668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8669 if (!SWIG_IsOK(res1)) {
8670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8671 }
8672 arg1 = reinterpret_cast< wxCaret * >(argp1);
8673 {
8674 PyThreadState* __tstate = wxPyBeginAllowThreads();
8675 result = (arg1)->GetSize();
8676 wxPyEndAllowThreads(__tstate);
8677 if (PyErr_Occurred()) SWIG_fail;
8678 }
8679 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
8680 return resultobj;
8681 fail:
8682 return NULL;
8683 }
8684
8685
8686 SWIGINTERN PyObject *_wrap_Caret_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8687 PyObject *resultobj = 0;
8688 wxCaret *arg1 = (wxCaret *) 0 ;
8689 int *arg2 = (int *) 0 ;
8690 int *arg3 = (int *) 0 ;
8691 void *argp1 = 0 ;
8692 int res1 = 0 ;
8693 int temp2 ;
8694 int res2 = SWIG_TMPOBJ ;
8695 int temp3 ;
8696 int res3 = SWIG_TMPOBJ ;
8697 PyObject *swig_obj[1] ;
8698
8699 arg2 = &temp2;
8700 arg3 = &temp3;
8701 if (!args) SWIG_fail;
8702 swig_obj[0] = args;
8703 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8704 if (!SWIG_IsOK(res1)) {
8705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSizeTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8706 }
8707 arg1 = reinterpret_cast< wxCaret * >(argp1);
8708 {
8709 PyThreadState* __tstate = wxPyBeginAllowThreads();
8710 (arg1)->GetSize(arg2,arg3);
8711 wxPyEndAllowThreads(__tstate);
8712 if (PyErr_Occurred()) SWIG_fail;
8713 }
8714 resultobj = SWIG_Py_Void();
8715 if (SWIG_IsTmpObj(res2)) {
8716 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8717 } else {
8718 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8719 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8720 }
8721 if (SWIG_IsTmpObj(res3)) {
8722 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8723 } else {
8724 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8725 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8726 }
8727 return resultobj;
8728 fail:
8729 return NULL;
8730 }
8731
8732
8733 SWIGINTERN PyObject *_wrap_Caret_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8734 PyObject *resultobj = 0;
8735 wxCaret *arg1 = (wxCaret *) 0 ;
8736 wxWindow *result = 0 ;
8737 void *argp1 = 0 ;
8738 int res1 = 0 ;
8739 PyObject *swig_obj[1] ;
8740
8741 if (!args) SWIG_fail;
8742 swig_obj[0] = args;
8743 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8744 if (!SWIG_IsOK(res1)) {
8745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetWindow" "', expected argument " "1"" of type '" "wxCaret *""'");
8746 }
8747 arg1 = reinterpret_cast< wxCaret * >(argp1);
8748 {
8749 PyThreadState* __tstate = wxPyBeginAllowThreads();
8750 result = (wxWindow *)(arg1)->GetWindow();
8751 wxPyEndAllowThreads(__tstate);
8752 if (PyErr_Occurred()) SWIG_fail;
8753 }
8754 {
8755 resultobj = wxPyMake_wxObject(result, 0);
8756 }
8757 return resultobj;
8758 fail:
8759 return NULL;
8760 }
8761
8762
8763 SWIGINTERN PyObject *_wrap_Caret_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8764 PyObject *resultobj = 0;
8765 wxCaret *arg1 = (wxCaret *) 0 ;
8766 int arg2 ;
8767 int arg3 ;
8768 void *argp1 = 0 ;
8769 int res1 = 0 ;
8770 int val2 ;
8771 int ecode2 = 0 ;
8772 int val3 ;
8773 int ecode3 = 0 ;
8774 PyObject * obj0 = 0 ;
8775 PyObject * obj1 = 0 ;
8776 PyObject * obj2 = 0 ;
8777 char * kwnames[] = {
8778 (char *) "self",(char *) "x",(char *) "y", NULL
8779 };
8780
8781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8782 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8783 if (!SWIG_IsOK(res1)) {
8784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_MoveXY" "', expected argument " "1"" of type '" "wxCaret *""'");
8785 }
8786 arg1 = reinterpret_cast< wxCaret * >(argp1);
8787 ecode2 = SWIG_AsVal_int(obj1, &val2);
8788 if (!SWIG_IsOK(ecode2)) {
8789 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_MoveXY" "', expected argument " "2"" of type '" "int""'");
8790 }
8791 arg2 = static_cast< int >(val2);
8792 ecode3 = SWIG_AsVal_int(obj2, &val3);
8793 if (!SWIG_IsOK(ecode3)) {
8794 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_MoveXY" "', expected argument " "3"" of type '" "int""'");
8795 }
8796 arg3 = static_cast< int >(val3);
8797 {
8798 PyThreadState* __tstate = wxPyBeginAllowThreads();
8799 (arg1)->Move(arg2,arg3);
8800 wxPyEndAllowThreads(__tstate);
8801 if (PyErr_Occurred()) SWIG_fail;
8802 }
8803 resultobj = SWIG_Py_Void();
8804 return resultobj;
8805 fail:
8806 return NULL;
8807 }
8808
8809
8810 SWIGINTERN PyObject *_wrap_Caret_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8811 PyObject *resultobj = 0;
8812 wxCaret *arg1 = (wxCaret *) 0 ;
8813 wxPoint *arg2 = 0 ;
8814 void *argp1 = 0 ;
8815 int res1 = 0 ;
8816 wxPoint temp2 ;
8817 PyObject * obj0 = 0 ;
8818 PyObject * obj1 = 0 ;
8819 char * kwnames[] = {
8820 (char *) "self",(char *) "pt", NULL
8821 };
8822
8823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) SWIG_fail;
8824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8825 if (!SWIG_IsOK(res1)) {
8826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Move" "', expected argument " "1"" of type '" "wxCaret *""'");
8827 }
8828 arg1 = reinterpret_cast< wxCaret * >(argp1);
8829 {
8830 arg2 = &temp2;
8831 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
8832 }
8833 {
8834 PyThreadState* __tstate = wxPyBeginAllowThreads();
8835 (arg1)->Move((wxPoint const &)*arg2);
8836 wxPyEndAllowThreads(__tstate);
8837 if (PyErr_Occurred()) SWIG_fail;
8838 }
8839 resultobj = SWIG_Py_Void();
8840 return resultobj;
8841 fail:
8842 return NULL;
8843 }
8844
8845
8846 SWIGINTERN PyObject *_wrap_Caret_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8847 PyObject *resultobj = 0;
8848 wxCaret *arg1 = (wxCaret *) 0 ;
8849 int arg2 ;
8850 int arg3 ;
8851 void *argp1 = 0 ;
8852 int res1 = 0 ;
8853 int val2 ;
8854 int ecode2 = 0 ;
8855 int val3 ;
8856 int ecode3 = 0 ;
8857 PyObject * obj0 = 0 ;
8858 PyObject * obj1 = 0 ;
8859 PyObject * obj2 = 0 ;
8860 char * kwnames[] = {
8861 (char *) "self",(char *) "width",(char *) "height", NULL
8862 };
8863
8864 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8865 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8866 if (!SWIG_IsOK(res1)) {
8867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSizeWH" "', expected argument " "1"" of type '" "wxCaret *""'");
8868 }
8869 arg1 = reinterpret_cast< wxCaret * >(argp1);
8870 ecode2 = SWIG_AsVal_int(obj1, &val2);
8871 if (!SWIG_IsOK(ecode2)) {
8872 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
8873 }
8874 arg2 = static_cast< int >(val2);
8875 ecode3 = SWIG_AsVal_int(obj2, &val3);
8876 if (!SWIG_IsOK(ecode3)) {
8877 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
8878 }
8879 arg3 = static_cast< int >(val3);
8880 {
8881 PyThreadState* __tstate = wxPyBeginAllowThreads();
8882 (arg1)->SetSize(arg2,arg3);
8883 wxPyEndAllowThreads(__tstate);
8884 if (PyErr_Occurred()) SWIG_fail;
8885 }
8886 resultobj = SWIG_Py_Void();
8887 return resultobj;
8888 fail:
8889 return NULL;
8890 }
8891
8892
8893 SWIGINTERN PyObject *_wrap_Caret_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8894 PyObject *resultobj = 0;
8895 wxCaret *arg1 = (wxCaret *) 0 ;
8896 wxSize *arg2 = 0 ;
8897 void *argp1 = 0 ;
8898 int res1 = 0 ;
8899 wxSize temp2 ;
8900 PyObject * obj0 = 0 ;
8901 PyObject * obj1 = 0 ;
8902 char * kwnames[] = {
8903 (char *) "self",(char *) "size", NULL
8904 };
8905
8906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
8907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8908 if (!SWIG_IsOK(res1)) {
8909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8910 }
8911 arg1 = reinterpret_cast< wxCaret * >(argp1);
8912 {
8913 arg2 = &temp2;
8914 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8915 }
8916 {
8917 PyThreadState* __tstate = wxPyBeginAllowThreads();
8918 (arg1)->SetSize((wxSize const &)*arg2);
8919 wxPyEndAllowThreads(__tstate);
8920 if (PyErr_Occurred()) SWIG_fail;
8921 }
8922 resultobj = SWIG_Py_Void();
8923 return resultobj;
8924 fail:
8925 return NULL;
8926 }
8927
8928
8929 SWIGINTERN PyObject *_wrap_Caret_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8930 PyObject *resultobj = 0;
8931 wxCaret *arg1 = (wxCaret *) 0 ;
8932 int arg2 = (int) true ;
8933 void *argp1 = 0 ;
8934 int res1 = 0 ;
8935 int val2 ;
8936 int ecode2 = 0 ;
8937 PyObject * obj0 = 0 ;
8938 PyObject * obj1 = 0 ;
8939 char * kwnames[] = {
8940 (char *) "self",(char *) "show", NULL
8941 };
8942
8943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) SWIG_fail;
8944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8945 if (!SWIG_IsOK(res1)) {
8946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Show" "', expected argument " "1"" of type '" "wxCaret *""'");
8947 }
8948 arg1 = reinterpret_cast< wxCaret * >(argp1);
8949 if (obj1) {
8950 ecode2 = SWIG_AsVal_int(obj1, &val2);
8951 if (!SWIG_IsOK(ecode2)) {
8952 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_Show" "', expected argument " "2"" of type '" "int""'");
8953 }
8954 arg2 = static_cast< int >(val2);
8955 }
8956 {
8957 PyThreadState* __tstate = wxPyBeginAllowThreads();
8958 (arg1)->Show(arg2);
8959 wxPyEndAllowThreads(__tstate);
8960 if (PyErr_Occurred()) SWIG_fail;
8961 }
8962 resultobj = SWIG_Py_Void();
8963 return resultobj;
8964 fail:
8965 return NULL;
8966 }
8967
8968
8969 SWIGINTERN PyObject *_wrap_Caret_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8970 PyObject *resultobj = 0;
8971 wxCaret *arg1 = (wxCaret *) 0 ;
8972 void *argp1 = 0 ;
8973 int res1 = 0 ;
8974 PyObject *swig_obj[1] ;
8975
8976 if (!args) SWIG_fail;
8977 swig_obj[0] = args;
8978 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8979 if (!SWIG_IsOK(res1)) {
8980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Hide" "', expected argument " "1"" of type '" "wxCaret *""'");
8981 }
8982 arg1 = reinterpret_cast< wxCaret * >(argp1);
8983 {
8984 PyThreadState* __tstate = wxPyBeginAllowThreads();
8985 (arg1)->Hide();
8986 wxPyEndAllowThreads(__tstate);
8987 if (PyErr_Occurred()) SWIG_fail;
8988 }
8989 resultobj = SWIG_Py_Void();
8990 return resultobj;
8991 fail:
8992 return NULL;
8993 }
8994
8995
8996 SWIGINTERN PyObject *_wrap_Caret_GetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8997 PyObject *resultobj = 0;
8998 int result;
8999
9000 if (!SWIG_Python_UnpackTuple(args,"Caret_GetBlinkTime",0,0,0)) SWIG_fail;
9001 {
9002 PyThreadState* __tstate = wxPyBeginAllowThreads();
9003 result = (int)wxCaret::GetBlinkTime();
9004 wxPyEndAllowThreads(__tstate);
9005 if (PyErr_Occurred()) SWIG_fail;
9006 }
9007 resultobj = SWIG_From_int(static_cast< int >(result));
9008 return resultobj;
9009 fail:
9010 return NULL;
9011 }
9012
9013
9014 SWIGINTERN PyObject *_wrap_Caret_SetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9015 PyObject *resultobj = 0;
9016 int arg1 ;
9017 int val1 ;
9018 int ecode1 = 0 ;
9019 PyObject * obj0 = 0 ;
9020 char * kwnames[] = {
9021 (char *) "milliseconds", NULL
9022 };
9023
9024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) SWIG_fail;
9025 ecode1 = SWIG_AsVal_int(obj0, &val1);
9026 if (!SWIG_IsOK(ecode1)) {
9027 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Caret_SetBlinkTime" "', expected argument " "1"" of type '" "int""'");
9028 }
9029 arg1 = static_cast< int >(val1);
9030 {
9031 PyThreadState* __tstate = wxPyBeginAllowThreads();
9032 wxCaret::SetBlinkTime(arg1);
9033 wxPyEndAllowThreads(__tstate);
9034 if (PyErr_Occurred()) SWIG_fail;
9035 }
9036 resultobj = SWIG_Py_Void();
9037 return resultobj;
9038 fail:
9039 return NULL;
9040 }
9041
9042
9043 SWIGINTERN PyObject *Caret_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9044 PyObject *obj;
9045 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9046 SWIG_TypeNewClientData(SWIGTYPE_p_wxCaret, SWIG_NewClientData(obj));
9047 return SWIG_Py_Void();
9048 }
9049
9050 SWIGINTERN PyObject *Caret_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9051 return SWIG_Python_InitShadowInstance(args);
9052 }
9053
9054 SWIGINTERN PyObject *_wrap_new_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9055 PyObject *resultobj = 0;
9056 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
9057 wxBusyCursor *result = 0 ;
9058 void *argp1 = 0 ;
9059 int res1 = 0 ;
9060 PyObject * obj0 = 0 ;
9061 char * kwnames[] = {
9062 (char *) "cursor", NULL
9063 };
9064
9065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) SWIG_fail;
9066 if (obj0) {
9067 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
9068 if (!SWIG_IsOK(res1)) {
9069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
9070 }
9071 arg1 = reinterpret_cast< wxCursor * >(argp1);
9072 }
9073 {
9074 if (!wxPyCheckForApp()) SWIG_fail;
9075 PyThreadState* __tstate = wxPyBeginAllowThreads();
9076 result = (wxBusyCursor *)new wxBusyCursor(arg1);
9077 wxPyEndAllowThreads(__tstate);
9078 if (PyErr_Occurred()) SWIG_fail;
9079 }
9080 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_NEW | 0 );
9081 return resultobj;
9082 fail:
9083 return NULL;
9084 }
9085
9086
9087 SWIGINTERN PyObject *_wrap_delete_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9088 PyObject *resultobj = 0;
9089 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
9090 void *argp1 = 0 ;
9091 int res1 = 0 ;
9092 PyObject *swig_obj[1] ;
9093
9094 if (!args) SWIG_fail;
9095 swig_obj[0] = args;
9096 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_DISOWN | 0 );
9097 if (!SWIG_IsOK(res1)) {
9098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyCursor" "', expected argument " "1"" of type '" "wxBusyCursor *""'");
9099 }
9100 arg1 = reinterpret_cast< wxBusyCursor * >(argp1);
9101 {
9102 PyThreadState* __tstate = wxPyBeginAllowThreads();
9103 delete arg1;
9104
9105 wxPyEndAllowThreads(__tstate);
9106 if (PyErr_Occurred()) SWIG_fail;
9107 }
9108 resultobj = SWIG_Py_Void();
9109 return resultobj;
9110 fail:
9111 return NULL;
9112 }
9113
9114
9115 SWIGINTERN PyObject *BusyCursor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9116 PyObject *obj;
9117 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9118 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyCursor, SWIG_NewClientData(obj));
9119 return SWIG_Py_Void();
9120 }
9121
9122 SWIGINTERN PyObject *BusyCursor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9123 return SWIG_Python_InitShadowInstance(args);
9124 }
9125
9126 SWIGINTERN PyObject *_wrap_new_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9127 PyObject *resultobj = 0;
9128 wxWindow *arg1 = (wxWindow *) NULL ;
9129 wxWindowDisabler *result = 0 ;
9130 void *argp1 = 0 ;
9131 int res1 = 0 ;
9132 PyObject * obj0 = 0 ;
9133 char * kwnames[] = {
9134 (char *) "winToSkip", NULL
9135 };
9136
9137 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) SWIG_fail;
9138 if (obj0) {
9139 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
9140 if (!SWIG_IsOK(res1)) {
9141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDisabler" "', expected argument " "1"" of type '" "wxWindow *""'");
9142 }
9143 arg1 = reinterpret_cast< wxWindow * >(argp1);
9144 }
9145 {
9146 if (!wxPyCheckForApp()) SWIG_fail;
9147 PyThreadState* __tstate = wxPyBeginAllowThreads();
9148 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
9149 wxPyEndAllowThreads(__tstate);
9150 if (PyErr_Occurred()) SWIG_fail;
9151 }
9152 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_NEW | 0 );
9153 return resultobj;
9154 fail:
9155 return NULL;
9156 }
9157
9158
9159 SWIGINTERN PyObject *_wrap_delete_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9160 PyObject *resultobj = 0;
9161 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
9162 void *argp1 = 0 ;
9163 int res1 = 0 ;
9164 PyObject *swig_obj[1] ;
9165
9166 if (!args) SWIG_fail;
9167 swig_obj[0] = args;
9168 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_DISOWN | 0 );
9169 if (!SWIG_IsOK(res1)) {
9170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_WindowDisabler" "', expected argument " "1"" of type '" "wxWindowDisabler *""'");
9171 }
9172 arg1 = reinterpret_cast< wxWindowDisabler * >(argp1);
9173 {
9174 PyThreadState* __tstate = wxPyBeginAllowThreads();
9175 delete arg1;
9176
9177 wxPyEndAllowThreads(__tstate);
9178 if (PyErr_Occurred()) SWIG_fail;
9179 }
9180 resultobj = SWIG_Py_Void();
9181 return resultobj;
9182 fail:
9183 return NULL;
9184 }
9185
9186
9187 SWIGINTERN PyObject *WindowDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9188 PyObject *obj;
9189 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9190 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDisabler, SWIG_NewClientData(obj));
9191 return SWIG_Py_Void();
9192 }
9193
9194 SWIGINTERN PyObject *WindowDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9195 return SWIG_Python_InitShadowInstance(args);
9196 }
9197
9198 SWIGINTERN PyObject *_wrap_new_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9199 PyObject *resultobj = 0;
9200 wxString *arg1 = 0 ;
9201 wxWindow *arg2 = (wxWindow *) NULL ;
9202 wxBusyInfo *result = 0 ;
9203 bool temp1 = false ;
9204 void *argp2 = 0 ;
9205 int res2 = 0 ;
9206 PyObject * obj0 = 0 ;
9207 PyObject * obj1 = 0 ;
9208 char * kwnames[] = {
9209 (char *) "message",(char *) "parent", NULL
9210 };
9211
9212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_BusyInfo",kwnames,&obj0,&obj1)) SWIG_fail;
9213 {
9214 arg1 = wxString_in_helper(obj0);
9215 if (arg1 == NULL) SWIG_fail;
9216 temp1 = true;
9217 }
9218 if (obj1) {
9219 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
9220 if (!SWIG_IsOK(res2)) {
9221 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_BusyInfo" "', expected argument " "2"" of type '" "wxWindow *""'");
9222 }
9223 arg2 = reinterpret_cast< wxWindow * >(argp2);
9224 }
9225 {
9226 if (!wxPyCheckForApp()) SWIG_fail;
9227 PyThreadState* __tstate = wxPyBeginAllowThreads();
9228 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1,arg2);
9229 wxPyEndAllowThreads(__tstate);
9230 if (PyErr_Occurred()) SWIG_fail;
9231 }
9232 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_NEW | 0 );
9233 {
9234 if (temp1)
9235 delete arg1;
9236 }
9237 return resultobj;
9238 fail:
9239 {
9240 if (temp1)
9241 delete arg1;
9242 }
9243 return NULL;
9244 }
9245
9246
9247 SWIGINTERN PyObject *_wrap_delete_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9248 PyObject *resultobj = 0;
9249 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
9250 void *argp1 = 0 ;
9251 int res1 = 0 ;
9252 PyObject *swig_obj[1] ;
9253
9254 if (!args) SWIG_fail;
9255 swig_obj[0] = args;
9256 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_DISOWN | 0 );
9257 if (!SWIG_IsOK(res1)) {
9258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyInfo" "', expected argument " "1"" of type '" "wxBusyInfo *""'");
9259 }
9260 arg1 = reinterpret_cast< wxBusyInfo * >(argp1);
9261 {
9262 PyThreadState* __tstate = wxPyBeginAllowThreads();
9263 delete arg1;
9264
9265 wxPyEndAllowThreads(__tstate);
9266 if (PyErr_Occurred()) SWIG_fail;
9267 }
9268 resultobj = SWIG_Py_Void();
9269 return resultobj;
9270 fail:
9271 return NULL;
9272 }
9273
9274
9275 SWIGINTERN PyObject *BusyInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9276 PyObject *obj;
9277 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9278 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyInfo, SWIG_NewClientData(obj));
9279 return SWIG_Py_Void();
9280 }
9281
9282 SWIGINTERN PyObject *BusyInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9283 return SWIG_Python_InitShadowInstance(args);
9284 }
9285
9286 SWIGINTERN PyObject *_wrap_new_StopWatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9287 PyObject *resultobj = 0;
9288 wxStopWatch *result = 0 ;
9289
9290 if (!SWIG_Python_UnpackTuple(args,"new_StopWatch",0,0,0)) SWIG_fail;
9291 {
9292 PyThreadState* __tstate = wxPyBeginAllowThreads();
9293 result = (wxStopWatch *)new wxStopWatch();
9294 wxPyEndAllowThreads(__tstate);
9295 if (PyErr_Occurred()) SWIG_fail;
9296 }
9297 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStopWatch, SWIG_POINTER_NEW | 0 );
9298 return resultobj;
9299 fail:
9300 return NULL;
9301 }
9302
9303
9304 SWIGINTERN PyObject *_wrap_delete_StopWatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9305 PyObject *resultobj = 0;
9306 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9307 void *argp1 = 0 ;
9308 int res1 = 0 ;
9309 PyObject *swig_obj[1] ;
9310
9311 if (!args) SWIG_fail;
9312 swig_obj[0] = args;
9313 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, SWIG_POINTER_DISOWN | 0 );
9314 if (!SWIG_IsOK(res1)) {
9315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StopWatch" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9316 }
9317 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9318 {
9319 PyThreadState* __tstate = wxPyBeginAllowThreads();
9320 delete arg1;
9321
9322 wxPyEndAllowThreads(__tstate);
9323 if (PyErr_Occurred()) SWIG_fail;
9324 }
9325 resultobj = SWIG_Py_Void();
9326 return resultobj;
9327 fail:
9328 return NULL;
9329 }
9330
9331
9332 SWIGINTERN PyObject *_wrap_StopWatch_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9333 PyObject *resultobj = 0;
9334 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9335 long arg2 = (long) 0 ;
9336 void *argp1 = 0 ;
9337 int res1 = 0 ;
9338 long val2 ;
9339 int ecode2 = 0 ;
9340 PyObject * obj0 = 0 ;
9341 PyObject * obj1 = 0 ;
9342 char * kwnames[] = {
9343 (char *) "self",(char *) "t0", NULL
9344 };
9345
9346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) SWIG_fail;
9347 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9348 if (!SWIG_IsOK(res1)) {
9349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Start" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9350 }
9351 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9352 if (obj1) {
9353 ecode2 = SWIG_AsVal_long(obj1, &val2);
9354 if (!SWIG_IsOK(ecode2)) {
9355 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StopWatch_Start" "', expected argument " "2"" of type '" "long""'");
9356 }
9357 arg2 = static_cast< long >(val2);
9358 }
9359 {
9360 PyThreadState* __tstate = wxPyBeginAllowThreads();
9361 (arg1)->Start(arg2);
9362 wxPyEndAllowThreads(__tstate);
9363 if (PyErr_Occurred()) SWIG_fail;
9364 }
9365 resultobj = SWIG_Py_Void();
9366 return resultobj;
9367 fail:
9368 return NULL;
9369 }
9370
9371
9372 SWIGINTERN PyObject *_wrap_StopWatch_Pause(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9373 PyObject *resultobj = 0;
9374 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9375 void *argp1 = 0 ;
9376 int res1 = 0 ;
9377 PyObject *swig_obj[1] ;
9378
9379 if (!args) SWIG_fail;
9380 swig_obj[0] = args;
9381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9382 if (!SWIG_IsOK(res1)) {
9383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Pause" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9384 }
9385 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9386 {
9387 PyThreadState* __tstate = wxPyBeginAllowThreads();
9388 (arg1)->Pause();
9389 wxPyEndAllowThreads(__tstate);
9390 if (PyErr_Occurred()) SWIG_fail;
9391 }
9392 resultobj = SWIG_Py_Void();
9393 return resultobj;
9394 fail:
9395 return NULL;
9396 }
9397
9398
9399 SWIGINTERN PyObject *_wrap_StopWatch_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9400 PyObject *resultobj = 0;
9401 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
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_Resume" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9411 }
9412 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9413 {
9414 PyThreadState* __tstate = wxPyBeginAllowThreads();
9415 (arg1)->Resume();
9416 wxPyEndAllowThreads(__tstate);
9417 if (PyErr_Occurred()) SWIG_fail;
9418 }
9419 resultobj = SWIG_Py_Void();
9420 return resultobj;
9421 fail:
9422 return NULL;
9423 }
9424
9425
9426 SWIGINTERN PyObject *_wrap_StopWatch_Time(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9427 PyObject *resultobj = 0;
9428 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9429 long result;
9430 void *argp1 = 0 ;
9431 int res1 = 0 ;
9432 PyObject *swig_obj[1] ;
9433
9434 if (!args) SWIG_fail;
9435 swig_obj[0] = args;
9436 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9437 if (!SWIG_IsOK(res1)) {
9438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Time" "', expected argument " "1"" of type '" "wxStopWatch const *""'");
9439 }
9440 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9441 {
9442 PyThreadState* __tstate = wxPyBeginAllowThreads();
9443 result = (long)((wxStopWatch const *)arg1)->Time();
9444 wxPyEndAllowThreads(__tstate);
9445 if (PyErr_Occurred()) SWIG_fail;
9446 }
9447 resultobj = SWIG_From_long(static_cast< long >(result));
9448 return resultobj;
9449 fail:
9450 return NULL;
9451 }
9452
9453
9454 SWIGINTERN PyObject *StopWatch_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9455 PyObject *obj;
9456 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9457 SWIG_TypeNewClientData(SWIGTYPE_p_wxStopWatch, SWIG_NewClientData(obj));
9458 return SWIG_Py_Void();
9459 }
9460
9461 SWIGINTERN PyObject *StopWatch_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9462 return SWIG_Python_InitShadowInstance(args);
9463 }
9464
9465 SWIGINTERN PyObject *_wrap_new_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9466 PyObject *resultobj = 0;
9467 int arg1 = (int) 9 ;
9468 int arg2 = (int) wxID_FILE1 ;
9469 wxFileHistory *result = 0 ;
9470 int val1 ;
9471 int ecode1 = 0 ;
9472 int val2 ;
9473 int ecode2 = 0 ;
9474 PyObject * obj0 = 0 ;
9475 PyObject * obj1 = 0 ;
9476 char * kwnames[] = {
9477 (char *) "maxFiles",(char *) "idBase", NULL
9478 };
9479
9480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9481 if (obj0) {
9482 ecode1 = SWIG_AsVal_int(obj0, &val1);
9483 if (!SWIG_IsOK(ecode1)) {
9484 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FileHistory" "', expected argument " "1"" of type '" "int""'");
9485 }
9486 arg1 = static_cast< int >(val1);
9487 }
9488 if (obj1) {
9489 ecode2 = SWIG_AsVal_int(obj1, &val2);
9490 if (!SWIG_IsOK(ecode2)) {
9491 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FileHistory" "', expected argument " "2"" of type '" "int""'");
9492 }
9493 arg2 = static_cast< int >(val2);
9494 }
9495 {
9496 PyThreadState* __tstate = wxPyBeginAllowThreads();
9497 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
9498 wxPyEndAllowThreads(__tstate);
9499 if (PyErr_Occurred()) SWIG_fail;
9500 }
9501 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileHistory, SWIG_POINTER_NEW | 0 );
9502 return resultobj;
9503 fail:
9504 return NULL;
9505 }
9506
9507
9508 SWIGINTERN PyObject *_wrap_delete_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9509 PyObject *resultobj = 0;
9510 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9511 void *argp1 = 0 ;
9512 int res1 = 0 ;
9513 PyObject *swig_obj[1] ;
9514
9515 if (!args) SWIG_fail;
9516 swig_obj[0] = args;
9517 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, SWIG_POINTER_DISOWN | 0 );
9518 if (!SWIG_IsOK(res1)) {
9519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9520 }
9521 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9522 {
9523 PyThreadState* __tstate = wxPyBeginAllowThreads();
9524 delete arg1;
9525
9526 wxPyEndAllowThreads(__tstate);
9527 if (PyErr_Occurred()) SWIG_fail;
9528 }
9529 resultobj = SWIG_Py_Void();
9530 return resultobj;
9531 fail:
9532 return NULL;
9533 }
9534
9535
9536 SWIGINTERN PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9537 PyObject *resultobj = 0;
9538 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9539 wxString *arg2 = 0 ;
9540 void *argp1 = 0 ;
9541 int res1 = 0 ;
9542 bool temp2 = false ;
9543 PyObject * obj0 = 0 ;
9544 PyObject * obj1 = 0 ;
9545 char * kwnames[] = {
9546 (char *) "self",(char *) "file", NULL
9547 };
9548
9549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9551 if (!SWIG_IsOK(res1)) {
9552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFileToHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9553 }
9554 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9555 {
9556 arg2 = wxString_in_helper(obj1);
9557 if (arg2 == NULL) SWIG_fail;
9558 temp2 = true;
9559 }
9560 {
9561 PyThreadState* __tstate = wxPyBeginAllowThreads();
9562 (arg1)->AddFileToHistory((wxString const &)*arg2);
9563 wxPyEndAllowThreads(__tstate);
9564 if (PyErr_Occurred()) SWIG_fail;
9565 }
9566 resultobj = SWIG_Py_Void();
9567 {
9568 if (temp2)
9569 delete arg2;
9570 }
9571 return resultobj;
9572 fail:
9573 {
9574 if (temp2)
9575 delete arg2;
9576 }
9577 return NULL;
9578 }
9579
9580
9581 SWIGINTERN PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9582 PyObject *resultobj = 0;
9583 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9584 int arg2 ;
9585 void *argp1 = 0 ;
9586 int res1 = 0 ;
9587 int val2 ;
9588 int ecode2 = 0 ;
9589 PyObject * obj0 = 0 ;
9590 PyObject * obj1 = 0 ;
9591 char * kwnames[] = {
9592 (char *) "self",(char *) "i", NULL
9593 };
9594
9595 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9596 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9597 if (!SWIG_IsOK(res1)) {
9598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9599 }
9600 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9601 ecode2 = SWIG_AsVal_int(obj1, &val2);
9602 if (!SWIG_IsOK(ecode2)) {
9603 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "2"" of type '" "int""'");
9604 }
9605 arg2 = static_cast< int >(val2);
9606 {
9607 PyThreadState* __tstate = wxPyBeginAllowThreads();
9608 (arg1)->RemoveFileFromHistory(arg2);
9609 wxPyEndAllowThreads(__tstate);
9610 if (PyErr_Occurred()) SWIG_fail;
9611 }
9612 resultobj = SWIG_Py_Void();
9613 return resultobj;
9614 fail:
9615 return NULL;
9616 }
9617
9618
9619 SWIGINTERN PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9620 PyObject *resultobj = 0;
9621 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9622 int result;
9623 void *argp1 = 0 ;
9624 int res1 = 0 ;
9625 PyObject *swig_obj[1] ;
9626
9627 if (!args) SWIG_fail;
9628 swig_obj[0] = args;
9629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9630 if (!SWIG_IsOK(res1)) {
9631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetMaxFiles" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9632 }
9633 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9634 {
9635 PyThreadState* __tstate = wxPyBeginAllowThreads();
9636 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
9637 wxPyEndAllowThreads(__tstate);
9638 if (PyErr_Occurred()) SWIG_fail;
9639 }
9640 resultobj = SWIG_From_int(static_cast< int >(result));
9641 return resultobj;
9642 fail:
9643 return NULL;
9644 }
9645
9646
9647 SWIGINTERN PyObject *_wrap_FileHistory_UseMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9648 PyObject *resultobj = 0;
9649 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9650 wxMenu *arg2 = (wxMenu *) 0 ;
9651 void *argp1 = 0 ;
9652 int res1 = 0 ;
9653 void *argp2 = 0 ;
9654 int res2 = 0 ;
9655 PyObject * obj0 = 0 ;
9656 PyObject * obj1 = 0 ;
9657 char * kwnames[] = {
9658 (char *) "self",(char *) "menu", NULL
9659 };
9660
9661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9662 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9663 if (!SWIG_IsOK(res1)) {
9664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_UseMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9665 }
9666 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9667 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9668 if (!SWIG_IsOK(res2)) {
9669 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_UseMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9670 }
9671 arg2 = reinterpret_cast< wxMenu * >(argp2);
9672 {
9673 PyThreadState* __tstate = wxPyBeginAllowThreads();
9674 (arg1)->UseMenu(arg2);
9675 wxPyEndAllowThreads(__tstate);
9676 if (PyErr_Occurred()) SWIG_fail;
9677 }
9678 resultobj = SWIG_Py_Void();
9679 return resultobj;
9680 fail:
9681 return NULL;
9682 }
9683
9684
9685 SWIGINTERN PyObject *_wrap_FileHistory_RemoveMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9686 PyObject *resultobj = 0;
9687 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9688 wxMenu *arg2 = (wxMenu *) 0 ;
9689 void *argp1 = 0 ;
9690 int res1 = 0 ;
9691 void *argp2 = 0 ;
9692 int res2 = 0 ;
9693 PyObject * obj0 = 0 ;
9694 PyObject * obj1 = 0 ;
9695 char * kwnames[] = {
9696 (char *) "self",(char *) "menu", NULL
9697 };
9698
9699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9700 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9701 if (!SWIG_IsOK(res1)) {
9702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9703 }
9704 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9705 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9706 if (!SWIG_IsOK(res2)) {
9707 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_RemoveMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9708 }
9709 arg2 = reinterpret_cast< wxMenu * >(argp2);
9710 {
9711 PyThreadState* __tstate = wxPyBeginAllowThreads();
9712 (arg1)->RemoveMenu(arg2);
9713 wxPyEndAllowThreads(__tstate);
9714 if (PyErr_Occurred()) SWIG_fail;
9715 }
9716 resultobj = SWIG_Py_Void();
9717 return resultobj;
9718 fail:
9719 return NULL;
9720 }
9721
9722
9723 SWIGINTERN PyObject *_wrap_FileHistory_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9724 PyObject *resultobj = 0;
9725 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9726 wxConfigBase *arg2 = 0 ;
9727 void *argp1 = 0 ;
9728 int res1 = 0 ;
9729 void *argp2 = 0 ;
9730 int res2 = 0 ;
9731 PyObject * obj0 = 0 ;
9732 PyObject * obj1 = 0 ;
9733 char * kwnames[] = {
9734 (char *) "self",(char *) "config", NULL
9735 };
9736
9737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) SWIG_fail;
9738 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9739 if (!SWIG_IsOK(res1)) {
9740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Load" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9741 }
9742 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9743 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9744 if (!SWIG_IsOK(res2)) {
9745 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9746 }
9747 if (!argp2) {
9748 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9749 }
9750 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9751 {
9752 PyThreadState* __tstate = wxPyBeginAllowThreads();
9753 (arg1)->Load(*arg2);
9754 wxPyEndAllowThreads(__tstate);
9755 if (PyErr_Occurred()) SWIG_fail;
9756 }
9757 resultobj = SWIG_Py_Void();
9758 return resultobj;
9759 fail:
9760 return NULL;
9761 }
9762
9763
9764 SWIGINTERN PyObject *_wrap_FileHistory_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9765 PyObject *resultobj = 0;
9766 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9767 wxConfigBase *arg2 = 0 ;
9768 void *argp1 = 0 ;
9769 int res1 = 0 ;
9770 void *argp2 = 0 ;
9771 int res2 = 0 ;
9772 PyObject * obj0 = 0 ;
9773 PyObject * obj1 = 0 ;
9774 char * kwnames[] = {
9775 (char *) "self",(char *) "config", NULL
9776 };
9777
9778 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) SWIG_fail;
9779 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9780 if (!SWIG_IsOK(res1)) {
9781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Save" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9782 }
9783 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9784 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9785 if (!SWIG_IsOK(res2)) {
9786 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9787 }
9788 if (!argp2) {
9789 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9790 }
9791 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9792 {
9793 PyThreadState* __tstate = wxPyBeginAllowThreads();
9794 (arg1)->Save(*arg2);
9795 wxPyEndAllowThreads(__tstate);
9796 if (PyErr_Occurred()) SWIG_fail;
9797 }
9798 resultobj = SWIG_Py_Void();
9799 return resultobj;
9800 fail:
9801 return NULL;
9802 }
9803
9804
9805 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9806 PyObject *resultobj = 0;
9807 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9808 void *argp1 = 0 ;
9809 int res1 = 0 ;
9810 PyObject *swig_obj[1] ;
9811
9812 if (!args) SWIG_fail;
9813 swig_obj[0] = args;
9814 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9815 if (!SWIG_IsOK(res1)) {
9816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9817 }
9818 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9819 {
9820 PyThreadState* __tstate = wxPyBeginAllowThreads();
9821 (arg1)->AddFilesToMenu();
9822 wxPyEndAllowThreads(__tstate);
9823 if (PyErr_Occurred()) SWIG_fail;
9824 }
9825 resultobj = SWIG_Py_Void();
9826 return resultobj;
9827 fail:
9828 return NULL;
9829 }
9830
9831
9832 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9833 PyObject *resultobj = 0;
9834 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9835 wxMenu *arg2 = (wxMenu *) 0 ;
9836 void *argp1 = 0 ;
9837 int res1 = 0 ;
9838 void *argp2 = 0 ;
9839 int res2 = 0 ;
9840 PyObject * obj0 = 0 ;
9841 PyObject * obj1 = 0 ;
9842 char * kwnames[] = {
9843 (char *) "self",(char *) "menu", NULL
9844 };
9845
9846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9847 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9848 if (!SWIG_IsOK(res1)) {
9849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9850 }
9851 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9852 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9853 if (!SWIG_IsOK(res2)) {
9854 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9855 }
9856 arg2 = reinterpret_cast< wxMenu * >(argp2);
9857 {
9858 PyThreadState* __tstate = wxPyBeginAllowThreads();
9859 (arg1)->AddFilesToMenu(arg2);
9860 wxPyEndAllowThreads(__tstate);
9861 if (PyErr_Occurred()) SWIG_fail;
9862 }
9863 resultobj = SWIG_Py_Void();
9864 return resultobj;
9865 fail:
9866 return NULL;
9867 }
9868
9869
9870 SWIGINTERN PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9871 PyObject *resultobj = 0;
9872 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9873 int arg2 ;
9874 wxString result;
9875 void *argp1 = 0 ;
9876 int res1 = 0 ;
9877 int val2 ;
9878 int ecode2 = 0 ;
9879 PyObject * obj0 = 0 ;
9880 PyObject * obj1 = 0 ;
9881 char * kwnames[] = {
9882 (char *) "self",(char *) "i", NULL
9883 };
9884
9885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) SWIG_fail;
9886 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9887 if (!SWIG_IsOK(res1)) {
9888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9889 }
9890 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9891 ecode2 = SWIG_AsVal_int(obj1, &val2);
9892 if (!SWIG_IsOK(ecode2)) {
9893 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "2"" of type '" "int""'");
9894 }
9895 arg2 = static_cast< int >(val2);
9896 {
9897 PyThreadState* __tstate = wxPyBeginAllowThreads();
9898 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
9899 wxPyEndAllowThreads(__tstate);
9900 if (PyErr_Occurred()) SWIG_fail;
9901 }
9902 {
9903 #if wxUSE_UNICODE
9904 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9905 #else
9906 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9907 #endif
9908 }
9909 return resultobj;
9910 fail:
9911 return NULL;
9912 }
9913
9914
9915 SWIGINTERN PyObject *_wrap_FileHistory_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9916 PyObject *resultobj = 0;
9917 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9918 int result;
9919 void *argp1 = 0 ;
9920 int res1 = 0 ;
9921 PyObject *swig_obj[1] ;
9922
9923 if (!args) SWIG_fail;
9924 swig_obj[0] = args;
9925 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9926 if (!SWIG_IsOK(res1)) {
9927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetCount" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9928 }
9929 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9930 {
9931 PyThreadState* __tstate = wxPyBeginAllowThreads();
9932 result = (int)((wxFileHistory const *)arg1)->GetCount();
9933 wxPyEndAllowThreads(__tstate);
9934 if (PyErr_Occurred()) SWIG_fail;
9935 }
9936 resultobj = SWIG_From_int(static_cast< int >(result));
9937 return resultobj;
9938 fail:
9939 return NULL;
9940 }
9941
9942
9943 SWIGINTERN PyObject *FileHistory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9944 PyObject *obj;
9945 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9946 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileHistory, SWIG_NewClientData(obj));
9947 return SWIG_Py_Void();
9948 }
9949
9950 SWIGINTERN PyObject *FileHistory_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9951 return SWIG_Python_InitShadowInstance(args);
9952 }
9953
9954 SWIGINTERN PyObject *_wrap_new_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9955 PyObject *resultobj = 0;
9956 wxString *arg1 = 0 ;
9957 wxString const &arg2_defvalue = wxPyEmptyString ;
9958 wxString *arg2 = (wxString *) &arg2_defvalue ;
9959 wxSingleInstanceChecker *result = 0 ;
9960 bool temp1 = false ;
9961 bool temp2 = false ;
9962 PyObject * obj0 = 0 ;
9963 PyObject * obj1 = 0 ;
9964 char * kwnames[] = {
9965 (char *) "name",(char *) "path", NULL
9966 };
9967
9968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) SWIG_fail;
9969 {
9970 arg1 = wxString_in_helper(obj0);
9971 if (arg1 == NULL) SWIG_fail;
9972 temp1 = true;
9973 }
9974 if (obj1) {
9975 {
9976 arg2 = wxString_in_helper(obj1);
9977 if (arg2 == NULL) SWIG_fail;
9978 temp2 = true;
9979 }
9980 }
9981 {
9982 PyThreadState* __tstate = wxPyBeginAllowThreads();
9983 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
9984 wxPyEndAllowThreads(__tstate);
9985 if (PyErr_Occurred()) SWIG_fail;
9986 }
9987 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_NEW | 0 );
9988 {
9989 if (temp1)
9990 delete arg1;
9991 }
9992 {
9993 if (temp2)
9994 delete arg2;
9995 }
9996 return resultobj;
9997 fail:
9998 {
9999 if (temp1)
10000 delete arg1;
10001 }
10002 {
10003 if (temp2)
10004 delete arg2;
10005 }
10006 return NULL;
10007 }
10008
10009
10010 SWIGINTERN PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10011 PyObject *resultobj = 0;
10012 wxSingleInstanceChecker *result = 0 ;
10013
10014 if (!SWIG_Python_UnpackTuple(args,"new_PreSingleInstanceChecker",0,0,0)) SWIG_fail;
10015 {
10016 PyThreadState* __tstate = wxPyBeginAllowThreads();
10017 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
10018 wxPyEndAllowThreads(__tstate);
10019 if (PyErr_Occurred()) SWIG_fail;
10020 }
10021 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_OWN | 0 );
10022 return resultobj;
10023 fail:
10024 return NULL;
10025 }
10026
10027
10028 SWIGINTERN PyObject *_wrap_delete_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10029 PyObject *resultobj = 0;
10030 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
10031 void *argp1 = 0 ;
10032 int res1 = 0 ;
10033 PyObject *swig_obj[1] ;
10034
10035 if (!args) SWIG_fail;
10036 swig_obj[0] = args;
10037 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_DISOWN | 0 );
10038 if (!SWIG_IsOK(res1)) {
10039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SingleInstanceChecker" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
10040 }
10041 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
10042 {
10043 PyThreadState* __tstate = wxPyBeginAllowThreads();
10044 delete arg1;
10045
10046 wxPyEndAllowThreads(__tstate);
10047 if (PyErr_Occurred()) SWIG_fail;
10048 }
10049 resultobj = SWIG_Py_Void();
10050 return resultobj;
10051 fail:
10052 return NULL;
10053 }
10054
10055
10056 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10057 PyObject *resultobj = 0;
10058 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
10059 wxString *arg2 = 0 ;
10060 wxString const &arg3_defvalue = wxPyEmptyString ;
10061 wxString *arg3 = (wxString *) &arg3_defvalue ;
10062 bool result;
10063 void *argp1 = 0 ;
10064 int res1 = 0 ;
10065 bool temp2 = false ;
10066 bool temp3 = false ;
10067 PyObject * obj0 = 0 ;
10068 PyObject * obj1 = 0 ;
10069 PyObject * obj2 = 0 ;
10070 char * kwnames[] = {
10071 (char *) "self",(char *) "name",(char *) "path", NULL
10072 };
10073
10074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
10076 if (!SWIG_IsOK(res1)) {
10077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_Create" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
10078 }
10079 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
10080 {
10081 arg2 = wxString_in_helper(obj1);
10082 if (arg2 == NULL) SWIG_fail;
10083 temp2 = true;
10084 }
10085 if (obj2) {
10086 {
10087 arg3 = wxString_in_helper(obj2);
10088 if (arg3 == NULL) SWIG_fail;
10089 temp3 = true;
10090 }
10091 }
10092 {
10093 PyThreadState* __tstate = wxPyBeginAllowThreads();
10094 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
10095 wxPyEndAllowThreads(__tstate);
10096 if (PyErr_Occurred()) SWIG_fail;
10097 }
10098 {
10099 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10100 }
10101 {
10102 if (temp2)
10103 delete arg2;
10104 }
10105 {
10106 if (temp3)
10107 delete arg3;
10108 }
10109 return resultobj;
10110 fail:
10111 {
10112 if (temp2)
10113 delete arg2;
10114 }
10115 {
10116 if (temp3)
10117 delete arg3;
10118 }
10119 return NULL;
10120 }
10121
10122
10123 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10124 PyObject *resultobj = 0;
10125 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
10126 bool result;
10127 void *argp1 = 0 ;
10128 int res1 = 0 ;
10129 PyObject *swig_obj[1] ;
10130
10131 if (!args) SWIG_fail;
10132 swig_obj[0] = args;
10133 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
10134 if (!SWIG_IsOK(res1)) {
10135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_IsAnotherRunning" "', expected argument " "1"" of type '" "wxSingleInstanceChecker const *""'");
10136 }
10137 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
10138 {
10139 PyThreadState* __tstate = wxPyBeginAllowThreads();
10140 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
10141 wxPyEndAllowThreads(__tstate);
10142 if (PyErr_Occurred()) SWIG_fail;
10143 }
10144 {
10145 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10146 }
10147 return resultobj;
10148 fail:
10149 return NULL;
10150 }
10151
10152
10153 SWIGINTERN PyObject *SingleInstanceChecker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10154 PyObject *obj;
10155 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10156 SWIG_TypeNewClientData(SWIGTYPE_p_wxSingleInstanceChecker, SWIG_NewClientData(obj));
10157 return SWIG_Py_Void();
10158 }
10159
10160 SWIGINTERN PyObject *SingleInstanceChecker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10161 return SWIG_Python_InitShadowInstance(args);
10162 }
10163
10164 SWIGINTERN PyObject *_wrap_new_PlatformInformation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10165 PyObject *resultobj = 0;
10166 wxPlatformInfo *result = 0 ;
10167
10168 if (!SWIG_Python_UnpackTuple(args,"new_PlatformInformation",0,0,0)) SWIG_fail;
10169 {
10170 PyThreadState* __tstate = wxPyBeginAllowThreads();
10171 result = (wxPlatformInfo *)new wxPlatformInfo();
10172 wxPyEndAllowThreads(__tstate);
10173 if (PyErr_Occurred()) SWIG_fail;
10174 }
10175 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPlatformInfo, SWIG_POINTER_NEW | 0 );
10176 return resultobj;
10177 fail:
10178 return NULL;
10179 }
10180
10181
10182 SWIGINTERN PyObject *_wrap_PlatformInformation___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10183 PyObject *resultobj = 0;
10184 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10185 wxPlatformInfo *arg2 = 0 ;
10186 bool result;
10187 void *argp1 = 0 ;
10188 int res1 = 0 ;
10189 void *argp2 = 0 ;
10190 int res2 = 0 ;
10191 PyObject * obj0 = 0 ;
10192 PyObject * obj1 = 0 ;
10193 char * kwnames[] = {
10194 (char *) "self",(char *) "t", NULL
10195 };
10196
10197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
10198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10199 if (!SWIG_IsOK(res1)) {
10200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation___eq__" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10201 }
10202 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10203 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPlatformInfo, 0 | 0);
10204 if (!SWIG_IsOK(res2)) {
10205 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PlatformInformation___eq__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10206 }
10207 if (!argp2) {
10208 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PlatformInformation___eq__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10209 }
10210 arg2 = reinterpret_cast< wxPlatformInfo * >(argp2);
10211 {
10212 PyThreadState* __tstate = wxPyBeginAllowThreads();
10213 result = (bool)((wxPlatformInfo const *)arg1)->operator ==((wxPlatformInfo const &)*arg2);
10214 wxPyEndAllowThreads(__tstate);
10215 if (PyErr_Occurred()) SWIG_fail;
10216 }
10217 {
10218 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10219 }
10220 return resultobj;
10221 fail:
10222 return NULL;
10223 }
10224
10225
10226 SWIGINTERN PyObject *_wrap_PlatformInformation___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10227 PyObject *resultobj = 0;
10228 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10229 wxPlatformInfo *arg2 = 0 ;
10230 bool result;
10231 void *argp1 = 0 ;
10232 int res1 = 0 ;
10233 void *argp2 = 0 ;
10234 int res2 = 0 ;
10235 PyObject * obj0 = 0 ;
10236 PyObject * obj1 = 0 ;
10237 char * kwnames[] = {
10238 (char *) "self",(char *) "t", NULL
10239 };
10240
10241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
10242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10243 if (!SWIG_IsOK(res1)) {
10244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation___ne__" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10245 }
10246 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10247 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPlatformInfo, 0 | 0);
10248 if (!SWIG_IsOK(res2)) {
10249 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PlatformInformation___ne__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10250 }
10251 if (!argp2) {
10252 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PlatformInformation___ne__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10253 }
10254 arg2 = reinterpret_cast< wxPlatformInfo * >(argp2);
10255 {
10256 PyThreadState* __tstate = wxPyBeginAllowThreads();
10257 result = (bool)((wxPlatformInfo const *)arg1)->operator !=((wxPlatformInfo const &)*arg2);
10258 wxPyEndAllowThreads(__tstate);
10259 if (PyErr_Occurred()) SWIG_fail;
10260 }
10261 {
10262 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10263 }
10264 return resultobj;
10265 fail:
10266 return NULL;
10267 }
10268
10269
10270 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOSMajorVersion(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_GetOSMajorVersion" "', 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)->GetOSMajorVersion();
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_GetOSMinorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10299 PyObject *resultobj = 0;
10300 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10301 int result;
10302 void *argp1 = 0 ;
10303 int res1 = 0 ;
10304 PyObject *swig_obj[1] ;
10305
10306 if (!args) SWIG_fail;
10307 swig_obj[0] = args;
10308 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10309 if (!SWIG_IsOK(res1)) {
10310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOSMinorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10311 }
10312 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10313 {
10314 PyThreadState* __tstate = wxPyBeginAllowThreads();
10315 result = (int)((wxPlatformInfo const *)arg1)->GetOSMinorVersion();
10316 wxPyEndAllowThreads(__tstate);
10317 if (PyErr_Occurred()) SWIG_fail;
10318 }
10319 resultobj = SWIG_From_int(static_cast< int >(result));
10320 return resultobj;
10321 fail:
10322 return NULL;
10323 }
10324
10325
10326 SWIGINTERN PyObject *_wrap_PlatformInformation_CheckOSVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10327 PyObject *resultobj = 0;
10328 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10329 int arg2 ;
10330 int arg3 ;
10331 bool result;
10332 void *argp1 = 0 ;
10333 int res1 = 0 ;
10334 int val2 ;
10335 int ecode2 = 0 ;
10336 int val3 ;
10337 int ecode3 = 0 ;
10338 PyObject * obj0 = 0 ;
10339 PyObject * obj1 = 0 ;
10340 PyObject * obj2 = 0 ;
10341 char * kwnames[] = {
10342 (char *) "self",(char *) "major",(char *) "minor", NULL
10343 };
10344
10345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_CheckOSVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10346 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10347 if (!SWIG_IsOK(res1)) {
10348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_CheckOSVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10349 }
10350 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10351 ecode2 = SWIG_AsVal_int(obj1, &val2);
10352 if (!SWIG_IsOK(ecode2)) {
10353 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_CheckOSVersion" "', expected argument " "2"" of type '" "int""'");
10354 }
10355 arg2 = static_cast< int >(val2);
10356 ecode3 = SWIG_AsVal_int(obj2, &val3);
10357 if (!SWIG_IsOK(ecode3)) {
10358 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_CheckOSVersion" "', expected argument " "3"" of type '" "int""'");
10359 }
10360 arg3 = static_cast< int >(val3);
10361 {
10362 PyThreadState* __tstate = wxPyBeginAllowThreads();
10363 result = (bool)((wxPlatformInfo const *)arg1)->CheckOSVersion(arg2,arg3);
10364 wxPyEndAllowThreads(__tstate);
10365 if (PyErr_Occurred()) SWIG_fail;
10366 }
10367 {
10368 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10369 }
10370 return resultobj;
10371 fail:
10372 return NULL;
10373 }
10374
10375
10376 SWIGINTERN PyObject *_wrap_PlatformInformation_GetToolkitMajorVersion(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_GetToolkitMajorVersion" "', 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)->GetToolkitMajorVersion();
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_GetToolkitMinorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10405 PyObject *resultobj = 0;
10406 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10407 int result;
10408 void *argp1 = 0 ;
10409 int res1 = 0 ;
10410 PyObject *swig_obj[1] ;
10411
10412 if (!args) SWIG_fail;
10413 swig_obj[0] = args;
10414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10415 if (!SWIG_IsOK(res1)) {
10416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetToolkitMinorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10417 }
10418 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10419 {
10420 PyThreadState* __tstate = wxPyBeginAllowThreads();
10421 result = (int)((wxPlatformInfo const *)arg1)->GetToolkitMinorVersion();
10422 wxPyEndAllowThreads(__tstate);
10423 if (PyErr_Occurred()) SWIG_fail;
10424 }
10425 resultobj = SWIG_From_int(static_cast< int >(result));
10426 return resultobj;
10427 fail:
10428 return NULL;
10429 }
10430
10431
10432 SWIGINTERN PyObject *_wrap_PlatformInformation_CheckToolkitVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10433 PyObject *resultobj = 0;
10434 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10435 int arg2 ;
10436 int arg3 ;
10437 bool result;
10438 void *argp1 = 0 ;
10439 int res1 = 0 ;
10440 int val2 ;
10441 int ecode2 = 0 ;
10442 int val3 ;
10443 int ecode3 = 0 ;
10444 PyObject * obj0 = 0 ;
10445 PyObject * obj1 = 0 ;
10446 PyObject * obj2 = 0 ;
10447 char * kwnames[] = {
10448 (char *) "self",(char *) "major",(char *) "minor", NULL
10449 };
10450
10451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_CheckToolkitVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10452 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10453 if (!SWIG_IsOK(res1)) {
10454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_CheckToolkitVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10455 }
10456 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10457 ecode2 = SWIG_AsVal_int(obj1, &val2);
10458 if (!SWIG_IsOK(ecode2)) {
10459 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_CheckToolkitVersion" "', expected argument " "2"" of type '" "int""'");
10460 }
10461 arg2 = static_cast< int >(val2);
10462 ecode3 = SWIG_AsVal_int(obj2, &val3);
10463 if (!SWIG_IsOK(ecode3)) {
10464 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_CheckToolkitVersion" "', expected argument " "3"" of type '" "int""'");
10465 }
10466 arg3 = static_cast< int >(val3);
10467 {
10468 PyThreadState* __tstate = wxPyBeginAllowThreads();
10469 result = (bool)((wxPlatformInfo const *)arg1)->CheckToolkitVersion(arg2,arg3);
10470 wxPyEndAllowThreads(__tstate);
10471 if (PyErr_Occurred()) SWIG_fail;
10472 }
10473 {
10474 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10475 }
10476 return resultobj;
10477 fail:
10478 return NULL;
10479 }
10480
10481
10482 SWIGINTERN PyObject *_wrap_PlatformInformation_IsUsingUniversalWidgets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10483 PyObject *resultobj = 0;
10484 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10485 bool result;
10486 void *argp1 = 0 ;
10487 int res1 = 0 ;
10488 PyObject *swig_obj[1] ;
10489
10490 if (!args) SWIG_fail;
10491 swig_obj[0] = args;
10492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10493 if (!SWIG_IsOK(res1)) {
10494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_IsUsingUniversalWidgets" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10495 }
10496 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10497 {
10498 PyThreadState* __tstate = wxPyBeginAllowThreads();
10499 result = (bool)((wxPlatformInfo const *)arg1)->IsUsingUniversalWidgets();
10500 wxPyEndAllowThreads(__tstate);
10501 if (PyErr_Occurred()) SWIG_fail;
10502 }
10503 {
10504 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10505 }
10506 return resultobj;
10507 fail:
10508 return NULL;
10509 }
10510
10511
10512 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10513 PyObject *resultobj = 0;
10514 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10515 wxOperatingSystemId 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_GetOperatingSystemId" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10525 }
10526 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10527 {
10528 PyThreadState* __tstate = wxPyBeginAllowThreads();
10529 result = (wxOperatingSystemId)((wxPlatformInfo const *)arg1)->GetOperatingSystemId();
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_GetPortId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10541 PyObject *resultobj = 0;
10542 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10543 wxPortId 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_GetPortId" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10553 }
10554 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10555 {
10556 PyThreadState* __tstate = wxPyBeginAllowThreads();
10557 result = (wxPortId)((wxPlatformInfo const *)arg1)->GetPortId();
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_GetArchitecture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10569 PyObject *resultobj = 0;
10570 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10571 wxArchitecture 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_GetArchitecture" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10581 }
10582 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10583 {
10584 PyThreadState* __tstate = wxPyBeginAllowThreads();
10585 result = (wxArchitecture)((wxPlatformInfo const *)arg1)->GetArchitecture();
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_GetEndianness(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10597 PyObject *resultobj = 0;
10598 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10599 wxEndianness 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_GetEndianness" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10609 }
10610 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10611 {
10612 PyThreadState* __tstate = wxPyBeginAllowThreads();
10613 result = (wxEndianness)((wxPlatformInfo const *)arg1)->GetEndianness();
10614 wxPyEndAllowThreads(__tstate);
10615 if (PyErr_Occurred()) SWIG_fail;
10616 }
10617 resultobj = SWIG_From_int(static_cast< int >(result));
10618 return resultobj;
10619 fail:
10620 return NULL;
10621 }
10622
10623
10624 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemFamilyName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10625 PyObject *resultobj = 0;
10626 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10627 wxString result;
10628 void *argp1 = 0 ;
10629 int res1 = 0 ;
10630 PyObject *swig_obj[1] ;
10631
10632 if (!args) SWIG_fail;
10633 swig_obj[0] = args;
10634 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10635 if (!SWIG_IsOK(res1)) {
10636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOperatingSystemFamilyName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10637 }
10638 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10639 {
10640 PyThreadState* __tstate = wxPyBeginAllowThreads();
10641 result = ((wxPlatformInfo const *)arg1)->GetOperatingSystemFamilyName();
10642 wxPyEndAllowThreads(__tstate);
10643 if (PyErr_Occurred()) SWIG_fail;
10644 }
10645 {
10646 #if wxUSE_UNICODE
10647 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10648 #else
10649 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10650 #endif
10651 }
10652 return resultobj;
10653 fail:
10654 return NULL;
10655 }
10656
10657
10658 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemIdName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10659 PyObject *resultobj = 0;
10660 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10661 wxString result;
10662 void *argp1 = 0 ;
10663 int res1 = 0 ;
10664 PyObject *swig_obj[1] ;
10665
10666 if (!args) SWIG_fail;
10667 swig_obj[0] = args;
10668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10669 if (!SWIG_IsOK(res1)) {
10670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOperatingSystemIdName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10671 }
10672 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10673 {
10674 PyThreadState* __tstate = wxPyBeginAllowThreads();
10675 result = ((wxPlatformInfo const *)arg1)->GetOperatingSystemIdName();
10676 wxPyEndAllowThreads(__tstate);
10677 if (PyErr_Occurred()) SWIG_fail;
10678 }
10679 {
10680 #if wxUSE_UNICODE
10681 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10682 #else
10683 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10684 #endif
10685 }
10686 return resultobj;
10687 fail:
10688 return NULL;
10689 }
10690
10691
10692 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortIdName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10693 PyObject *resultobj = 0;
10694 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10695 wxString result;
10696 void *argp1 = 0 ;
10697 int res1 = 0 ;
10698 PyObject *swig_obj[1] ;
10699
10700 if (!args) SWIG_fail;
10701 swig_obj[0] = args;
10702 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10703 if (!SWIG_IsOK(res1)) {
10704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortIdName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10705 }
10706 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10707 {
10708 PyThreadState* __tstate = wxPyBeginAllowThreads();
10709 result = ((wxPlatformInfo const *)arg1)->GetPortIdName();
10710 wxPyEndAllowThreads(__tstate);
10711 if (PyErr_Occurred()) SWIG_fail;
10712 }
10713 {
10714 #if wxUSE_UNICODE
10715 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10716 #else
10717 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10718 #endif
10719 }
10720 return resultobj;
10721 fail:
10722 return NULL;
10723 }
10724
10725
10726 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortIdShortName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10727 PyObject *resultobj = 0;
10728 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10729 wxString result;
10730 void *argp1 = 0 ;
10731 int res1 = 0 ;
10732 PyObject *swig_obj[1] ;
10733
10734 if (!args) SWIG_fail;
10735 swig_obj[0] = args;
10736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10737 if (!SWIG_IsOK(res1)) {
10738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortIdShortName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10739 }
10740 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10741 {
10742 PyThreadState* __tstate = wxPyBeginAllowThreads();
10743 result = ((wxPlatformInfo const *)arg1)->GetPortIdShortName();
10744 wxPyEndAllowThreads(__tstate);
10745 if (PyErr_Occurred()) SWIG_fail;
10746 }
10747 {
10748 #if wxUSE_UNICODE
10749 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10750 #else
10751 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10752 #endif
10753 }
10754 return resultobj;
10755 fail:
10756 return NULL;
10757 }
10758
10759
10760 SWIGINTERN PyObject *_wrap_PlatformInformation_GetArchName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10761 PyObject *resultobj = 0;
10762 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10763 wxString result;
10764 void *argp1 = 0 ;
10765 int res1 = 0 ;
10766 PyObject *swig_obj[1] ;
10767
10768 if (!args) SWIG_fail;
10769 swig_obj[0] = args;
10770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10771 if (!SWIG_IsOK(res1)) {
10772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetArchName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10773 }
10774 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10775 {
10776 PyThreadState* __tstate = wxPyBeginAllowThreads();
10777 result = ((wxPlatformInfo const *)arg1)->GetArchName();
10778 wxPyEndAllowThreads(__tstate);
10779 if (PyErr_Occurred()) SWIG_fail;
10780 }
10781 {
10782 #if wxUSE_UNICODE
10783 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10784 #else
10785 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10786 #endif
10787 }
10788 return resultobj;
10789 fail:
10790 return NULL;
10791 }
10792
10793
10794 SWIGINTERN PyObject *_wrap_PlatformInformation_GetEndiannessName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10795 PyObject *resultobj = 0;
10796 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10797 wxString result;
10798 void *argp1 = 0 ;
10799 int res1 = 0 ;
10800 PyObject *swig_obj[1] ;
10801
10802 if (!args) SWIG_fail;
10803 swig_obj[0] = args;
10804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10805 if (!SWIG_IsOK(res1)) {
10806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetEndiannessName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10807 }
10808 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10809 {
10810 PyThreadState* __tstate = wxPyBeginAllowThreads();
10811 result = ((wxPlatformInfo const *)arg1)->GetEndiannessName();
10812 wxPyEndAllowThreads(__tstate);
10813 if (PyErr_Occurred()) SWIG_fail;
10814 }
10815 {
10816 #if wxUSE_UNICODE
10817 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10818 #else
10819 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10820 #endif
10821 }
10822 return resultobj;
10823 fail:
10824 return NULL;
10825 }
10826
10827
10828 SWIGINTERN PyObject *_wrap_PlatformInformation_SetOSVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10829 PyObject *resultobj = 0;
10830 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10831 int arg2 ;
10832 int arg3 ;
10833 void *argp1 = 0 ;
10834 int res1 = 0 ;
10835 int val2 ;
10836 int ecode2 = 0 ;
10837 int val3 ;
10838 int ecode3 = 0 ;
10839 PyObject * obj0 = 0 ;
10840 PyObject * obj1 = 0 ;
10841 PyObject * obj2 = 0 ;
10842 char * kwnames[] = {
10843 (char *) "self",(char *) "major",(char *) "minor", NULL
10844 };
10845
10846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_SetOSVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10847 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10848 if (!SWIG_IsOK(res1)) {
10849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10850 }
10851 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10852 ecode2 = SWIG_AsVal_int(obj1, &val2);
10853 if (!SWIG_IsOK(ecode2)) {
10854 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "2"" of type '" "int""'");
10855 }
10856 arg2 = static_cast< int >(val2);
10857 ecode3 = SWIG_AsVal_int(obj2, &val3);
10858 if (!SWIG_IsOK(ecode3)) {
10859 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "3"" of type '" "int""'");
10860 }
10861 arg3 = static_cast< int >(val3);
10862 {
10863 PyThreadState* __tstate = wxPyBeginAllowThreads();
10864 (arg1)->SetOSVersion(arg2,arg3);
10865 wxPyEndAllowThreads(__tstate);
10866 if (PyErr_Occurred()) SWIG_fail;
10867 }
10868 resultobj = SWIG_Py_Void();
10869 return resultobj;
10870 fail:
10871 return NULL;
10872 }
10873
10874
10875 SWIGINTERN PyObject *_wrap_PlatformInformation_SetToolkitVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10876 PyObject *resultobj = 0;
10877 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10878 int arg2 ;
10879 int arg3 ;
10880 void *argp1 = 0 ;
10881 int res1 = 0 ;
10882 int val2 ;
10883 int ecode2 = 0 ;
10884 int val3 ;
10885 int ecode3 = 0 ;
10886 PyObject * obj0 = 0 ;
10887 PyObject * obj1 = 0 ;
10888 PyObject * obj2 = 0 ;
10889 char * kwnames[] = {
10890 (char *) "self",(char *) "major",(char *) "minor", NULL
10891 };
10892
10893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_SetToolkitVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10895 if (!SWIG_IsOK(res1)) {
10896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetToolkitVersion" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10897 }
10898 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10899 ecode2 = SWIG_AsVal_int(obj1, &val2);
10900 if (!SWIG_IsOK(ecode2)) {
10901 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetToolkitVersion" "', expected argument " "2"" of type '" "int""'");
10902 }
10903 arg2 = static_cast< int >(val2);
10904 ecode3 = SWIG_AsVal_int(obj2, &val3);
10905 if (!SWIG_IsOK(ecode3)) {
10906 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_SetToolkitVersion" "', expected argument " "3"" of type '" "int""'");
10907 }
10908 arg3 = static_cast< int >(val3);
10909 {
10910 PyThreadState* __tstate = wxPyBeginAllowThreads();
10911 (arg1)->SetToolkitVersion(arg2,arg3);
10912 wxPyEndAllowThreads(__tstate);
10913 if (PyErr_Occurred()) SWIG_fail;
10914 }
10915 resultobj = SWIG_Py_Void();
10916 return resultobj;
10917 fail:
10918 return NULL;
10919 }
10920
10921
10922 SWIGINTERN PyObject *_wrap_PlatformInformation_SetOperatingSystemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10923 PyObject *resultobj = 0;
10924 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10925 wxOperatingSystemId arg2 ;
10926 void *argp1 = 0 ;
10927 int res1 = 0 ;
10928 int val2 ;
10929 int ecode2 = 0 ;
10930 PyObject * obj0 = 0 ;
10931 PyObject * obj1 = 0 ;
10932 char * kwnames[] = {
10933 (char *) "self",(char *) "n", NULL
10934 };
10935
10936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetOperatingSystemId",kwnames,&obj0,&obj1)) SWIG_fail;
10937 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10938 if (!SWIG_IsOK(res1)) {
10939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetOperatingSystemId" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10940 }
10941 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10942 ecode2 = SWIG_AsVal_int(obj1, &val2);
10943 if (!SWIG_IsOK(ecode2)) {
10944 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetOperatingSystemId" "', expected argument " "2"" of type '" "wxOperatingSystemId""'");
10945 }
10946 arg2 = static_cast< wxOperatingSystemId >(val2);
10947 {
10948 PyThreadState* __tstate = wxPyBeginAllowThreads();
10949 (arg1)->SetOperatingSystemId(arg2);
10950 wxPyEndAllowThreads(__tstate);
10951 if (PyErr_Occurred()) SWIG_fail;
10952 }
10953 resultobj = SWIG_Py_Void();
10954 return resultobj;
10955 fail:
10956 return NULL;
10957 }
10958
10959
10960 SWIGINTERN PyObject *_wrap_PlatformInformation_SetPortId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10961 PyObject *resultobj = 0;
10962 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10963 wxPortId arg2 ;
10964 void *argp1 = 0 ;
10965 int res1 = 0 ;
10966 int val2 ;
10967 int ecode2 = 0 ;
10968 PyObject * obj0 = 0 ;
10969 PyObject * obj1 = 0 ;
10970 char * kwnames[] = {
10971 (char *) "self",(char *) "n", NULL
10972 };
10973
10974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetPortId",kwnames,&obj0,&obj1)) SWIG_fail;
10975 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10976 if (!SWIG_IsOK(res1)) {
10977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetPortId" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10978 }
10979 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10980 ecode2 = SWIG_AsVal_int(obj1, &val2);
10981 if (!SWIG_IsOK(ecode2)) {
10982 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetPortId" "', expected argument " "2"" of type '" "wxPortId""'");
10983 }
10984 arg2 = static_cast< wxPortId >(val2);
10985 {
10986 PyThreadState* __tstate = wxPyBeginAllowThreads();
10987 (arg1)->SetPortId(arg2);
10988 wxPyEndAllowThreads(__tstate);
10989 if (PyErr_Occurred()) SWIG_fail;
10990 }
10991 resultobj = SWIG_Py_Void();
10992 return resultobj;
10993 fail:
10994 return NULL;
10995 }
10996
10997
10998 SWIGINTERN PyObject *_wrap_PlatformInformation_SetArchitecture(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10999 PyObject *resultobj = 0;
11000 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
11001 wxArchitecture arg2 ;
11002 void *argp1 = 0 ;
11003 int res1 = 0 ;
11004 int val2 ;
11005 int ecode2 = 0 ;
11006 PyObject * obj0 = 0 ;
11007 PyObject * obj1 = 0 ;
11008 char * kwnames[] = {
11009 (char *) "self",(char *) "n", NULL
11010 };
11011
11012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetArchitecture",kwnames,&obj0,&obj1)) SWIG_fail;
11013 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
11014 if (!SWIG_IsOK(res1)) {
11015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetArchitecture" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
11016 }
11017 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
11018 ecode2 = SWIG_AsVal_int(obj1, &val2);
11019 if (!SWIG_IsOK(ecode2)) {
11020 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetArchitecture" "', expected argument " "2"" of type '" "wxArchitecture""'");
11021 }
11022 arg2 = static_cast< wxArchitecture >(val2);
11023 {
11024 PyThreadState* __tstate = wxPyBeginAllowThreads();
11025 (arg1)->SetArchitecture(arg2);
11026 wxPyEndAllowThreads(__tstate);
11027 if (PyErr_Occurred()) SWIG_fail;
11028 }
11029 resultobj = SWIG_Py_Void();
11030 return resultobj;
11031 fail:
11032 return NULL;
11033 }
11034
11035
11036 SWIGINTERN PyObject *_wrap_PlatformInformation_SetEndianness(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11037 PyObject *resultobj = 0;
11038 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
11039 wxEndianness arg2 ;
11040 void *argp1 = 0 ;
11041 int res1 = 0 ;
11042 int val2 ;
11043 int ecode2 = 0 ;
11044 PyObject * obj0 = 0 ;
11045 PyObject * obj1 = 0 ;
11046 char * kwnames[] = {
11047 (char *) "self",(char *) "n", NULL
11048 };
11049
11050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetEndianness",kwnames,&obj0,&obj1)) SWIG_fail;
11051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
11052 if (!SWIG_IsOK(res1)) {
11053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetEndianness" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
11054 }
11055 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
11056 ecode2 = SWIG_AsVal_int(obj1, &val2);
11057 if (!SWIG_IsOK(ecode2)) {
11058 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetEndianness" "', expected argument " "2"" of type '" "wxEndianness""'");
11059 }
11060 arg2 = static_cast< wxEndianness >(val2);
11061 {
11062 PyThreadState* __tstate = wxPyBeginAllowThreads();
11063 (arg1)->SetEndianness(arg2);
11064 wxPyEndAllowThreads(__tstate);
11065 if (PyErr_Occurred()) SWIG_fail;
11066 }
11067 resultobj = SWIG_Py_Void();
11068 return resultobj;
11069 fail:
11070 return NULL;
11071 }
11072
11073
11074 SWIGINTERN PyObject *_wrap_PlatformInformation_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11075 PyObject *resultobj = 0;
11076 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
11077 bool result;
11078 void *argp1 = 0 ;
11079 int res1 = 0 ;
11080 PyObject *swig_obj[1] ;
11081
11082 if (!args) SWIG_fail;
11083 swig_obj[0] = args;
11084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
11085 if (!SWIG_IsOK(res1)) {
11086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_IsOk" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
11087 }
11088 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
11089 {
11090 PyThreadState* __tstate = wxPyBeginAllowThreads();
11091 result = (bool)((wxPlatformInfo const *)arg1)->IsOk();
11092 wxPyEndAllowThreads(__tstate);
11093 if (PyErr_Occurred()) SWIG_fail;
11094 }
11095 {
11096 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11097 }
11098 return resultobj;
11099 fail:
11100 return NULL;
11101 }
11102
11103
11104 SWIGINTERN PyObject *PlatformInformation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11105 PyObject *obj;
11106 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11107 SWIG_TypeNewClientData(SWIGTYPE_p_wxPlatformInfo, SWIG_NewClientData(obj));
11108 return SWIG_Py_Void();
11109 }
11110
11111 SWIGINTERN PyObject *PlatformInformation_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11112 return SWIG_Python_InitShadowInstance(args);
11113 }
11114
11115 SWIGINTERN PyObject *_wrap_DrawWindowOnDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11116 PyObject *resultobj = 0;
11117 wxWindow *arg1 = (wxWindow *) 0 ;
11118 wxDC *arg2 = 0 ;
11119 bool result;
11120 void *argp1 = 0 ;
11121 int res1 = 0 ;
11122 void *argp2 = 0 ;
11123 int res2 = 0 ;
11124 PyObject * obj0 = 0 ;
11125 PyObject * obj1 = 0 ;
11126 char * kwnames[] = {
11127 (char *) "window",(char *) "dc", NULL
11128 };
11129
11130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DrawWindowOnDC",kwnames,&obj0,&obj1)) SWIG_fail;
11131 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
11132 if (!SWIG_IsOK(res1)) {
11133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DrawWindowOnDC" "', expected argument " "1"" of type '" "wxWindow *""'");
11134 }
11135 arg1 = reinterpret_cast< wxWindow * >(argp1);
11136 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
11137 if (!SWIG_IsOK(res2)) {
11138 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
11139 }
11140 if (!argp2) {
11141 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
11142 }
11143 arg2 = reinterpret_cast< wxDC * >(argp2);
11144 {
11145 PyThreadState* __tstate = wxPyBeginAllowThreads();
11146 result = (bool)wxDrawWindowOnDC(arg1,(wxDC const &)*arg2);
11147 wxPyEndAllowThreads(__tstate);
11148 if (PyErr_Occurred()) SWIG_fail;
11149 }
11150 {
11151 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11152 }
11153 return resultobj;
11154 fail:
11155 return NULL;
11156 }
11157
11158
11159 SWIGINTERN PyObject *_wrap_delete_TipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11160 PyObject *resultobj = 0;
11161 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11162 void *argp1 = 0 ;
11163 int res1 = 0 ;
11164 PyObject *swig_obj[1] ;
11165
11166 if (!args) SWIG_fail;
11167 swig_obj[0] = args;
11168 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, SWIG_POINTER_DISOWN | 0 );
11169 if (!SWIG_IsOK(res1)) {
11170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TipProvider" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11171 }
11172 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11173 {
11174 PyThreadState* __tstate = wxPyBeginAllowThreads();
11175 delete arg1;
11176
11177 wxPyEndAllowThreads(__tstate);
11178 if (PyErr_Occurred()) SWIG_fail;
11179 }
11180 resultobj = SWIG_Py_Void();
11181 return resultobj;
11182 fail:
11183 return NULL;
11184 }
11185
11186
11187 SWIGINTERN PyObject *_wrap_TipProvider_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11188 PyObject *resultobj = 0;
11189 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11190 wxString result;
11191 void *argp1 = 0 ;
11192 int res1 = 0 ;
11193 PyObject *swig_obj[1] ;
11194
11195 if (!args) SWIG_fail;
11196 swig_obj[0] = args;
11197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11198 if (!SWIG_IsOK(res1)) {
11199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11200 }
11201 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11202 {
11203 PyThreadState* __tstate = wxPyBeginAllowThreads();
11204 result = (arg1)->GetTip();
11205 wxPyEndAllowThreads(__tstate);
11206 if (PyErr_Occurred()) SWIG_fail;
11207 }
11208 {
11209 #if wxUSE_UNICODE
11210 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11211 #else
11212 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11213 #endif
11214 }
11215 return resultobj;
11216 fail:
11217 return NULL;
11218 }
11219
11220
11221 SWIGINTERN PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11222 PyObject *resultobj = 0;
11223 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11224 size_t result;
11225 void *argp1 = 0 ;
11226 int res1 = 0 ;
11227 PyObject *swig_obj[1] ;
11228
11229 if (!args) SWIG_fail;
11230 swig_obj[0] = args;
11231 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11232 if (!SWIG_IsOK(res1)) {
11233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetCurrentTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11234 }
11235 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11236 {
11237 PyThreadState* __tstate = wxPyBeginAllowThreads();
11238 result = (size_t)(arg1)->GetCurrentTip();
11239 wxPyEndAllowThreads(__tstate);
11240 if (PyErr_Occurred()) SWIG_fail;
11241 }
11242 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
11243 return resultobj;
11244 fail:
11245 return NULL;
11246 }
11247
11248
11249 SWIGINTERN PyObject *_wrap_TipProvider_PreprocessTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11250 PyObject *resultobj = 0;
11251 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11252 wxString *arg2 = 0 ;
11253 wxString result;
11254 void *argp1 = 0 ;
11255 int res1 = 0 ;
11256 bool temp2 = false ;
11257 PyObject * obj0 = 0 ;
11258 PyObject * obj1 = 0 ;
11259 char * kwnames[] = {
11260 (char *) "self",(char *) "tip", NULL
11261 };
11262
11263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) SWIG_fail;
11264 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11265 if (!SWIG_IsOK(res1)) {
11266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_PreprocessTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11267 }
11268 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11269 {
11270 arg2 = wxString_in_helper(obj1);
11271 if (arg2 == NULL) SWIG_fail;
11272 temp2 = true;
11273 }
11274 {
11275 PyThreadState* __tstate = wxPyBeginAllowThreads();
11276 result = (arg1)->PreprocessTip((wxString const &)*arg2);
11277 wxPyEndAllowThreads(__tstate);
11278 if (PyErr_Occurred()) SWIG_fail;
11279 }
11280 {
11281 #if wxUSE_UNICODE
11282 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11283 #else
11284 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11285 #endif
11286 }
11287 {
11288 if (temp2)
11289 delete arg2;
11290 }
11291 return resultobj;
11292 fail:
11293 {
11294 if (temp2)
11295 delete arg2;
11296 }
11297 return NULL;
11298 }
11299
11300
11301 SWIGINTERN PyObject *TipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11302 PyObject *obj;
11303 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11304 SWIG_TypeNewClientData(SWIGTYPE_p_wxTipProvider, SWIG_NewClientData(obj));
11305 return SWIG_Py_Void();
11306 }
11307
11308 SWIGINTERN PyObject *_wrap_new_PyTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11309 PyObject *resultobj = 0;
11310 size_t arg1 ;
11311 wxPyTipProvider *result = 0 ;
11312 size_t val1 ;
11313 int ecode1 = 0 ;
11314 PyObject * obj0 = 0 ;
11315 char * kwnames[] = {
11316 (char *) "currentTip", NULL
11317 };
11318
11319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) SWIG_fail;
11320 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
11321 if (!SWIG_IsOK(ecode1)) {
11322 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyTipProvider" "', expected argument " "1"" of type '" "size_t""'");
11323 }
11324 arg1 = static_cast< size_t >(val1);
11325 {
11326 PyThreadState* __tstate = wxPyBeginAllowThreads();
11327 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
11328 wxPyEndAllowThreads(__tstate);
11329 if (PyErr_Occurred()) SWIG_fail;
11330 }
11331 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_NEW | 0 );
11332 return resultobj;
11333 fail:
11334 return NULL;
11335 }
11336
11337
11338 SWIGINTERN PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11339 PyObject *resultobj = 0;
11340 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
11341 PyObject *arg2 = (PyObject *) 0 ;
11342 PyObject *arg3 = (PyObject *) 0 ;
11343 void *argp1 = 0 ;
11344 int res1 = 0 ;
11345 PyObject * obj0 = 0 ;
11346 PyObject * obj1 = 0 ;
11347 PyObject * obj2 = 0 ;
11348 char * kwnames[] = {
11349 (char *) "self",(char *) "self",(char *) "_class", NULL
11350 };
11351
11352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11353 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTipProvider, 0 | 0 );
11354 if (!SWIG_IsOK(res1)) {
11355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTipProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTipProvider *""'");
11356 }
11357 arg1 = reinterpret_cast< wxPyTipProvider * >(argp1);
11358 arg2 = obj1;
11359 arg3 = obj2;
11360 {
11361 PyThreadState* __tstate = wxPyBeginAllowThreads();
11362 (arg1)->_setCallbackInfo(arg2,arg3);
11363 wxPyEndAllowThreads(__tstate);
11364 if (PyErr_Occurred()) SWIG_fail;
11365 }
11366 resultobj = SWIG_Py_Void();
11367 return resultobj;
11368 fail:
11369 return NULL;
11370 }
11371
11372
11373 SWIGINTERN PyObject *PyTipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11374 PyObject *obj;
11375 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11376 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTipProvider, SWIG_NewClientData(obj));
11377 return SWIG_Py_Void();
11378 }
11379
11380 SWIGINTERN PyObject *PyTipProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11381 return SWIG_Python_InitShadowInstance(args);
11382 }
11383
11384 SWIGINTERN PyObject *_wrap_ShowTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11385 PyObject *resultobj = 0;
11386 wxWindow *arg1 = (wxWindow *) 0 ;
11387 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
11388 bool arg3 = (bool) true ;
11389 bool result;
11390 void *argp1 = 0 ;
11391 int res1 = 0 ;
11392 void *argp2 = 0 ;
11393 int res2 = 0 ;
11394 bool val3 ;
11395 int ecode3 = 0 ;
11396 PyObject * obj0 = 0 ;
11397 PyObject * obj1 = 0 ;
11398 PyObject * obj2 = 0 ;
11399 char * kwnames[] = {
11400 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
11401 };
11402
11403 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11404 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
11405 if (!SWIG_IsOK(res1)) {
11406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowTip" "', expected argument " "1"" of type '" "wxWindow *""'");
11407 }
11408 arg1 = reinterpret_cast< wxWindow * >(argp1);
11409 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11410 if (!SWIG_IsOK(res2)) {
11411 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShowTip" "', expected argument " "2"" of type '" "wxTipProvider *""'");
11412 }
11413 arg2 = reinterpret_cast< wxTipProvider * >(argp2);
11414 if (obj2) {
11415 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11416 if (!SWIG_IsOK(ecode3)) {
11417 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ShowTip" "', expected argument " "3"" of type '" "bool""'");
11418 }
11419 arg3 = static_cast< bool >(val3);
11420 }
11421 {
11422 if (!wxPyCheckForApp()) SWIG_fail;
11423 PyThreadState* __tstate = wxPyBeginAllowThreads();
11424 result = (bool)wxShowTip(arg1,arg2,arg3);
11425 wxPyEndAllowThreads(__tstate);
11426 if (PyErr_Occurred()) SWIG_fail;
11427 }
11428 {
11429 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11430 }
11431 return resultobj;
11432 fail:
11433 return NULL;
11434 }
11435
11436
11437 SWIGINTERN PyObject *_wrap_CreateFileTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11438 PyObject *resultobj = 0;
11439 wxString *arg1 = 0 ;
11440 size_t arg2 ;
11441 wxTipProvider *result = 0 ;
11442 bool temp1 = false ;
11443 size_t val2 ;
11444 int ecode2 = 0 ;
11445 PyObject * obj0 = 0 ;
11446 PyObject * obj1 = 0 ;
11447 char * kwnames[] = {
11448 (char *) "filename",(char *) "currentTip", NULL
11449 };
11450
11451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) SWIG_fail;
11452 {
11453 arg1 = wxString_in_helper(obj0);
11454 if (arg1 == NULL) SWIG_fail;
11455 temp1 = true;
11456 }
11457 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
11458 if (!SWIG_IsOK(ecode2)) {
11459 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CreateFileTipProvider" "', expected argument " "2"" of type '" "size_t""'");
11460 }
11461 arg2 = static_cast< size_t >(val2);
11462 {
11463 if (!wxPyCheckForApp()) SWIG_fail;
11464 PyThreadState* __tstate = wxPyBeginAllowThreads();
11465 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
11466 wxPyEndAllowThreads(__tstate);
11467 if (PyErr_Occurred()) SWIG_fail;
11468 }
11469 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTipProvider, SWIG_POINTER_OWN | 0 );
11470 {
11471 if (temp1)
11472 delete arg1;
11473 }
11474 return resultobj;
11475 fail:
11476 {
11477 if (temp1)
11478 delete arg1;
11479 }
11480 return NULL;
11481 }
11482
11483
11484 SWIGINTERN PyObject *_wrap_new_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11485 PyObject *resultobj = 0;
11486 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
11487 int arg2 = (int) wxID_ANY ;
11488 wxPyTimer *result = 0 ;
11489 void *argp1 = 0 ;
11490 int res1 = 0 ;
11491 int val2 ;
11492 int ecode2 = 0 ;
11493 PyObject * obj0 = 0 ;
11494 PyObject * obj1 = 0 ;
11495 char * kwnames[] = {
11496 (char *) "owner",(char *) "id", NULL
11497 };
11498
11499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) SWIG_fail;
11500 if (obj0) {
11501 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
11502 if (!SWIG_IsOK(res1)) {
11503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Timer" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
11504 }
11505 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
11506 }
11507 if (obj1) {
11508 ecode2 = SWIG_AsVal_int(obj1, &val2);
11509 if (!SWIG_IsOK(ecode2)) {
11510 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Timer" "', expected argument " "2"" of type '" "int""'");
11511 }
11512 arg2 = static_cast< int >(val2);
11513 }
11514 {
11515 if (!wxPyCheckForApp()) SWIG_fail;
11516 PyThreadState* __tstate = wxPyBeginAllowThreads();
11517 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
11518 wxPyEndAllowThreads(__tstate);
11519 if (PyErr_Occurred()) SWIG_fail;
11520 }
11521 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTimer, SWIG_POINTER_NEW | 0 );
11522 return resultobj;
11523 fail:
11524 return NULL;
11525 }
11526
11527
11528 SWIGINTERN PyObject *_wrap_delete_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11529 PyObject *resultobj = 0;
11530 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11531 void *argp1 = 0 ;
11532 int res1 = 0 ;
11533 PyObject *swig_obj[1] ;
11534
11535 if (!args) SWIG_fail;
11536 swig_obj[0] = args;
11537 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, SWIG_POINTER_DISOWN | 0 );
11538 if (!SWIG_IsOK(res1)) {
11539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Timer" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11540 }
11541 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11542 {
11543 PyThreadState* __tstate = wxPyBeginAllowThreads();
11544 delete arg1;
11545
11546 wxPyEndAllowThreads(__tstate);
11547 if (PyErr_Occurred()) SWIG_fail;
11548 }
11549 resultobj = SWIG_Py_Void();
11550 return resultobj;
11551 fail:
11552 return NULL;
11553 }
11554
11555
11556 SWIGINTERN PyObject *_wrap_Timer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11557 PyObject *resultobj = 0;
11558 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11559 PyObject *arg2 = (PyObject *) 0 ;
11560 PyObject *arg3 = (PyObject *) 0 ;
11561 int arg4 = (int) 0 ;
11562 void *argp1 = 0 ;
11563 int res1 = 0 ;
11564 int val4 ;
11565 int ecode4 = 0 ;
11566 PyObject * obj0 = 0 ;
11567 PyObject * obj1 = 0 ;
11568 PyObject * obj2 = 0 ;
11569 PyObject * obj3 = 0 ;
11570 char * kwnames[] = {
11571 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
11572 };
11573
11574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11575 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11576 if (!SWIG_IsOK(res1)) {
11577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11578 }
11579 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11580 arg2 = obj1;
11581 arg3 = obj2;
11582 if (obj3) {
11583 ecode4 = SWIG_AsVal_int(obj3, &val4);
11584 if (!SWIG_IsOK(ecode4)) {
11585 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Timer__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
11586 }
11587 arg4 = static_cast< int >(val4);
11588 }
11589 {
11590 PyThreadState* __tstate = wxPyBeginAllowThreads();
11591 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
11592 wxPyEndAllowThreads(__tstate);
11593 if (PyErr_Occurred()) SWIG_fail;
11594 }
11595 resultobj = SWIG_Py_Void();
11596 return resultobj;
11597 fail:
11598 return NULL;
11599 }
11600
11601
11602 SWIGINTERN PyObject *_wrap_Timer_SetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11603 PyObject *resultobj = 0;
11604 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11605 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
11606 int arg3 = (int) wxID_ANY ;
11607 void *argp1 = 0 ;
11608 int res1 = 0 ;
11609 void *argp2 = 0 ;
11610 int res2 = 0 ;
11611 int val3 ;
11612 int ecode3 = 0 ;
11613 PyObject * obj0 = 0 ;
11614 PyObject * obj1 = 0 ;
11615 PyObject * obj2 = 0 ;
11616 char * kwnames[] = {
11617 (char *) "self",(char *) "owner",(char *) "id", NULL
11618 };
11619
11620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11622 if (!SWIG_IsOK(res1)) {
11623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_SetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11624 }
11625 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11626 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
11627 if (!SWIG_IsOK(res2)) {
11628 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Timer_SetOwner" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
11629 }
11630 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
11631 if (obj2) {
11632 ecode3 = SWIG_AsVal_int(obj2, &val3);
11633 if (!SWIG_IsOK(ecode3)) {
11634 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_SetOwner" "', expected argument " "3"" of type '" "int""'");
11635 }
11636 arg3 = static_cast< int >(val3);
11637 }
11638 {
11639 PyThreadState* __tstate = wxPyBeginAllowThreads();
11640 (arg1)->SetOwner(arg2,arg3);
11641 wxPyEndAllowThreads(__tstate);
11642 if (PyErr_Occurred()) SWIG_fail;
11643 }
11644 resultobj = SWIG_Py_Void();
11645 return resultobj;
11646 fail:
11647 return NULL;
11648 }
11649
11650
11651 SWIGINTERN PyObject *_wrap_Timer_GetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11652 PyObject *resultobj = 0;
11653 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11654 wxEvtHandler *result = 0 ;
11655 void *argp1 = 0 ;
11656 int res1 = 0 ;
11657 PyObject *swig_obj[1] ;
11658
11659 if (!args) SWIG_fail;
11660 swig_obj[0] = args;
11661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11662 if (!SWIG_IsOK(res1)) {
11663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11664 }
11665 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11666 {
11667 PyThreadState* __tstate = wxPyBeginAllowThreads();
11668 result = (wxEvtHandler *)(arg1)->GetOwner();
11669 wxPyEndAllowThreads(__tstate);
11670 if (PyErr_Occurred()) SWIG_fail;
11671 }
11672 {
11673 resultobj = wxPyMake_wxObject(result, 0);
11674 }
11675 return resultobj;
11676 fail:
11677 return NULL;
11678 }
11679
11680
11681 SWIGINTERN PyObject *_wrap_Timer_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11682 PyObject *resultobj = 0;
11683 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11684 int arg2 = (int) -1 ;
11685 bool arg3 = (bool) false ;
11686 bool result;
11687 void *argp1 = 0 ;
11688 int res1 = 0 ;
11689 int val2 ;
11690 int ecode2 = 0 ;
11691 bool val3 ;
11692 int ecode3 = 0 ;
11693 PyObject * obj0 = 0 ;
11694 PyObject * obj1 = 0 ;
11695 PyObject * obj2 = 0 ;
11696 char * kwnames[] = {
11697 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
11698 };
11699
11700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11701 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11702 if (!SWIG_IsOK(res1)) {
11703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Start" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11704 }
11705 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11706 if (obj1) {
11707 ecode2 = SWIG_AsVal_int(obj1, &val2);
11708 if (!SWIG_IsOK(ecode2)) {
11709 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Timer_Start" "', expected argument " "2"" of type '" "int""'");
11710 }
11711 arg2 = static_cast< int >(val2);
11712 }
11713 if (obj2) {
11714 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11715 if (!SWIG_IsOK(ecode3)) {
11716 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_Start" "', expected argument " "3"" of type '" "bool""'");
11717 }
11718 arg3 = static_cast< bool >(val3);
11719 }
11720 {
11721 PyThreadState* __tstate = wxPyBeginAllowThreads();
11722 result = (bool)(arg1)->Start(arg2,arg3);
11723 wxPyEndAllowThreads(__tstate);
11724 if (PyErr_Occurred()) SWIG_fail;
11725 }
11726 {
11727 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11728 }
11729 return resultobj;
11730 fail:
11731 return NULL;
11732 }
11733
11734
11735 SWIGINTERN PyObject *_wrap_Timer_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11736 PyObject *resultobj = 0;
11737 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11738 void *argp1 = 0 ;
11739 int res1 = 0 ;
11740 PyObject *swig_obj[1] ;
11741
11742 if (!args) SWIG_fail;
11743 swig_obj[0] = args;
11744 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11745 if (!SWIG_IsOK(res1)) {
11746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Stop" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11747 }
11748 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11749 {
11750 PyThreadState* __tstate = wxPyBeginAllowThreads();
11751 (arg1)->Stop();
11752 wxPyEndAllowThreads(__tstate);
11753 if (PyErr_Occurred()) SWIG_fail;
11754 }
11755 resultobj = SWIG_Py_Void();
11756 return resultobj;
11757 fail:
11758 return NULL;
11759 }
11760
11761
11762 SWIGINTERN PyObject *_wrap_Timer_Notify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11763 PyObject *resultobj = 0;
11764 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
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_Notify" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11774 }
11775 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11776 {
11777 PyThreadState* __tstate = wxPyBeginAllowThreads();
11778 (arg1)->Notify();
11779 wxPyEndAllowThreads(__tstate);
11780 if (PyErr_Occurred()) SWIG_fail;
11781 }
11782 resultobj = SWIG_Py_Void();
11783 return resultobj;
11784 fail:
11785 return NULL;
11786 }
11787
11788
11789 SWIGINTERN PyObject *_wrap_Timer_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11790 PyObject *resultobj = 0;
11791 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11792 bool result;
11793 void *argp1 = 0 ;
11794 int res1 = 0 ;
11795 PyObject *swig_obj[1] ;
11796
11797 if (!args) SWIG_fail;
11798 swig_obj[0] = args;
11799 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11800 if (!SWIG_IsOK(res1)) {
11801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsRunning" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11802 }
11803 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11804 {
11805 PyThreadState* __tstate = wxPyBeginAllowThreads();
11806 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
11807 wxPyEndAllowThreads(__tstate);
11808 if (PyErr_Occurred()) SWIG_fail;
11809 }
11810 {
11811 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11812 }
11813 return resultobj;
11814 fail:
11815 return NULL;
11816 }
11817
11818
11819 SWIGINTERN PyObject *_wrap_Timer_GetInterval(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_GetInterval" "', 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)->GetInterval();
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_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11848 PyObject *resultobj = 0;
11849 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11850 int 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_GetId" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11860 }
11861 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11862 {
11863 PyThreadState* __tstate = wxPyBeginAllowThreads();
11864 result = (int)((wxPyTimer const *)arg1)->GetId();
11865 wxPyEndAllowThreads(__tstate);
11866 if (PyErr_Occurred()) SWIG_fail;
11867 }
11868 resultobj = SWIG_From_int(static_cast< int >(result));
11869 return resultobj;
11870 fail:
11871 return NULL;
11872 }
11873
11874
11875 SWIGINTERN PyObject *_wrap_Timer_IsOneShot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11876 PyObject *resultobj = 0;
11877 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11878 bool result;
11879 void *argp1 = 0 ;
11880 int res1 = 0 ;
11881 PyObject *swig_obj[1] ;
11882
11883 if (!args) SWIG_fail;
11884 swig_obj[0] = args;
11885 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11886 if (!SWIG_IsOK(res1)) {
11887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsOneShot" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11888 }
11889 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11890 {
11891 PyThreadState* __tstate = wxPyBeginAllowThreads();
11892 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
11893 wxPyEndAllowThreads(__tstate);
11894 if (PyErr_Occurred()) SWIG_fail;
11895 }
11896 {
11897 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11898 }
11899 return resultobj;
11900 fail:
11901 return NULL;
11902 }
11903
11904
11905 SWIGINTERN PyObject *Timer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11906 PyObject *obj;
11907 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11908 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTimer, SWIG_NewClientData(obj));
11909 return SWIG_Py_Void();
11910 }
11911
11912 SWIGINTERN PyObject *Timer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11913 return SWIG_Python_InitShadowInstance(args);
11914 }
11915
11916 SWIGINTERN PyObject *_wrap_new_TimerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11917 PyObject *resultobj = 0;
11918 int arg1 = (int) 0 ;
11919 int arg2 = (int) 0 ;
11920 wxTimerEvent *result = 0 ;
11921 int val1 ;
11922 int ecode1 = 0 ;
11923 int val2 ;
11924 int ecode2 = 0 ;
11925 PyObject * obj0 = 0 ;
11926 PyObject * obj1 = 0 ;
11927 char * kwnames[] = {
11928 (char *) "timerid",(char *) "interval", NULL
11929 };
11930
11931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) SWIG_fail;
11932 if (obj0) {
11933 ecode1 = SWIG_AsVal_int(obj0, &val1);
11934 if (!SWIG_IsOK(ecode1)) {
11935 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimerEvent" "', expected argument " "1"" of type '" "int""'");
11936 }
11937 arg1 = static_cast< int >(val1);
11938 }
11939 if (obj1) {
11940 ecode2 = SWIG_AsVal_int(obj1, &val2);
11941 if (!SWIG_IsOK(ecode2)) {
11942 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerEvent" "', expected argument " "2"" of type '" "int""'");
11943 }
11944 arg2 = static_cast< int >(val2);
11945 }
11946 {
11947 PyThreadState* __tstate = wxPyBeginAllowThreads();
11948 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
11949 wxPyEndAllowThreads(__tstate);
11950 if (PyErr_Occurred()) SWIG_fail;
11951 }
11952 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_NEW | 0 );
11953 return resultobj;
11954 fail:
11955 return NULL;
11956 }
11957
11958
11959 SWIGINTERN PyObject *_wrap_TimerEvent_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11960 PyObject *resultobj = 0;
11961 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
11962 int result;
11963 void *argp1 = 0 ;
11964 int res1 = 0 ;
11965 PyObject *swig_obj[1] ;
11966
11967 if (!args) SWIG_fail;
11968 swig_obj[0] = args;
11969 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerEvent, 0 | 0 );
11970 if (!SWIG_IsOK(res1)) {
11971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerEvent_GetInterval" "', expected argument " "1"" of type '" "wxTimerEvent const *""'");
11972 }
11973 arg1 = reinterpret_cast< wxTimerEvent * >(argp1);
11974 {
11975 PyThreadState* __tstate = wxPyBeginAllowThreads();
11976 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
11977 wxPyEndAllowThreads(__tstate);
11978 if (PyErr_Occurred()) SWIG_fail;
11979 }
11980 resultobj = SWIG_From_int(static_cast< int >(result));
11981 return resultobj;
11982 fail:
11983 return NULL;
11984 }
11985
11986
11987 SWIGINTERN PyObject *TimerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11988 PyObject *obj;
11989 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11990 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerEvent, SWIG_NewClientData(obj));
11991 return SWIG_Py_Void();
11992 }
11993
11994 SWIGINTERN PyObject *TimerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11995 return SWIG_Python_InitShadowInstance(args);
11996 }
11997
11998 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
11999 PyObject *resultobj = 0;
12000 wxTimer *arg1 = 0 ;
12001 wxTimerRunner *result = 0 ;
12002 void *argp1 = 0 ;
12003 int res1 = 0 ;
12004
12005 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
12006 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
12007 if (!SWIG_IsOK(res1)) {
12008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
12009 }
12010 if (!argp1) {
12011 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
12012 }
12013 arg1 = reinterpret_cast< wxTimer * >(argp1);
12014 {
12015 if (!wxPyCheckForApp()) SWIG_fail;
12016 PyThreadState* __tstate = wxPyBeginAllowThreads();
12017 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
12018 wxPyEndAllowThreads(__tstate);
12019 if (PyErr_Occurred()) SWIG_fail;
12020 }
12021 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
12022 return resultobj;
12023 fail:
12024 return NULL;
12025 }
12026
12027
12028 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
12029 PyObject *resultobj = 0;
12030 wxTimer *arg1 = 0 ;
12031 int arg2 ;
12032 bool arg3 = (bool) false ;
12033 wxTimerRunner *result = 0 ;
12034 void *argp1 = 0 ;
12035 int res1 = 0 ;
12036 int val2 ;
12037 int ecode2 = 0 ;
12038 bool val3 ;
12039 int ecode3 = 0 ;
12040
12041 if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
12042 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
12043 if (!SWIG_IsOK(res1)) {
12044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
12045 }
12046 if (!argp1) {
12047 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
12048 }
12049 arg1 = reinterpret_cast< wxTimer * >(argp1);
12050 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12051 if (!SWIG_IsOK(ecode2)) {
12052 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerRunner" "', expected argument " "2"" of type '" "int""'");
12053 }
12054 arg2 = static_cast< int >(val2);
12055 if (swig_obj[2]) {
12056 ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
12057 if (!SWIG_IsOK(ecode3)) {
12058 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimerRunner" "', expected argument " "3"" of type '" "bool""'");
12059 }
12060 arg3 = static_cast< bool >(val3);
12061 }
12062 {
12063 if (!wxPyCheckForApp()) SWIG_fail;
12064 PyThreadState* __tstate = wxPyBeginAllowThreads();
12065 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
12066 wxPyEndAllowThreads(__tstate);
12067 if (PyErr_Occurred()) SWIG_fail;
12068 }
12069 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
12070 return resultobj;
12071 fail:
12072 return NULL;
12073 }
12074
12075
12076 SWIGINTERN PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
12077 int argc;
12078 PyObject *argv[4];
12079
12080 if (!(argc = SWIG_Python_UnpackTuple(args,"new_TimerRunner",0,3,argv))) SWIG_fail;
12081 --argc;
12082 if (argc == 1) {
12083 return _wrap_new_TimerRunner__SWIG_0(self, argc, argv);
12084 }
12085 if ((argc >= 2) && (argc <= 3)) {
12086 return _wrap_new_TimerRunner__SWIG_1(self, argc, argv);
12087 }
12088
12089 fail:
12090 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
12091 return NULL;
12092 }
12093
12094
12095 SWIGINTERN PyObject *_wrap_delete_TimerRunner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12096 PyObject *resultobj = 0;
12097 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
12098 void *argp1 = 0 ;
12099 int res1 = 0 ;
12100 PyObject *swig_obj[1] ;
12101
12102 if (!args) SWIG_fail;
12103 swig_obj[0] = args;
12104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_DISOWN | 0 );
12105 if (!SWIG_IsOK(res1)) {
12106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimerRunner" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
12107 }
12108 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
12109 {
12110 PyThreadState* __tstate = wxPyBeginAllowThreads();
12111 delete arg1;
12112
12113 wxPyEndAllowThreads(__tstate);
12114 if (PyErr_Occurred()) SWIG_fail;
12115 }
12116 resultobj = SWIG_Py_Void();
12117 return resultobj;
12118 fail:
12119 return NULL;
12120 }
12121
12122
12123 SWIGINTERN PyObject *_wrap_TimerRunner_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12124 PyObject *resultobj = 0;
12125 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
12126 int arg2 ;
12127 bool arg3 = (bool) false ;
12128 void *argp1 = 0 ;
12129 int res1 = 0 ;
12130 int val2 ;
12131 int ecode2 = 0 ;
12132 bool val3 ;
12133 int ecode3 = 0 ;
12134 PyObject * obj0 = 0 ;
12135 PyObject * obj1 = 0 ;
12136 PyObject * obj2 = 0 ;
12137 char * kwnames[] = {
12138 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
12139 };
12140
12141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimerRunner, 0 | 0 );
12143 if (!SWIG_IsOK(res1)) {
12144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerRunner_Start" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
12145 }
12146 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
12147 ecode2 = SWIG_AsVal_int(obj1, &val2);
12148 if (!SWIG_IsOK(ecode2)) {
12149 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimerRunner_Start" "', expected argument " "2"" of type '" "int""'");
12150 }
12151 arg2 = static_cast< int >(val2);
12152 if (obj2) {
12153 ecode3 = SWIG_AsVal_bool(obj2, &val3);
12154 if (!SWIG_IsOK(ecode3)) {
12155 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TimerRunner_Start" "', expected argument " "3"" of type '" "bool""'");
12156 }
12157 arg3 = static_cast< bool >(val3);
12158 }
12159 {
12160 PyThreadState* __tstate = wxPyBeginAllowThreads();
12161 (arg1)->Start(arg2,arg3);
12162 wxPyEndAllowThreads(__tstate);
12163 if (PyErr_Occurred()) SWIG_fail;
12164 }
12165 resultobj = SWIG_Py_Void();
12166 return resultobj;
12167 fail:
12168 return NULL;
12169 }
12170
12171
12172 SWIGINTERN PyObject *TimerRunner_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12173 PyObject *obj;
12174 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12175 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerRunner, SWIG_NewClientData(obj));
12176 return SWIG_Py_Void();
12177 }
12178
12179 SWIGINTERN PyObject *TimerRunner_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12180 return SWIG_Python_InitShadowInstance(args);
12181 }
12182
12183 SWIGINTERN PyObject *_wrap_new_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12184 PyObject *resultobj = 0;
12185 wxLog *result = 0 ;
12186
12187 if (!SWIG_Python_UnpackTuple(args,"new_Log",0,0,0)) SWIG_fail;
12188 {
12189 PyThreadState* __tstate = wxPyBeginAllowThreads();
12190 result = (wxLog *)new wxLog();
12191 wxPyEndAllowThreads(__tstate);
12192 if (PyErr_Occurred()) SWIG_fail;
12193 }
12194 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_NEW | 0 );
12195 return resultobj;
12196 fail:
12197 return NULL;
12198 }
12199
12200
12201 SWIGINTERN PyObject *_wrap_delete_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12202 PyObject *resultobj = 0;
12203 wxLog *arg1 = (wxLog *) 0 ;
12204 void *argp1 = 0 ;
12205 int res1 = 0 ;
12206 PyObject *swig_obj[1] ;
12207
12208 if (!args) SWIG_fail;
12209 swig_obj[0] = args;
12210 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
12211 if (!SWIG_IsOK(res1)) {
12212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Log" "', expected argument " "1"" of type '" "wxLog *""'");
12213 }
12214 arg1 = reinterpret_cast< wxLog * >(argp1);
12215 {
12216 PyThreadState* __tstate = wxPyBeginAllowThreads();
12217 delete arg1;
12218
12219 wxPyEndAllowThreads(__tstate);
12220 if (PyErr_Occurred()) SWIG_fail;
12221 }
12222 resultobj = SWIG_Py_Void();
12223 return resultobj;
12224 fail:
12225 return NULL;
12226 }
12227
12228
12229 SWIGINTERN PyObject *_wrap_Log_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12230 PyObject *resultobj = 0;
12231 bool result;
12232
12233 if (!SWIG_Python_UnpackTuple(args,"Log_IsEnabled",0,0,0)) SWIG_fail;
12234 {
12235 PyThreadState* __tstate = wxPyBeginAllowThreads();
12236 result = (bool)wxLog::IsEnabled();
12237 wxPyEndAllowThreads(__tstate);
12238 if (PyErr_Occurred()) SWIG_fail;
12239 }
12240 {
12241 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12242 }
12243 return resultobj;
12244 fail:
12245 return NULL;
12246 }
12247
12248
12249 SWIGINTERN PyObject *_wrap_Log_EnableLogging(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12250 PyObject *resultobj = 0;
12251 bool arg1 = (bool) true ;
12252 bool result;
12253 bool val1 ;
12254 int ecode1 = 0 ;
12255 PyObject * obj0 = 0 ;
12256 char * kwnames[] = {
12257 (char *) "doIt", NULL
12258 };
12259
12260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) SWIG_fail;
12261 if (obj0) {
12262 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12263 if (!SWIG_IsOK(ecode1)) {
12264 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_EnableLogging" "', expected argument " "1"" of type '" "bool""'");
12265 }
12266 arg1 = static_cast< bool >(val1);
12267 }
12268 {
12269 PyThreadState* __tstate = wxPyBeginAllowThreads();
12270 result = (bool)wxLog::EnableLogging(arg1);
12271 wxPyEndAllowThreads(__tstate);
12272 if (PyErr_Occurred()) SWIG_fail;
12273 }
12274 {
12275 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12276 }
12277 return resultobj;
12278 fail:
12279 return NULL;
12280 }
12281
12282
12283 SWIGINTERN PyObject *_wrap_Log_OnLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12284 PyObject *resultobj = 0;
12285 wxLogLevel arg1 ;
12286 wxChar *arg2 = (wxChar *) 0 ;
12287 time_t arg3 ;
12288 unsigned long val1 ;
12289 int ecode1 = 0 ;
12290 void *argp2 = 0 ;
12291 int res2 = 0 ;
12292 unsigned int val3 ;
12293 int ecode3 = 0 ;
12294 PyObject * obj0 = 0 ;
12295 PyObject * obj1 = 0 ;
12296 PyObject * obj2 = 0 ;
12297 char * kwnames[] = {
12298 (char *) "level",(char *) "szString",(char *) "t", NULL
12299 };
12300
12301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12302 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12303 if (!SWIG_IsOK(ecode1)) {
12304 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_OnLog" "', expected argument " "1"" of type '" "wxLogLevel""'");
12305 }
12306 arg1 = static_cast< wxLogLevel >(val1);
12307 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxChar, 0 | 0 );
12308 if (!SWIG_IsOK(res2)) {
12309 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Log_OnLog" "', expected argument " "2"" of type '" "wxChar const *""'");
12310 }
12311 arg2 = reinterpret_cast< wxChar * >(argp2);
12312 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
12313 if (!SWIG_IsOK(ecode3)) {
12314 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Log_OnLog" "', expected argument " "3"" of type '" "time_t""'");
12315 }
12316 arg3 = static_cast< time_t >(val3);
12317 {
12318 PyThreadState* __tstate = wxPyBeginAllowThreads();
12319 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
12320 wxPyEndAllowThreads(__tstate);
12321 if (PyErr_Occurred()) SWIG_fail;
12322 }
12323 resultobj = SWIG_Py_Void();
12324 return resultobj;
12325 fail:
12326 return NULL;
12327 }
12328
12329
12330 SWIGINTERN PyObject *_wrap_Log_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12331 PyObject *resultobj = 0;
12332 wxLog *arg1 = (wxLog *) 0 ;
12333 void *argp1 = 0 ;
12334 int res1 = 0 ;
12335 PyObject *swig_obj[1] ;
12336
12337 if (!args) SWIG_fail;
12338 swig_obj[0] = args;
12339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
12340 if (!SWIG_IsOK(res1)) {
12341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Flush" "', expected argument " "1"" of type '" "wxLog *""'");
12342 }
12343 arg1 = reinterpret_cast< wxLog * >(argp1);
12344 {
12345 PyThreadState* __tstate = wxPyBeginAllowThreads();
12346 (arg1)->Flush();
12347 wxPyEndAllowThreads(__tstate);
12348 if (PyErr_Occurred()) SWIG_fail;
12349 }
12350 resultobj = SWIG_Py_Void();
12351 return resultobj;
12352 fail:
12353 return NULL;
12354 }
12355
12356
12357 SWIGINTERN PyObject *_wrap_Log_FlushActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12358 PyObject *resultobj = 0;
12359
12360 if (!SWIG_Python_UnpackTuple(args,"Log_FlushActive",0,0,0)) SWIG_fail;
12361 {
12362 PyThreadState* __tstate = wxPyBeginAllowThreads();
12363 wxLog::FlushActive();
12364 wxPyEndAllowThreads(__tstate);
12365 if (PyErr_Occurred()) SWIG_fail;
12366 }
12367 resultobj = SWIG_Py_Void();
12368 return resultobj;
12369 fail:
12370 return NULL;
12371 }
12372
12373
12374 SWIGINTERN PyObject *_wrap_Log_GetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12375 PyObject *resultobj = 0;
12376 wxLog *result = 0 ;
12377
12378 if (!SWIG_Python_UnpackTuple(args,"Log_GetActiveTarget",0,0,0)) SWIG_fail;
12379 {
12380 PyThreadState* __tstate = wxPyBeginAllowThreads();
12381 result = (wxLog *)wxLog::GetActiveTarget();
12382 wxPyEndAllowThreads(__tstate);
12383 if (PyErr_Occurred()) SWIG_fail;
12384 }
12385 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
12386 return resultobj;
12387 fail:
12388 return NULL;
12389 }
12390
12391
12392 SWIGINTERN PyObject *_wrap_Log_SetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12393 PyObject *resultobj = 0;
12394 wxLog *arg1 = (wxLog *) 0 ;
12395 wxLog *result = 0 ;
12396 int res1 = 0 ;
12397 PyObject * obj0 = 0 ;
12398 char * kwnames[] = {
12399 (char *) "pLogger", NULL
12400 };
12401
12402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) SWIG_fail;
12403 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
12404 if (!SWIG_IsOK(res1)) {
12405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetActiveTarget" "', expected argument " "1"" of type '" "wxLog *""'");
12406 }
12407 {
12408 PyThreadState* __tstate = wxPyBeginAllowThreads();
12409 result = (wxLog *)wxLog::SetActiveTarget(arg1);
12410 wxPyEndAllowThreads(__tstate);
12411 if (PyErr_Occurred()) SWIG_fail;
12412 }
12413 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_OWN | 0 );
12414 return resultobj;
12415 fail:
12416 return NULL;
12417 }
12418
12419
12420 SWIGINTERN PyObject *_wrap_Log_Suspend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12421 PyObject *resultobj = 0;
12422
12423 if (!SWIG_Python_UnpackTuple(args,"Log_Suspend",0,0,0)) SWIG_fail;
12424 {
12425 PyThreadState* __tstate = wxPyBeginAllowThreads();
12426 wxLog::Suspend();
12427 wxPyEndAllowThreads(__tstate);
12428 if (PyErr_Occurred()) SWIG_fail;
12429 }
12430 resultobj = SWIG_Py_Void();
12431 return resultobj;
12432 fail:
12433 return NULL;
12434 }
12435
12436
12437 SWIGINTERN PyObject *_wrap_Log_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12438 PyObject *resultobj = 0;
12439
12440 if (!SWIG_Python_UnpackTuple(args,"Log_Resume",0,0,0)) SWIG_fail;
12441 {
12442 PyThreadState* __tstate = wxPyBeginAllowThreads();
12443 wxLog::Resume();
12444 wxPyEndAllowThreads(__tstate);
12445 if (PyErr_Occurred()) SWIG_fail;
12446 }
12447 resultobj = SWIG_Py_Void();
12448 return resultobj;
12449 fail:
12450 return NULL;
12451 }
12452
12453
12454 SWIGINTERN PyObject *_wrap_Log_SetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12455 PyObject *resultobj = 0;
12456 bool arg1 = (bool) true ;
12457 bool val1 ;
12458 int ecode1 = 0 ;
12459 PyObject * obj0 = 0 ;
12460 char * kwnames[] = {
12461 (char *) "bVerbose", NULL
12462 };
12463
12464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) SWIG_fail;
12465 if (obj0) {
12466 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12467 if (!SWIG_IsOK(ecode1)) {
12468 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetVerbose" "', expected argument " "1"" of type '" "bool""'");
12469 }
12470 arg1 = static_cast< bool >(val1);
12471 }
12472 {
12473 PyThreadState* __tstate = wxPyBeginAllowThreads();
12474 wxLog::SetVerbose(arg1);
12475 wxPyEndAllowThreads(__tstate);
12476 if (PyErr_Occurred()) SWIG_fail;
12477 }
12478 resultobj = SWIG_Py_Void();
12479 return resultobj;
12480 fail:
12481 return NULL;
12482 }
12483
12484
12485 SWIGINTERN PyObject *_wrap_Log_SetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12486 PyObject *resultobj = 0;
12487 wxLogLevel arg1 ;
12488 unsigned long val1 ;
12489 int ecode1 = 0 ;
12490 PyObject * obj0 = 0 ;
12491 char * kwnames[] = {
12492 (char *) "logLevel", NULL
12493 };
12494
12495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) SWIG_fail;
12496 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12497 if (!SWIG_IsOK(ecode1)) {
12498 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetLogLevel" "', expected argument " "1"" of type '" "wxLogLevel""'");
12499 }
12500 arg1 = static_cast< wxLogLevel >(val1);
12501 {
12502 PyThreadState* __tstate = wxPyBeginAllowThreads();
12503 wxLog::SetLogLevel(arg1);
12504 wxPyEndAllowThreads(__tstate);
12505 if (PyErr_Occurred()) SWIG_fail;
12506 }
12507 resultobj = SWIG_Py_Void();
12508 return resultobj;
12509 fail:
12510 return NULL;
12511 }
12512
12513
12514 SWIGINTERN PyObject *_wrap_Log_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12515 PyObject *resultobj = 0;
12516
12517 if (!SWIG_Python_UnpackTuple(args,"Log_DontCreateOnDemand",0,0,0)) SWIG_fail;
12518 {
12519 PyThreadState* __tstate = wxPyBeginAllowThreads();
12520 wxLog::DontCreateOnDemand();
12521 wxPyEndAllowThreads(__tstate);
12522 if (PyErr_Occurred()) SWIG_fail;
12523 }
12524 resultobj = SWIG_Py_Void();
12525 return resultobj;
12526 fail:
12527 return NULL;
12528 }
12529
12530
12531 SWIGINTERN PyObject *_wrap_Log_SetRepetitionCounting(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12532 PyObject *resultobj = 0;
12533 bool arg1 = (bool) true ;
12534 bool val1 ;
12535 int ecode1 = 0 ;
12536 PyObject * obj0 = 0 ;
12537 char * kwnames[] = {
12538 (char *) "bRepetCounting", NULL
12539 };
12540
12541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetRepetitionCounting",kwnames,&obj0)) SWIG_fail;
12542 if (obj0) {
12543 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12544 if (!SWIG_IsOK(ecode1)) {
12545 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetRepetitionCounting" "', expected argument " "1"" of type '" "bool""'");
12546 }
12547 arg1 = static_cast< bool >(val1);
12548 }
12549 {
12550 PyThreadState* __tstate = wxPyBeginAllowThreads();
12551 wxLog::SetRepetitionCounting(arg1);
12552 wxPyEndAllowThreads(__tstate);
12553 if (PyErr_Occurred()) SWIG_fail;
12554 }
12555 resultobj = SWIG_Py_Void();
12556 return resultobj;
12557 fail:
12558 return NULL;
12559 }
12560
12561
12562 SWIGINTERN PyObject *_wrap_Log_GetRepetitionCounting(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12563 PyObject *resultobj = 0;
12564 bool result;
12565
12566 if (!SWIG_Python_UnpackTuple(args,"Log_GetRepetitionCounting",0,0,0)) SWIG_fail;
12567 {
12568 PyThreadState* __tstate = wxPyBeginAllowThreads();
12569 result = (bool)wxLog::GetRepetitionCounting();
12570 wxPyEndAllowThreads(__tstate);
12571 if (PyErr_Occurred()) SWIG_fail;
12572 }
12573 {
12574 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12575 }
12576 return resultobj;
12577 fail:
12578 return NULL;
12579 }
12580
12581
12582 SWIGINTERN PyObject *_wrap_Log_SetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12583 PyObject *resultobj = 0;
12584 wxTraceMask arg1 ;
12585 unsigned long val1 ;
12586 int ecode1 = 0 ;
12587 PyObject * obj0 = 0 ;
12588 char * kwnames[] = {
12589 (char *) "ulMask", NULL
12590 };
12591
12592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) SWIG_fail;
12593 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12594 if (!SWIG_IsOK(ecode1)) {
12595 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetTraceMask" "', expected argument " "1"" of type '" "wxTraceMask""'");
12596 }
12597 arg1 = static_cast< wxTraceMask >(val1);
12598 {
12599 PyThreadState* __tstate = wxPyBeginAllowThreads();
12600 wxLog::SetTraceMask(arg1);
12601 wxPyEndAllowThreads(__tstate);
12602 if (PyErr_Occurred()) SWIG_fail;
12603 }
12604 resultobj = SWIG_Py_Void();
12605 return resultobj;
12606 fail:
12607 return NULL;
12608 }
12609
12610
12611 SWIGINTERN PyObject *_wrap_Log_AddTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12612 PyObject *resultobj = 0;
12613 wxString *arg1 = 0 ;
12614 bool temp1 = false ;
12615 PyObject * obj0 = 0 ;
12616 char * kwnames[] = {
12617 (char *) "str", NULL
12618 };
12619
12620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) SWIG_fail;
12621 {
12622 arg1 = wxString_in_helper(obj0);
12623 if (arg1 == NULL) SWIG_fail;
12624 temp1 = true;
12625 }
12626 {
12627 PyThreadState* __tstate = wxPyBeginAllowThreads();
12628 wxLog::AddTraceMask((wxString const &)*arg1);
12629 wxPyEndAllowThreads(__tstate);
12630 if (PyErr_Occurred()) SWIG_fail;
12631 }
12632 resultobj = SWIG_Py_Void();
12633 {
12634 if (temp1)
12635 delete arg1;
12636 }
12637 return resultobj;
12638 fail:
12639 {
12640 if (temp1)
12641 delete arg1;
12642 }
12643 return NULL;
12644 }
12645
12646
12647 SWIGINTERN PyObject *_wrap_Log_RemoveTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12648 PyObject *resultobj = 0;
12649 wxString *arg1 = 0 ;
12650 bool temp1 = false ;
12651 PyObject * obj0 = 0 ;
12652 char * kwnames[] = {
12653 (char *) "str", NULL
12654 };
12655
12656 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) SWIG_fail;
12657 {
12658 arg1 = wxString_in_helper(obj0);
12659 if (arg1 == NULL) SWIG_fail;
12660 temp1 = true;
12661 }
12662 {
12663 PyThreadState* __tstate = wxPyBeginAllowThreads();
12664 wxLog::RemoveTraceMask((wxString const &)*arg1);
12665 wxPyEndAllowThreads(__tstate);
12666 if (PyErr_Occurred()) SWIG_fail;
12667 }
12668 resultobj = SWIG_Py_Void();
12669 {
12670 if (temp1)
12671 delete arg1;
12672 }
12673 return resultobj;
12674 fail:
12675 {
12676 if (temp1)
12677 delete arg1;
12678 }
12679 return NULL;
12680 }
12681
12682
12683 SWIGINTERN PyObject *_wrap_Log_ClearTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12684 PyObject *resultobj = 0;
12685
12686 if (!SWIG_Python_UnpackTuple(args,"Log_ClearTraceMasks",0,0,0)) SWIG_fail;
12687 {
12688 PyThreadState* __tstate = wxPyBeginAllowThreads();
12689 wxLog::ClearTraceMasks();
12690 wxPyEndAllowThreads(__tstate);
12691 if (PyErr_Occurred()) SWIG_fail;
12692 }
12693 resultobj = SWIG_Py_Void();
12694 return resultobj;
12695 fail:
12696 return NULL;
12697 }
12698
12699
12700 SWIGINTERN PyObject *_wrap_Log_GetTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12701 PyObject *resultobj = 0;
12702 wxArrayString *result = 0 ;
12703
12704 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMasks",0,0,0)) SWIG_fail;
12705 {
12706 PyThreadState* __tstate = wxPyBeginAllowThreads();
12707 {
12708 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
12709 result = (wxArrayString *) &_result_ref;
12710 }
12711 wxPyEndAllowThreads(__tstate);
12712 if (PyErr_Occurred()) SWIG_fail;
12713 }
12714 {
12715 resultobj = wxArrayString2PyList_helper(*result);
12716 }
12717 return resultobj;
12718 fail:
12719 return NULL;
12720 }
12721
12722
12723 SWIGINTERN PyObject *_wrap_Log_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12724 PyObject *resultobj = 0;
12725 wxChar *arg1 = (wxChar *) 0 ;
12726 void *argp1 = 0 ;
12727 int res1 = 0 ;
12728 PyObject * obj0 = 0 ;
12729 char * kwnames[] = {
12730 (char *) "ts", NULL
12731 };
12732
12733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) SWIG_fail;
12734 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
12735 if (!SWIG_IsOK(res1)) {
12736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetTimestamp" "', expected argument " "1"" of type '" "wxChar const *""'");
12737 }
12738 arg1 = reinterpret_cast< wxChar * >(argp1);
12739 {
12740 PyThreadState* __tstate = wxPyBeginAllowThreads();
12741 wxLog::SetTimestamp((wxChar const *)arg1);
12742 wxPyEndAllowThreads(__tstate);
12743 if (PyErr_Occurred()) SWIG_fail;
12744 }
12745 resultobj = SWIG_Py_Void();
12746 return resultobj;
12747 fail:
12748 return NULL;
12749 }
12750
12751
12752 SWIGINTERN PyObject *_wrap_Log_GetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12753 PyObject *resultobj = 0;
12754 bool result;
12755
12756 if (!SWIG_Python_UnpackTuple(args,"Log_GetVerbose",0,0,0)) SWIG_fail;
12757 {
12758 PyThreadState* __tstate = wxPyBeginAllowThreads();
12759 result = (bool)wxLog::GetVerbose();
12760 wxPyEndAllowThreads(__tstate);
12761 if (PyErr_Occurred()) SWIG_fail;
12762 }
12763 {
12764 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12765 }
12766 return resultobj;
12767 fail:
12768 return NULL;
12769 }
12770
12771
12772 SWIGINTERN PyObject *_wrap_Log_GetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12773 PyObject *resultobj = 0;
12774 wxTraceMask result;
12775
12776 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMask",0,0,0)) SWIG_fail;
12777 {
12778 PyThreadState* __tstate = wxPyBeginAllowThreads();
12779 result = (wxTraceMask)wxLog::GetTraceMask();
12780 wxPyEndAllowThreads(__tstate);
12781 if (PyErr_Occurred()) SWIG_fail;
12782 }
12783 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12784 return resultobj;
12785 fail:
12786 return NULL;
12787 }
12788
12789
12790 SWIGINTERN PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12791 PyObject *resultobj = 0;
12792 wxChar *arg1 = (wxChar *) 0 ;
12793 bool result;
12794 void *argp1 = 0 ;
12795 int res1 = 0 ;
12796 PyObject * obj0 = 0 ;
12797 char * kwnames[] = {
12798 (char *) "mask", NULL
12799 };
12800
12801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) SWIG_fail;
12802 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
12803 if (!SWIG_IsOK(res1)) {
12804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_IsAllowedTraceMask" "', expected argument " "1"" of type '" "wxChar const *""'");
12805 }
12806 arg1 = reinterpret_cast< wxChar * >(argp1);
12807 {
12808 PyThreadState* __tstate = wxPyBeginAllowThreads();
12809 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
12810 wxPyEndAllowThreads(__tstate);
12811 if (PyErr_Occurred()) SWIG_fail;
12812 }
12813 {
12814 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12815 }
12816 return resultobj;
12817 fail:
12818 return NULL;
12819 }
12820
12821
12822 SWIGINTERN PyObject *_wrap_Log_GetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12823 PyObject *resultobj = 0;
12824 wxLogLevel result;
12825
12826 if (!SWIG_Python_UnpackTuple(args,"Log_GetLogLevel",0,0,0)) SWIG_fail;
12827 {
12828 PyThreadState* __tstate = wxPyBeginAllowThreads();
12829 result = (wxLogLevel)wxLog::GetLogLevel();
12830 wxPyEndAllowThreads(__tstate);
12831 if (PyErr_Occurred()) SWIG_fail;
12832 }
12833 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12834 return resultobj;
12835 fail:
12836 return NULL;
12837 }
12838
12839
12840 SWIGINTERN PyObject *_wrap_Log_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12841 PyObject *resultobj = 0;
12842 wxChar *result = 0 ;
12843
12844 if (!SWIG_Python_UnpackTuple(args,"Log_GetTimestamp",0,0,0)) SWIG_fail;
12845 {
12846 PyThreadState* __tstate = wxPyBeginAllowThreads();
12847 result = (wxChar *)wxLog::GetTimestamp();
12848 wxPyEndAllowThreads(__tstate);
12849 if (PyErr_Occurred()) SWIG_fail;
12850 }
12851 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChar, 0 | 0 );
12852 return resultobj;
12853 fail:
12854 return NULL;
12855 }
12856
12857
12858 SWIGINTERN PyObject *_wrap_Log_TimeStamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12859 PyObject *resultobj = 0;
12860 wxString result;
12861
12862 if (!SWIG_Python_UnpackTuple(args,"Log_TimeStamp",0,0,0)) SWIG_fail;
12863 {
12864 PyThreadState* __tstate = wxPyBeginAllowThreads();
12865 result = wxLog_TimeStamp();
12866 wxPyEndAllowThreads(__tstate);
12867 if (PyErr_Occurred()) SWIG_fail;
12868 }
12869 {
12870 #if wxUSE_UNICODE
12871 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12872 #else
12873 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12874 #endif
12875 }
12876 return resultobj;
12877 fail:
12878 return NULL;
12879 }
12880
12881
12882 SWIGINTERN PyObject *_wrap_Log_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12883 PyObject *resultobj = 0;
12884 wxLog *arg1 = (wxLog *) 0 ;
12885 void *argp1 = 0 ;
12886 int res1 = 0 ;
12887 PyObject *swig_obj[1] ;
12888
12889 if (!args) SWIG_fail;
12890 swig_obj[0] = args;
12891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
12892 if (!SWIG_IsOK(res1)) {
12893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Destroy" "', expected argument " "1"" of type '" "wxLog *""'");
12894 }
12895 arg1 = reinterpret_cast< wxLog * >(argp1);
12896 {
12897 PyThreadState* __tstate = wxPyBeginAllowThreads();
12898 wxLog_Destroy(arg1);
12899 wxPyEndAllowThreads(__tstate);
12900 if (PyErr_Occurred()) SWIG_fail;
12901 }
12902 resultobj = SWIG_Py_Void();
12903 return resultobj;
12904 fail:
12905 return NULL;
12906 }
12907
12908
12909 SWIGINTERN PyObject *Log_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12910 PyObject *obj;
12911 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12912 SWIG_TypeNewClientData(SWIGTYPE_p_wxLog, SWIG_NewClientData(obj));
12913 return SWIG_Py_Void();
12914 }
12915
12916 SWIGINTERN PyObject *Log_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12917 return SWIG_Python_InitShadowInstance(args);
12918 }
12919
12920 SWIGINTERN PyObject *_wrap_new_LogStderr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12921 PyObject *resultobj = 0;
12922 wxLogStderr *result = 0 ;
12923
12924 if (!SWIG_Python_UnpackTuple(args,"new_LogStderr",0,0,0)) SWIG_fail;
12925 {
12926 PyThreadState* __tstate = wxPyBeginAllowThreads();
12927 result = (wxLogStderr *)new wxLogStderr();
12928 wxPyEndAllowThreads(__tstate);
12929 if (PyErr_Occurred()) SWIG_fail;
12930 }
12931 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogStderr, SWIG_POINTER_NEW | 0 );
12932 return resultobj;
12933 fail:
12934 return NULL;
12935 }
12936
12937
12938 SWIGINTERN PyObject *LogStderr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12939 PyObject *obj;
12940 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12941 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogStderr, SWIG_NewClientData(obj));
12942 return SWIG_Py_Void();
12943 }
12944
12945 SWIGINTERN PyObject *LogStderr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12946 return SWIG_Python_InitShadowInstance(args);
12947 }
12948
12949 SWIGINTERN PyObject *_wrap_new_LogTextCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12950 PyObject *resultobj = 0;
12951 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
12952 wxLogTextCtrl *result = 0 ;
12953 void *argp1 = 0 ;
12954 int res1 = 0 ;
12955 PyObject * obj0 = 0 ;
12956 char * kwnames[] = {
12957 (char *) "pTextCtrl", NULL
12958 };
12959
12960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) SWIG_fail;
12961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextCtrl, 0 | 0 );
12962 if (!SWIG_IsOK(res1)) {
12963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogTextCtrl" "', expected argument " "1"" of type '" "wxTextCtrl *""'");
12964 }
12965 arg1 = reinterpret_cast< wxTextCtrl * >(argp1);
12966 {
12967 PyThreadState* __tstate = wxPyBeginAllowThreads();
12968 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
12969 wxPyEndAllowThreads(__tstate);
12970 if (PyErr_Occurred()) SWIG_fail;
12971 }
12972 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogTextCtrl, SWIG_POINTER_NEW | 0 );
12973 return resultobj;
12974 fail:
12975 return NULL;
12976 }
12977
12978
12979 SWIGINTERN PyObject *LogTextCtrl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12980 PyObject *obj;
12981 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12982 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogTextCtrl, SWIG_NewClientData(obj));
12983 return SWIG_Py_Void();
12984 }
12985
12986 SWIGINTERN PyObject *LogTextCtrl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12987 return SWIG_Python_InitShadowInstance(args);
12988 }
12989
12990 SWIGINTERN PyObject *_wrap_new_LogGui(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12991 PyObject *resultobj = 0;
12992 wxLogGui *result = 0 ;
12993
12994 if (!SWIG_Python_UnpackTuple(args,"new_LogGui",0,0,0)) SWIG_fail;
12995 {
12996 PyThreadState* __tstate = wxPyBeginAllowThreads();
12997 result = (wxLogGui *)new wxLogGui();
12998 wxPyEndAllowThreads(__tstate);
12999 if (PyErr_Occurred()) SWIG_fail;
13000 }
13001 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogGui, SWIG_POINTER_NEW | 0 );
13002 return resultobj;
13003 fail:
13004 return NULL;
13005 }
13006
13007
13008 SWIGINTERN PyObject *LogGui_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13009 PyObject *obj;
13010 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13011 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogGui, SWIG_NewClientData(obj));
13012 return SWIG_Py_Void();
13013 }
13014
13015 SWIGINTERN PyObject *LogGui_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13016 return SWIG_Python_InitShadowInstance(args);
13017 }
13018
13019 SWIGINTERN PyObject *_wrap_new_LogWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13020 PyObject *resultobj = 0;
13021 wxFrame *arg1 = (wxFrame *) 0 ;
13022 wxString *arg2 = 0 ;
13023 bool arg3 = (bool) true ;
13024 bool arg4 = (bool) true ;
13025 wxLogWindow *result = 0 ;
13026 void *argp1 = 0 ;
13027 int res1 = 0 ;
13028 bool temp2 = false ;
13029 bool val3 ;
13030 int ecode3 = 0 ;
13031 bool val4 ;
13032 int ecode4 = 0 ;
13033 PyObject * obj0 = 0 ;
13034 PyObject * obj1 = 0 ;
13035 PyObject * obj2 = 0 ;
13036 PyObject * obj3 = 0 ;
13037 char * kwnames[] = {
13038 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
13039 };
13040
13041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13042 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
13043 if (!SWIG_IsOK(res1)) {
13044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogWindow" "', expected argument " "1"" of type '" "wxFrame *""'");
13045 }
13046 arg1 = reinterpret_cast< wxFrame * >(argp1);
13047 {
13048 arg2 = wxString_in_helper(obj1);
13049 if (arg2 == NULL) SWIG_fail;
13050 temp2 = true;
13051 }
13052 if (obj2) {
13053 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13054 if (!SWIG_IsOK(ecode3)) {
13055 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_LogWindow" "', expected argument " "3"" of type '" "bool""'");
13056 }
13057 arg3 = static_cast< bool >(val3);
13058 }
13059 if (obj3) {
13060 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13061 if (!SWIG_IsOK(ecode4)) {
13062 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LogWindow" "', expected argument " "4"" of type '" "bool""'");
13063 }
13064 arg4 = static_cast< bool >(val4);
13065 }
13066 {
13067 PyThreadState* __tstate = wxPyBeginAllowThreads();
13068 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
13069 wxPyEndAllowThreads(__tstate);
13070 if (PyErr_Occurred()) SWIG_fail;
13071 }
13072 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogWindow, SWIG_POINTER_NEW | 0 );
13073 {
13074 if (temp2)
13075 delete arg2;
13076 }
13077 return resultobj;
13078 fail:
13079 {
13080 if (temp2)
13081 delete arg2;
13082 }
13083 return NULL;
13084 }
13085
13086
13087 SWIGINTERN PyObject *_wrap_LogWindow_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13088 PyObject *resultobj = 0;
13089 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13090 bool arg2 = (bool) true ;
13091 void *argp1 = 0 ;
13092 int res1 = 0 ;
13093 bool val2 ;
13094 int ecode2 = 0 ;
13095 PyObject * obj0 = 0 ;
13096 PyObject * obj1 = 0 ;
13097 char * kwnames[] = {
13098 (char *) "self",(char *) "bShow", NULL
13099 };
13100
13101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) SWIG_fail;
13102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13103 if (!SWIG_IsOK(res1)) {
13104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_Show" "', expected argument " "1"" of type '" "wxLogWindow *""'");
13105 }
13106 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13107 if (obj1) {
13108 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13109 if (!SWIG_IsOK(ecode2)) {
13110 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_Show" "', expected argument " "2"" of type '" "bool""'");
13111 }
13112 arg2 = static_cast< bool >(val2);
13113 }
13114 {
13115 PyThreadState* __tstate = wxPyBeginAllowThreads();
13116 (arg1)->Show(arg2);
13117 wxPyEndAllowThreads(__tstate);
13118 if (PyErr_Occurred()) SWIG_fail;
13119 }
13120 resultobj = SWIG_Py_Void();
13121 return resultobj;
13122 fail:
13123 return NULL;
13124 }
13125
13126
13127 SWIGINTERN PyObject *_wrap_LogWindow_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13128 PyObject *resultobj = 0;
13129 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13130 wxFrame *result = 0 ;
13131 void *argp1 = 0 ;
13132 int res1 = 0 ;
13133 PyObject *swig_obj[1] ;
13134
13135 if (!args) SWIG_fail;
13136 swig_obj[0] = args;
13137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13138 if (!SWIG_IsOK(res1)) {
13139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetFrame" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
13140 }
13141 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13142 {
13143 PyThreadState* __tstate = wxPyBeginAllowThreads();
13144 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
13145 wxPyEndAllowThreads(__tstate);
13146 if (PyErr_Occurred()) SWIG_fail;
13147 }
13148 {
13149 resultobj = wxPyMake_wxObject(result, (bool)0);
13150 }
13151 return resultobj;
13152 fail:
13153 return NULL;
13154 }
13155
13156
13157 SWIGINTERN PyObject *_wrap_LogWindow_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13158 PyObject *resultobj = 0;
13159 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13160 wxLog *result = 0 ;
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_GetOldLog" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
13170 }
13171 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13172 {
13173 PyThreadState* __tstate = wxPyBeginAllowThreads();
13174 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
13175 wxPyEndAllowThreads(__tstate);
13176 if (PyErr_Occurred()) SWIG_fail;
13177 }
13178 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
13179 return resultobj;
13180 fail:
13181 return NULL;
13182 }
13183
13184
13185 SWIGINTERN PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13186 PyObject *resultobj = 0;
13187 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13188 bool result;
13189 void *argp1 = 0 ;
13190 int res1 = 0 ;
13191 PyObject *swig_obj[1] ;
13192
13193 if (!args) SWIG_fail;
13194 swig_obj[0] = args;
13195 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13196 if (!SWIG_IsOK(res1)) {
13197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
13198 }
13199 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13200 {
13201 PyThreadState* __tstate = wxPyBeginAllowThreads();
13202 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
13203 wxPyEndAllowThreads(__tstate);
13204 if (PyErr_Occurred()) SWIG_fail;
13205 }
13206 {
13207 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13208 }
13209 return resultobj;
13210 fail:
13211 return NULL;
13212 }
13213
13214
13215 SWIGINTERN PyObject *_wrap_LogWindow_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13216 PyObject *resultobj = 0;
13217 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13218 bool arg2 ;
13219 void *argp1 = 0 ;
13220 int res1 = 0 ;
13221 bool val2 ;
13222 int ecode2 = 0 ;
13223 PyObject * obj0 = 0 ;
13224 PyObject * obj1 = 0 ;
13225 char * kwnames[] = {
13226 (char *) "self",(char *) "bDoPass", NULL
13227 };
13228
13229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
13230 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13231 if (!SWIG_IsOK(res1)) {
13232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_PassMessages" "', expected argument " "1"" of type '" "wxLogWindow *""'");
13233 }
13234 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13235 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13236 if (!SWIG_IsOK(ecode2)) {
13237 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_PassMessages" "', expected argument " "2"" of type '" "bool""'");
13238 }
13239 arg2 = static_cast< bool >(val2);
13240 {
13241 PyThreadState* __tstate = wxPyBeginAllowThreads();
13242 (arg1)->PassMessages(arg2);
13243 wxPyEndAllowThreads(__tstate);
13244 if (PyErr_Occurred()) SWIG_fail;
13245 }
13246 resultobj = SWIG_Py_Void();
13247 return resultobj;
13248 fail:
13249 return NULL;
13250 }
13251
13252
13253 SWIGINTERN PyObject *LogWindow_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13254 PyObject *obj;
13255 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13256 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogWindow, SWIG_NewClientData(obj));
13257 return SWIG_Py_Void();
13258 }
13259
13260 SWIGINTERN PyObject *LogWindow_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13261 return SWIG_Python_InitShadowInstance(args);
13262 }
13263
13264 SWIGINTERN PyObject *_wrap_new_LogChain(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13265 PyObject *resultobj = 0;
13266 wxLog *arg1 = (wxLog *) 0 ;
13267 wxLogChain *result = 0 ;
13268 void *argp1 = 0 ;
13269 int res1 = 0 ;
13270 PyObject * obj0 = 0 ;
13271 char * kwnames[] = {
13272 (char *) "logger", NULL
13273 };
13274
13275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) SWIG_fail;
13276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
13277 if (!SWIG_IsOK(res1)) {
13278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogChain" "', expected argument " "1"" of type '" "wxLog *""'");
13279 }
13280 arg1 = reinterpret_cast< wxLog * >(argp1);
13281 {
13282 PyThreadState* __tstate = wxPyBeginAllowThreads();
13283 result = (wxLogChain *)new wxLogChain(arg1);
13284 wxPyEndAllowThreads(__tstate);
13285 if (PyErr_Occurred()) SWIG_fail;
13286 }
13287 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogChain, SWIG_POINTER_NEW | 0 );
13288 return resultobj;
13289 fail:
13290 return NULL;
13291 }
13292
13293
13294 SWIGINTERN PyObject *_wrap_LogChain_SetLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13295 PyObject *resultobj = 0;
13296 wxLogChain *arg1 = (wxLogChain *) 0 ;
13297 wxLog *arg2 = (wxLog *) 0 ;
13298 void *argp1 = 0 ;
13299 int res1 = 0 ;
13300 void *argp2 = 0 ;
13301 int res2 = 0 ;
13302 PyObject * obj0 = 0 ;
13303 PyObject * obj1 = 0 ;
13304 char * kwnames[] = {
13305 (char *) "self",(char *) "logger", NULL
13306 };
13307
13308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) SWIG_fail;
13309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13310 if (!SWIG_IsOK(res1)) {
13311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_SetLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
13312 }
13313 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13314 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLog, 0 | 0 );
13315 if (!SWIG_IsOK(res2)) {
13316 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LogChain_SetLog" "', expected argument " "2"" of type '" "wxLog *""'");
13317 }
13318 arg2 = reinterpret_cast< wxLog * >(argp2);
13319 {
13320 PyThreadState* __tstate = wxPyBeginAllowThreads();
13321 (arg1)->SetLog(arg2);
13322 wxPyEndAllowThreads(__tstate);
13323 if (PyErr_Occurred()) SWIG_fail;
13324 }
13325 resultobj = SWIG_Py_Void();
13326 return resultobj;
13327 fail:
13328 return NULL;
13329 }
13330
13331
13332 SWIGINTERN PyObject *_wrap_LogChain_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13333 PyObject *resultobj = 0;
13334 wxLogChain *arg1 = (wxLogChain *) 0 ;
13335 bool arg2 ;
13336 void *argp1 = 0 ;
13337 int res1 = 0 ;
13338 bool val2 ;
13339 int ecode2 = 0 ;
13340 PyObject * obj0 = 0 ;
13341 PyObject * obj1 = 0 ;
13342 char * kwnames[] = {
13343 (char *) "self",(char *) "bDoPass", NULL
13344 };
13345
13346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
13347 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13348 if (!SWIG_IsOK(res1)) {
13349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_PassMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
13350 }
13351 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13352 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13353 if (!SWIG_IsOK(ecode2)) {
13354 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogChain_PassMessages" "', expected argument " "2"" of type '" "bool""'");
13355 }
13356 arg2 = static_cast< bool >(val2);
13357 {
13358 PyThreadState* __tstate = wxPyBeginAllowThreads();
13359 (arg1)->PassMessages(arg2);
13360 wxPyEndAllowThreads(__tstate);
13361 if (PyErr_Occurred()) SWIG_fail;
13362 }
13363 resultobj = SWIG_Py_Void();
13364 return resultobj;
13365 fail:
13366 return NULL;
13367 }
13368
13369
13370 SWIGINTERN PyObject *_wrap_LogChain_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13371 PyObject *resultobj = 0;
13372 wxLogChain *arg1 = (wxLogChain *) 0 ;
13373 bool result;
13374 void *argp1 = 0 ;
13375 int res1 = 0 ;
13376 PyObject *swig_obj[1] ;
13377
13378 if (!args) SWIG_fail;
13379 swig_obj[0] = args;
13380 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13381 if (!SWIG_IsOK(res1)) {
13382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
13383 }
13384 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13385 {
13386 PyThreadState* __tstate = wxPyBeginAllowThreads();
13387 result = (bool)(arg1)->IsPassingMessages();
13388 wxPyEndAllowThreads(__tstate);
13389 if (PyErr_Occurred()) SWIG_fail;
13390 }
13391 {
13392 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13393 }
13394 return resultobj;
13395 fail:
13396 return NULL;
13397 }
13398
13399
13400 SWIGINTERN PyObject *_wrap_LogChain_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13401 PyObject *resultobj = 0;
13402 wxLogChain *arg1 = (wxLogChain *) 0 ;
13403 wxLog *result = 0 ;
13404 void *argp1 = 0 ;
13405 int res1 = 0 ;
13406 PyObject *swig_obj[1] ;
13407
13408 if (!args) SWIG_fail;
13409 swig_obj[0] = args;
13410 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13411 if (!SWIG_IsOK(res1)) {
13412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_GetOldLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
13413 }
13414 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13415 {
13416 PyThreadState* __tstate = wxPyBeginAllowThreads();
13417 result = (wxLog *)(arg1)->GetOldLog();
13418 wxPyEndAllowThreads(__tstate);
13419 if (PyErr_Occurred()) SWIG_fail;
13420 }
13421 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
13422 return resultobj;
13423 fail:
13424 return NULL;
13425 }
13426
13427
13428 SWIGINTERN PyObject *LogChain_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13429 PyObject *obj;
13430 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13431 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogChain, SWIG_NewClientData(obj));
13432 return SWIG_Py_Void();
13433 }
13434
13435 SWIGINTERN PyObject *LogChain_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13436 return SWIG_Python_InitShadowInstance(args);
13437 }
13438
13439 SWIGINTERN PyObject *_wrap_new_LogBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13440 PyObject *resultobj = 0;
13441 wxLogBuffer *result = 0 ;
13442
13443 if (!SWIG_Python_UnpackTuple(args,"new_LogBuffer",0,0,0)) SWIG_fail;
13444 {
13445 PyThreadState* __tstate = wxPyBeginAllowThreads();
13446 result = (wxLogBuffer *)new wxLogBuffer();
13447 wxPyEndAllowThreads(__tstate);
13448 if (PyErr_Occurred()) SWIG_fail;
13449 }
13450 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogBuffer, SWIG_POINTER_NEW | 0 );
13451 return resultobj;
13452 fail:
13453 return NULL;
13454 }
13455
13456
13457 SWIGINTERN PyObject *_wrap_LogBuffer_GetBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13458 PyObject *resultobj = 0;
13459 wxLogBuffer *arg1 = (wxLogBuffer *) 0 ;
13460 wxString *result = 0 ;
13461 void *argp1 = 0 ;
13462 int res1 = 0 ;
13463 PyObject *swig_obj[1] ;
13464
13465 if (!args) SWIG_fail;
13466 swig_obj[0] = args;
13467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogBuffer, 0 | 0 );
13468 if (!SWIG_IsOK(res1)) {
13469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogBuffer_GetBuffer" "', expected argument " "1"" of type '" "wxLogBuffer const *""'");
13470 }
13471 arg1 = reinterpret_cast< wxLogBuffer * >(argp1);
13472 {
13473 PyThreadState* __tstate = wxPyBeginAllowThreads();
13474 {
13475 wxString const &_result_ref = ((wxLogBuffer const *)arg1)->GetBuffer();
13476 result = (wxString *) &_result_ref;
13477 }
13478 wxPyEndAllowThreads(__tstate);
13479 if (PyErr_Occurred()) SWIG_fail;
13480 }
13481 {
13482 #if wxUSE_UNICODE
13483 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13484 #else
13485 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13486 #endif
13487 }
13488 return resultobj;
13489 fail:
13490 return NULL;
13491 }
13492
13493
13494 SWIGINTERN PyObject *LogBuffer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13495 PyObject *obj;
13496 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13497 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogBuffer, SWIG_NewClientData(obj));
13498 return SWIG_Py_Void();
13499 }
13500
13501 SWIGINTERN PyObject *LogBuffer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13502 return SWIG_Python_InitShadowInstance(args);
13503 }
13504
13505 SWIGINTERN PyObject *_wrap_SysErrorCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13506 PyObject *resultobj = 0;
13507 unsigned long result;
13508
13509 if (!SWIG_Python_UnpackTuple(args,"SysErrorCode",0,0,0)) SWIG_fail;
13510 {
13511 PyThreadState* __tstate = wxPyBeginAllowThreads();
13512 result = (unsigned long)wxSysErrorCode();
13513 wxPyEndAllowThreads(__tstate);
13514 if (PyErr_Occurred()) SWIG_fail;
13515 }
13516 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
13517 return resultobj;
13518 fail:
13519 return NULL;
13520 }
13521
13522
13523 SWIGINTERN PyObject *_wrap_SysErrorMsg(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13524 PyObject *resultobj = 0;
13525 unsigned long arg1 = (unsigned long) 0 ;
13526 wxString result;
13527 unsigned long val1 ;
13528 int ecode1 = 0 ;
13529 PyObject * obj0 = 0 ;
13530 char * kwnames[] = {
13531 (char *) "nErrCode", NULL
13532 };
13533
13534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) SWIG_fail;
13535 if (obj0) {
13536 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
13537 if (!SWIG_IsOK(ecode1)) {
13538 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SysErrorMsg" "', expected argument " "1"" of type '" "unsigned long""'");
13539 }
13540 arg1 = static_cast< unsigned long >(val1);
13541 }
13542 {
13543 PyThreadState* __tstate = wxPyBeginAllowThreads();
13544 result = wxSysErrorMsg(arg1);
13545 wxPyEndAllowThreads(__tstate);
13546 if (PyErr_Occurred()) SWIG_fail;
13547 }
13548 {
13549 #if wxUSE_UNICODE
13550 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13551 #else
13552 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13553 #endif
13554 }
13555 return resultobj;
13556 fail:
13557 return NULL;
13558 }
13559
13560
13561 SWIGINTERN PyObject *_wrap_LogFatalError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13562 PyObject *resultobj = 0;
13563 wxString *arg1 = 0 ;
13564 bool temp1 = false ;
13565 PyObject * obj0 = 0 ;
13566 char * kwnames[] = {
13567 (char *) "msg", NULL
13568 };
13569
13570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) SWIG_fail;
13571 {
13572 arg1 = wxString_in_helper(obj0);
13573 if (arg1 == NULL) SWIG_fail;
13574 temp1 = true;
13575 }
13576 {
13577 PyThreadState* __tstate = wxPyBeginAllowThreads();
13578 wxPyLogFatalError((wxString const &)*arg1);
13579 wxPyEndAllowThreads(__tstate);
13580 if (PyErr_Occurred()) SWIG_fail;
13581 }
13582 resultobj = SWIG_Py_Void();
13583 {
13584 if (temp1)
13585 delete arg1;
13586 }
13587 return resultobj;
13588 fail:
13589 {
13590 if (temp1)
13591 delete arg1;
13592 }
13593 return NULL;
13594 }
13595
13596
13597 SWIGINTERN PyObject *_wrap_LogError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13598 PyObject *resultobj = 0;
13599 wxString *arg1 = 0 ;
13600 bool temp1 = false ;
13601 PyObject * obj0 = 0 ;
13602 char * kwnames[] = {
13603 (char *) "msg", NULL
13604 };
13605
13606 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) SWIG_fail;
13607 {
13608 arg1 = wxString_in_helper(obj0);
13609 if (arg1 == NULL) SWIG_fail;
13610 temp1 = true;
13611 }
13612 {
13613 PyThreadState* __tstate = wxPyBeginAllowThreads();
13614 wxPyLogError((wxString const &)*arg1);
13615 wxPyEndAllowThreads(__tstate);
13616 if (PyErr_Occurred()) SWIG_fail;
13617 }
13618 resultobj = SWIG_Py_Void();
13619 {
13620 if (temp1)
13621 delete arg1;
13622 }
13623 return resultobj;
13624 fail:
13625 {
13626 if (temp1)
13627 delete arg1;
13628 }
13629 return NULL;
13630 }
13631
13632
13633 SWIGINTERN PyObject *_wrap_LogWarning(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13634 PyObject *resultobj = 0;
13635 wxString *arg1 = 0 ;
13636 bool temp1 = false ;
13637 PyObject * obj0 = 0 ;
13638 char * kwnames[] = {
13639 (char *) "msg", NULL
13640 };
13641
13642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) SWIG_fail;
13643 {
13644 arg1 = wxString_in_helper(obj0);
13645 if (arg1 == NULL) SWIG_fail;
13646 temp1 = true;
13647 }
13648 {
13649 PyThreadState* __tstate = wxPyBeginAllowThreads();
13650 wxPyLogWarning((wxString const &)*arg1);
13651 wxPyEndAllowThreads(__tstate);
13652 if (PyErr_Occurred()) SWIG_fail;
13653 }
13654 resultobj = SWIG_Py_Void();
13655 {
13656 if (temp1)
13657 delete arg1;
13658 }
13659 return resultobj;
13660 fail:
13661 {
13662 if (temp1)
13663 delete arg1;
13664 }
13665 return NULL;
13666 }
13667
13668
13669 SWIGINTERN PyObject *_wrap_LogMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13670 PyObject *resultobj = 0;
13671 wxString *arg1 = 0 ;
13672 bool temp1 = false ;
13673 PyObject * obj0 = 0 ;
13674 char * kwnames[] = {
13675 (char *) "msg", NULL
13676 };
13677
13678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) SWIG_fail;
13679 {
13680 arg1 = wxString_in_helper(obj0);
13681 if (arg1 == NULL) SWIG_fail;
13682 temp1 = true;
13683 }
13684 {
13685 PyThreadState* __tstate = wxPyBeginAllowThreads();
13686 wxPyLogMessage((wxString const &)*arg1);
13687 wxPyEndAllowThreads(__tstate);
13688 if (PyErr_Occurred()) SWIG_fail;
13689 }
13690 resultobj = SWIG_Py_Void();
13691 {
13692 if (temp1)
13693 delete arg1;
13694 }
13695 return resultobj;
13696 fail:
13697 {
13698 if (temp1)
13699 delete arg1;
13700 }
13701 return NULL;
13702 }
13703
13704
13705 SWIGINTERN PyObject *_wrap_LogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13706 PyObject *resultobj = 0;
13707 wxString *arg1 = 0 ;
13708 bool temp1 = false ;
13709 PyObject * obj0 = 0 ;
13710 char * kwnames[] = {
13711 (char *) "msg", NULL
13712 };
13713
13714 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) SWIG_fail;
13715 {
13716 arg1 = wxString_in_helper(obj0);
13717 if (arg1 == NULL) SWIG_fail;
13718 temp1 = true;
13719 }
13720 {
13721 PyThreadState* __tstate = wxPyBeginAllowThreads();
13722 wxPyLogInfo((wxString const &)*arg1);
13723 wxPyEndAllowThreads(__tstate);
13724 if (PyErr_Occurred()) SWIG_fail;
13725 }
13726 resultobj = SWIG_Py_Void();
13727 {
13728 if (temp1)
13729 delete arg1;
13730 }
13731 return resultobj;
13732 fail:
13733 {
13734 if (temp1)
13735 delete arg1;
13736 }
13737 return NULL;
13738 }
13739
13740
13741 SWIGINTERN PyObject *_wrap_LogDebug(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13742 PyObject *resultobj = 0;
13743 wxString *arg1 = 0 ;
13744 bool temp1 = false ;
13745 PyObject * obj0 = 0 ;
13746 char * kwnames[] = {
13747 (char *) "msg", NULL
13748 };
13749
13750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) SWIG_fail;
13751 {
13752 arg1 = wxString_in_helper(obj0);
13753 if (arg1 == NULL) SWIG_fail;
13754 temp1 = true;
13755 }
13756 {
13757 PyThreadState* __tstate = wxPyBeginAllowThreads();
13758 wxPyLogDebug((wxString const &)*arg1);
13759 wxPyEndAllowThreads(__tstate);
13760 if (PyErr_Occurred()) SWIG_fail;
13761 }
13762 resultobj = SWIG_Py_Void();
13763 {
13764 if (temp1)
13765 delete arg1;
13766 }
13767 return resultobj;
13768 fail:
13769 {
13770 if (temp1)
13771 delete arg1;
13772 }
13773 return NULL;
13774 }
13775
13776
13777 SWIGINTERN PyObject *_wrap_LogVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13778 PyObject *resultobj = 0;
13779 wxString *arg1 = 0 ;
13780 bool temp1 = false ;
13781 PyObject * obj0 = 0 ;
13782 char * kwnames[] = {
13783 (char *) "msg", NULL
13784 };
13785
13786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) SWIG_fail;
13787 {
13788 arg1 = wxString_in_helper(obj0);
13789 if (arg1 == NULL) SWIG_fail;
13790 temp1 = true;
13791 }
13792 {
13793 PyThreadState* __tstate = wxPyBeginAllowThreads();
13794 wxPyLogVerbose((wxString const &)*arg1);
13795 wxPyEndAllowThreads(__tstate);
13796 if (PyErr_Occurred()) SWIG_fail;
13797 }
13798 resultobj = SWIG_Py_Void();
13799 {
13800 if (temp1)
13801 delete arg1;
13802 }
13803 return resultobj;
13804 fail:
13805 {
13806 if (temp1)
13807 delete arg1;
13808 }
13809 return NULL;
13810 }
13811
13812
13813 SWIGINTERN PyObject *_wrap_LogStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13814 PyObject *resultobj = 0;
13815 wxString *arg1 = 0 ;
13816 bool temp1 = false ;
13817 PyObject * obj0 = 0 ;
13818 char * kwnames[] = {
13819 (char *) "msg", NULL
13820 };
13821
13822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) SWIG_fail;
13823 {
13824 arg1 = wxString_in_helper(obj0);
13825 if (arg1 == NULL) SWIG_fail;
13826 temp1 = true;
13827 }
13828 {
13829 PyThreadState* __tstate = wxPyBeginAllowThreads();
13830 wxPyLogStatus((wxString const &)*arg1);
13831 wxPyEndAllowThreads(__tstate);
13832 if (PyErr_Occurred()) SWIG_fail;
13833 }
13834 resultobj = SWIG_Py_Void();
13835 {
13836 if (temp1)
13837 delete arg1;
13838 }
13839 return resultobj;
13840 fail:
13841 {
13842 if (temp1)
13843 delete arg1;
13844 }
13845 return NULL;
13846 }
13847
13848
13849 SWIGINTERN PyObject *_wrap_LogStatusFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13850 PyObject *resultobj = 0;
13851 wxFrame *arg1 = (wxFrame *) 0 ;
13852 wxString *arg2 = 0 ;
13853 void *argp1 = 0 ;
13854 int res1 = 0 ;
13855 bool temp2 = false ;
13856 PyObject * obj0 = 0 ;
13857 PyObject * obj1 = 0 ;
13858 char * kwnames[] = {
13859 (char *) "pFrame",(char *) "msg", NULL
13860 };
13861
13862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) SWIG_fail;
13863 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
13864 if (!SWIG_IsOK(res1)) {
13865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogStatusFrame" "', expected argument " "1"" of type '" "wxFrame *""'");
13866 }
13867 arg1 = reinterpret_cast< wxFrame * >(argp1);
13868 {
13869 arg2 = wxString_in_helper(obj1);
13870 if (arg2 == NULL) SWIG_fail;
13871 temp2 = true;
13872 }
13873 {
13874 PyThreadState* __tstate = wxPyBeginAllowThreads();
13875 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
13876 wxPyEndAllowThreads(__tstate);
13877 if (PyErr_Occurred()) SWIG_fail;
13878 }
13879 resultobj = SWIG_Py_Void();
13880 {
13881 if (temp2)
13882 delete arg2;
13883 }
13884 return resultobj;
13885 fail:
13886 {
13887 if (temp2)
13888 delete arg2;
13889 }
13890 return NULL;
13891 }
13892
13893
13894 SWIGINTERN PyObject *_wrap_LogSysError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13895 PyObject *resultobj = 0;
13896 wxString *arg1 = 0 ;
13897 bool temp1 = false ;
13898 PyObject * obj0 = 0 ;
13899 char * kwnames[] = {
13900 (char *) "msg", NULL
13901 };
13902
13903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) SWIG_fail;
13904 {
13905 arg1 = wxString_in_helper(obj0);
13906 if (arg1 == NULL) SWIG_fail;
13907 temp1 = true;
13908 }
13909 {
13910 PyThreadState* __tstate = wxPyBeginAllowThreads();
13911 wxPyLogSysError((wxString const &)*arg1);
13912 wxPyEndAllowThreads(__tstate);
13913 if (PyErr_Occurred()) SWIG_fail;
13914 }
13915 resultobj = SWIG_Py_Void();
13916 {
13917 if (temp1)
13918 delete arg1;
13919 }
13920 return resultobj;
13921 fail:
13922 {
13923 if (temp1)
13924 delete arg1;
13925 }
13926 return NULL;
13927 }
13928
13929
13930 SWIGINTERN PyObject *_wrap_LogGeneric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13931 PyObject *resultobj = 0;
13932 unsigned long arg1 ;
13933 wxString *arg2 = 0 ;
13934 unsigned long val1 ;
13935 int ecode1 = 0 ;
13936 bool temp2 = false ;
13937 PyObject * obj0 = 0 ;
13938 PyObject * obj1 = 0 ;
13939 char * kwnames[] = {
13940 (char *) "level",(char *) "msg", NULL
13941 };
13942
13943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) SWIG_fail;
13944 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
13945 if (!SWIG_IsOK(ecode1)) {
13946 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogGeneric" "', expected argument " "1"" of type '" "unsigned long""'");
13947 }
13948 arg1 = static_cast< unsigned long >(val1);
13949 {
13950 arg2 = wxString_in_helper(obj1);
13951 if (arg2 == NULL) SWIG_fail;
13952 temp2 = true;
13953 }
13954 {
13955 PyThreadState* __tstate = wxPyBeginAllowThreads();
13956 wxPyLogGeneric(arg1,(wxString const &)*arg2);
13957 wxPyEndAllowThreads(__tstate);
13958 if (PyErr_Occurred()) SWIG_fail;
13959 }
13960 resultobj = SWIG_Py_Void();
13961 {
13962 if (temp2)
13963 delete arg2;
13964 }
13965 return resultobj;
13966 fail:
13967 {
13968 if (temp2)
13969 delete arg2;
13970 }
13971 return NULL;
13972 }
13973
13974
13975 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
13976 PyObject *resultobj = 0;
13977 unsigned long arg1 ;
13978 wxString *arg2 = 0 ;
13979 unsigned long val1 ;
13980 int ecode1 = 0 ;
13981 bool temp2 = false ;
13982
13983 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
13984 ecode1 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val1);
13985 if (!SWIG_IsOK(ecode1)) {
13986 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogTrace" "', expected argument " "1"" of type '" "unsigned long""'");
13987 }
13988 arg1 = static_cast< unsigned long >(val1);
13989 {
13990 arg2 = wxString_in_helper(swig_obj[1]);
13991 if (arg2 == NULL) SWIG_fail;
13992 temp2 = true;
13993 }
13994 {
13995 PyThreadState* __tstate = wxPyBeginAllowThreads();
13996 wxPyLogTrace(arg1,(wxString const &)*arg2);
13997 wxPyEndAllowThreads(__tstate);
13998 if (PyErr_Occurred()) SWIG_fail;
13999 }
14000 resultobj = SWIG_Py_Void();
14001 {
14002 if (temp2)
14003 delete arg2;
14004 }
14005 return resultobj;
14006 fail:
14007 {
14008 if (temp2)
14009 delete arg2;
14010 }
14011 return NULL;
14012 }
14013
14014
14015 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
14016 PyObject *resultobj = 0;
14017 wxString *arg1 = 0 ;
14018 wxString *arg2 = 0 ;
14019 bool temp1 = false ;
14020 bool temp2 = false ;
14021
14022 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
14023 {
14024 arg1 = wxString_in_helper(swig_obj[0]);
14025 if (arg1 == NULL) SWIG_fail;
14026 temp1 = true;
14027 }
14028 {
14029 arg2 = wxString_in_helper(swig_obj[1]);
14030 if (arg2 == NULL) SWIG_fail;
14031 temp2 = true;
14032 }
14033 {
14034 PyThreadState* __tstate = wxPyBeginAllowThreads();
14035 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
14036 wxPyEndAllowThreads(__tstate);
14037 if (PyErr_Occurred()) SWIG_fail;
14038 }
14039 resultobj = SWIG_Py_Void();
14040 {
14041 if (temp1)
14042 delete arg1;
14043 }
14044 {
14045 if (temp2)
14046 delete arg2;
14047 }
14048 return resultobj;
14049 fail:
14050 {
14051 if (temp1)
14052 delete arg1;
14053 }
14054 {
14055 if (temp2)
14056 delete arg2;
14057 }
14058 return NULL;
14059 }
14060
14061
14062 SWIGINTERN PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
14063 int argc;
14064 PyObject *argv[3];
14065
14066 if (!(argc = SWIG_Python_UnpackTuple(args,"LogTrace",0,2,argv))) SWIG_fail;
14067 --argc;
14068 if (argc == 2) {
14069 int _v = 0;
14070 {
14071 {
14072 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
14073 }
14074 }
14075 if (!_v) goto check_1;
14076 return _wrap_LogTrace__SWIG_1(self, argc, argv);
14077 }
14078 check_1:
14079
14080 if (argc == 2) {
14081 return _wrap_LogTrace__SWIG_0(self, argc, argv);
14082 }
14083
14084 fail:
14085 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
14086 return NULL;
14087 }
14088
14089
14090 SWIGINTERN PyObject *_wrap_SafeShowMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14091 PyObject *resultobj = 0;
14092 wxString *arg1 = 0 ;
14093 wxString *arg2 = 0 ;
14094 bool temp1 = false ;
14095 bool temp2 = false ;
14096 PyObject * obj0 = 0 ;
14097 PyObject * obj1 = 0 ;
14098 char * kwnames[] = {
14099 (char *) "title",(char *) "text", NULL
14100 };
14101
14102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) SWIG_fail;
14103 {
14104 arg1 = wxString_in_helper(obj0);
14105 if (arg1 == NULL) SWIG_fail;
14106 temp1 = true;
14107 }
14108 {
14109 arg2 = wxString_in_helper(obj1);
14110 if (arg2 == NULL) SWIG_fail;
14111 temp2 = true;
14112 }
14113 {
14114 PyThreadState* __tstate = wxPyBeginAllowThreads();
14115 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
14116 wxPyEndAllowThreads(__tstate);
14117 if (PyErr_Occurred()) SWIG_fail;
14118 }
14119 resultobj = SWIG_Py_Void();
14120 {
14121 if (temp1)
14122 delete arg1;
14123 }
14124 {
14125 if (temp2)
14126 delete arg2;
14127 }
14128 return resultobj;
14129 fail:
14130 {
14131 if (temp1)
14132 delete arg1;
14133 }
14134 {
14135 if (temp2)
14136 delete arg2;
14137 }
14138 return NULL;
14139 }
14140
14141
14142 SWIGINTERN PyObject *_wrap_new_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14143 PyObject *resultobj = 0;
14144 wxLogNull *result = 0 ;
14145
14146 if (!SWIG_Python_UnpackTuple(args,"new_LogNull",0,0,0)) SWIG_fail;
14147 {
14148 PyThreadState* __tstate = wxPyBeginAllowThreads();
14149 result = (wxLogNull *)new wxLogNull();
14150 wxPyEndAllowThreads(__tstate);
14151 if (PyErr_Occurred()) SWIG_fail;
14152 }
14153 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogNull, SWIG_POINTER_NEW | 0 );
14154 return resultobj;
14155 fail:
14156 return NULL;
14157 }
14158
14159
14160 SWIGINTERN PyObject *_wrap_delete_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14161 PyObject *resultobj = 0;
14162 wxLogNull *arg1 = (wxLogNull *) 0 ;
14163 void *argp1 = 0 ;
14164 int res1 = 0 ;
14165 PyObject *swig_obj[1] ;
14166
14167 if (!args) SWIG_fail;
14168 swig_obj[0] = args;
14169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogNull, SWIG_POINTER_DISOWN | 0 );
14170 if (!SWIG_IsOK(res1)) {
14171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LogNull" "', expected argument " "1"" of type '" "wxLogNull *""'");
14172 }
14173 arg1 = reinterpret_cast< wxLogNull * >(argp1);
14174 {
14175 PyThreadState* __tstate = wxPyBeginAllowThreads();
14176 delete arg1;
14177
14178 wxPyEndAllowThreads(__tstate);
14179 if (PyErr_Occurred()) SWIG_fail;
14180 }
14181 resultobj = SWIG_Py_Void();
14182 return resultobj;
14183 fail:
14184 return NULL;
14185 }
14186
14187
14188 SWIGINTERN PyObject *LogNull_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14189 PyObject *obj;
14190 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14191 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogNull, SWIG_NewClientData(obj));
14192 return SWIG_Py_Void();
14193 }
14194
14195 SWIGINTERN PyObject *LogNull_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14196 return SWIG_Python_InitShadowInstance(args);
14197 }
14198
14199 SWIGINTERN PyObject *_wrap_new_PyLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14200 PyObject *resultobj = 0;
14201 wxPyLog *result = 0 ;
14202
14203 if (!SWIG_Python_UnpackTuple(args,"new_PyLog",0,0,0)) SWIG_fail;
14204 {
14205 PyThreadState* __tstate = wxPyBeginAllowThreads();
14206 result = (wxPyLog *)new wxPyLog();
14207 wxPyEndAllowThreads(__tstate);
14208 if (PyErr_Occurred()) SWIG_fail;
14209 }
14210 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyLog, SWIG_POINTER_NEW | 0 );
14211 return resultobj;
14212 fail:
14213 return NULL;
14214 }
14215
14216
14217 SWIGINTERN PyObject *_wrap_PyLog__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14218 PyObject *resultobj = 0;
14219 wxPyLog *arg1 = (wxPyLog *) 0 ;
14220 PyObject *arg2 = (PyObject *) 0 ;
14221 PyObject *arg3 = (PyObject *) 0 ;
14222 void *argp1 = 0 ;
14223 int res1 = 0 ;
14224 PyObject * obj0 = 0 ;
14225 PyObject * obj1 = 0 ;
14226 PyObject * obj2 = 0 ;
14227 char * kwnames[] = {
14228 (char *) "self",(char *) "self",(char *) "_class", NULL
14229 };
14230
14231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14232 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyLog, 0 | 0 );
14233 if (!SWIG_IsOK(res1)) {
14234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyLog__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyLog *""'");
14235 }
14236 arg1 = reinterpret_cast< wxPyLog * >(argp1);
14237 arg2 = obj1;
14238 arg3 = obj2;
14239 {
14240 PyThreadState* __tstate = wxPyBeginAllowThreads();
14241 (arg1)->_setCallbackInfo(arg2,arg3);
14242 wxPyEndAllowThreads(__tstate);
14243 if (PyErr_Occurred()) SWIG_fail;
14244 }
14245 resultobj = SWIG_Py_Void();
14246 return resultobj;
14247 fail:
14248 return NULL;
14249 }
14250
14251
14252 SWIGINTERN PyObject *PyLog_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14253 PyObject *obj;
14254 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14255 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyLog, SWIG_NewClientData(obj));
14256 return SWIG_Py_Void();
14257 }
14258
14259 SWIGINTERN PyObject *PyLog_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14260 return SWIG_Python_InitShadowInstance(args);
14261 }
14262
14263 SWIGINTERN PyObject *_wrap_Process_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14264 PyObject *resultobj = 0;
14265 int arg1 ;
14266 wxSignal arg2 = (wxSignal) wxSIGTERM ;
14267 int arg3 = (int) wxKILL_NOCHILDREN ;
14268 wxKillError result;
14269 int val1 ;
14270 int ecode1 = 0 ;
14271 int val2 ;
14272 int ecode2 = 0 ;
14273 int val3 ;
14274 int ecode3 = 0 ;
14275 PyObject * obj0 = 0 ;
14276 PyObject * obj1 = 0 ;
14277 PyObject * obj2 = 0 ;
14278 char * kwnames[] = {
14279 (char *) "pid",(char *) "sig",(char *) "flags", NULL
14280 };
14281
14282 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14283 ecode1 = SWIG_AsVal_int(obj0, &val1);
14284 if (!SWIG_IsOK(ecode1)) {
14285 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Kill" "', expected argument " "1"" of type '" "int""'");
14286 }
14287 arg1 = static_cast< int >(val1);
14288 if (obj1) {
14289 ecode2 = SWIG_AsVal_int(obj1, &val2);
14290 if (!SWIG_IsOK(ecode2)) {
14291 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Kill" "', expected argument " "2"" of type '" "wxSignal""'");
14292 }
14293 arg2 = static_cast< wxSignal >(val2);
14294 }
14295 if (obj2) {
14296 ecode3 = SWIG_AsVal_int(obj2, &val3);
14297 if (!SWIG_IsOK(ecode3)) {
14298 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_Kill" "', expected argument " "3"" of type '" "int""'");
14299 }
14300 arg3 = static_cast< int >(val3);
14301 }
14302 {
14303 PyThreadState* __tstate = wxPyBeginAllowThreads();
14304 result = (wxKillError)wxPyProcess::Kill(arg1,arg2,arg3);
14305 wxPyEndAllowThreads(__tstate);
14306 if (PyErr_Occurred()) SWIG_fail;
14307 }
14308 resultobj = SWIG_From_int(static_cast< int >(result));
14309 return resultobj;
14310 fail:
14311 return NULL;
14312 }
14313
14314
14315 SWIGINTERN PyObject *_wrap_Process_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14316 PyObject *resultobj = 0;
14317 int arg1 ;
14318 bool result;
14319 int val1 ;
14320 int ecode1 = 0 ;
14321 PyObject * obj0 = 0 ;
14322 char * kwnames[] = {
14323 (char *) "pid", NULL
14324 };
14325
14326 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) SWIG_fail;
14327 ecode1 = SWIG_AsVal_int(obj0, &val1);
14328 if (!SWIG_IsOK(ecode1)) {
14329 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Exists" "', expected argument " "1"" of type '" "int""'");
14330 }
14331 arg1 = static_cast< int >(val1);
14332 {
14333 PyThreadState* __tstate = wxPyBeginAllowThreads();
14334 result = (bool)wxPyProcess::Exists(arg1);
14335 wxPyEndAllowThreads(__tstate);
14336 if (PyErr_Occurred()) SWIG_fail;
14337 }
14338 {
14339 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14340 }
14341 return resultobj;
14342 fail:
14343 return NULL;
14344 }
14345
14346
14347 SWIGINTERN PyObject *_wrap_Process_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14348 PyObject *resultobj = 0;
14349 wxString *arg1 = 0 ;
14350 int arg2 = (int) wxEXEC_ASYNC ;
14351 wxPyProcess *result = 0 ;
14352 bool temp1 = false ;
14353 int val2 ;
14354 int ecode2 = 0 ;
14355 PyObject * obj0 = 0 ;
14356 PyObject * obj1 = 0 ;
14357 char * kwnames[] = {
14358 (char *) "cmd",(char *) "flags", NULL
14359 };
14360
14361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) SWIG_fail;
14362 {
14363 arg1 = wxString_in_helper(obj0);
14364 if (arg1 == NULL) SWIG_fail;
14365 temp1 = true;
14366 }
14367 if (obj1) {
14368 ecode2 = SWIG_AsVal_int(obj1, &val2);
14369 if (!SWIG_IsOK(ecode2)) {
14370 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Open" "', expected argument " "2"" of type '" "int""'");
14371 }
14372 arg2 = static_cast< int >(val2);
14373 }
14374 {
14375 PyThreadState* __tstate = wxPyBeginAllowThreads();
14376 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
14377 wxPyEndAllowThreads(__tstate);
14378 if (PyErr_Occurred()) SWIG_fail;
14379 }
14380 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, 0 | 0 );
14381 {
14382 if (temp1)
14383 delete arg1;
14384 }
14385 return resultobj;
14386 fail:
14387 {
14388 if (temp1)
14389 delete arg1;
14390 }
14391 return NULL;
14392 }
14393
14394
14395 SWIGINTERN PyObject *_wrap_new_Process(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14396 PyObject *resultobj = 0;
14397 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
14398 int arg2 = (int) -1 ;
14399 wxPyProcess *result = 0 ;
14400 void *argp1 = 0 ;
14401 int res1 = 0 ;
14402 int val2 ;
14403 int ecode2 = 0 ;
14404 PyObject * obj0 = 0 ;
14405 PyObject * obj1 = 0 ;
14406 char * kwnames[] = {
14407 (char *) "parent",(char *) "id", NULL
14408 };
14409
14410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) SWIG_fail;
14411 if (obj0) {
14412 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
14413 if (!SWIG_IsOK(res1)) {
14414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Process" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
14415 }
14416 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
14417 }
14418 if (obj1) {
14419 ecode2 = SWIG_AsVal_int(obj1, &val2);
14420 if (!SWIG_IsOK(ecode2)) {
14421 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Process" "', expected argument " "2"" of type '" "int""'");
14422 }
14423 arg2 = static_cast< int >(val2);
14424 }
14425 {
14426 PyThreadState* __tstate = wxPyBeginAllowThreads();
14427 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
14428 wxPyEndAllowThreads(__tstate);
14429 if (PyErr_Occurred()) SWIG_fail;
14430 }
14431 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, SWIG_POINTER_NEW | 0 );
14432 return resultobj;
14433 fail:
14434 return NULL;
14435 }
14436
14437
14438 SWIGINTERN PyObject *_wrap_delete_Process(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14439 PyObject *resultobj = 0;
14440 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14441 void *argp1 = 0 ;
14442 int res1 = 0 ;
14443 PyObject *swig_obj[1] ;
14444
14445 if (!args) SWIG_fail;
14446 swig_obj[0] = args;
14447 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, SWIG_POINTER_DISOWN | 0 );
14448 if (!SWIG_IsOK(res1)) {
14449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Process" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14450 }
14451 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14452 {
14453 PyThreadState* __tstate = wxPyBeginAllowThreads();
14454 delete arg1;
14455
14456 wxPyEndAllowThreads(__tstate);
14457 if (PyErr_Occurred()) SWIG_fail;
14458 }
14459 resultobj = SWIG_Py_Void();
14460 return resultobj;
14461 fail:
14462 return NULL;
14463 }
14464
14465
14466 SWIGINTERN PyObject *_wrap_Process__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14467 PyObject *resultobj = 0;
14468 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14469 PyObject *arg2 = (PyObject *) 0 ;
14470 PyObject *arg3 = (PyObject *) 0 ;
14471 void *argp1 = 0 ;
14472 int res1 = 0 ;
14473 PyObject * obj0 = 0 ;
14474 PyObject * obj1 = 0 ;
14475 PyObject * obj2 = 0 ;
14476 char * kwnames[] = {
14477 (char *) "self",(char *) "self",(char *) "_class", NULL
14478 };
14479
14480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14481 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14482 if (!SWIG_IsOK(res1)) {
14483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14484 }
14485 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14486 arg2 = obj1;
14487 arg3 = obj2;
14488 {
14489 PyThreadState* __tstate = wxPyBeginAllowThreads();
14490 (arg1)->_setCallbackInfo(arg2,arg3);
14491 wxPyEndAllowThreads(__tstate);
14492 if (PyErr_Occurred()) SWIG_fail;
14493 }
14494 resultobj = SWIG_Py_Void();
14495 return resultobj;
14496 fail:
14497 return NULL;
14498 }
14499
14500
14501 SWIGINTERN PyObject *_wrap_Process_GetPid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14502 PyObject *resultobj = 0;
14503 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14504 long result;
14505 void *argp1 = 0 ;
14506 int res1 = 0 ;
14507 PyObject *swig_obj[1] ;
14508
14509 if (!args) SWIG_fail;
14510 swig_obj[0] = args;
14511 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14512 if (!SWIG_IsOK(res1)) {
14513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetPid" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14514 }
14515 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14516 {
14517 PyThreadState* __tstate = wxPyBeginAllowThreads();
14518 result = (long)((wxPyProcess const *)arg1)->GetPid();
14519 wxPyEndAllowThreads(__tstate);
14520 if (PyErr_Occurred()) SWIG_fail;
14521 }
14522 resultobj = SWIG_From_long(static_cast< long >(result));
14523 return resultobj;
14524 fail:
14525 return NULL;
14526 }
14527
14528
14529 SWIGINTERN PyObject *_wrap_Process_OnTerminate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14530 PyObject *resultobj = 0;
14531 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14532 int arg2 ;
14533 int arg3 ;
14534 void *argp1 = 0 ;
14535 int res1 = 0 ;
14536 int val2 ;
14537 int ecode2 = 0 ;
14538 int val3 ;
14539 int ecode3 = 0 ;
14540 PyObject * obj0 = 0 ;
14541 PyObject * obj1 = 0 ;
14542 PyObject * obj2 = 0 ;
14543 char * kwnames[] = {
14544 (char *) "self",(char *) "pid",(char *) "status", NULL
14545 };
14546
14547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_OnTerminate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14549 if (!SWIG_IsOK(res1)) {
14550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_OnTerminate" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14551 }
14552 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14553 ecode2 = SWIG_AsVal_int(obj1, &val2);
14554 if (!SWIG_IsOK(ecode2)) {
14555 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_OnTerminate" "', expected argument " "2"" of type '" "int""'");
14556 }
14557 arg2 = static_cast< int >(val2);
14558 ecode3 = SWIG_AsVal_int(obj2, &val3);
14559 if (!SWIG_IsOK(ecode3)) {
14560 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_OnTerminate" "', expected argument " "3"" of type '" "int""'");
14561 }
14562 arg3 = static_cast< int >(val3);
14563 {
14564 PyThreadState* __tstate = wxPyBeginAllowThreads();
14565 (arg1)->OnTerminate(arg2,arg3);
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_Redirect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14577 PyObject *resultobj = 0;
14578 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14579 void *argp1 = 0 ;
14580 int res1 = 0 ;
14581 PyObject *swig_obj[1] ;
14582
14583 if (!args) SWIG_fail;
14584 swig_obj[0] = args;
14585 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14586 if (!SWIG_IsOK(res1)) {
14587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Redirect" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14588 }
14589 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14590 {
14591 PyThreadState* __tstate = wxPyBeginAllowThreads();
14592 (arg1)->Redirect();
14593 wxPyEndAllowThreads(__tstate);
14594 if (PyErr_Occurred()) SWIG_fail;
14595 }
14596 resultobj = SWIG_Py_Void();
14597 return resultobj;
14598 fail:
14599 return NULL;
14600 }
14601
14602
14603 SWIGINTERN PyObject *_wrap_Process_IsRedirected(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14604 PyObject *resultobj = 0;
14605 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14606 bool result;
14607 void *argp1 = 0 ;
14608 int res1 = 0 ;
14609 PyObject *swig_obj[1] ;
14610
14611 if (!args) SWIG_fail;
14612 swig_obj[0] = args;
14613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14614 if (!SWIG_IsOK(res1)) {
14615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsRedirected" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14616 }
14617 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14618 {
14619 PyThreadState* __tstate = wxPyBeginAllowThreads();
14620 result = (bool)(arg1)->IsRedirected();
14621 wxPyEndAllowThreads(__tstate);
14622 if (PyErr_Occurred()) SWIG_fail;
14623 }
14624 {
14625 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14626 }
14627 return resultobj;
14628 fail:
14629 return NULL;
14630 }
14631
14632
14633 SWIGINTERN PyObject *_wrap_Process_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14634 PyObject *resultobj = 0;
14635 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14636 void *argp1 = 0 ;
14637 int res1 = 0 ;
14638 PyObject *swig_obj[1] ;
14639
14640 if (!args) SWIG_fail;
14641 swig_obj[0] = args;
14642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14643 if (!SWIG_IsOK(res1)) {
14644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Detach" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14645 }
14646 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14647 {
14648 PyThreadState* __tstate = wxPyBeginAllowThreads();
14649 (arg1)->Detach();
14650 wxPyEndAllowThreads(__tstate);
14651 if (PyErr_Occurred()) SWIG_fail;
14652 }
14653 resultobj = SWIG_Py_Void();
14654 return resultobj;
14655 fail:
14656 return NULL;
14657 }
14658
14659
14660 SWIGINTERN PyObject *_wrap_Process_GetInputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14661 PyObject *resultobj = 0;
14662 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14663 wxInputStream *result = 0 ;
14664 void *argp1 = 0 ;
14665 int res1 = 0 ;
14666 PyObject *swig_obj[1] ;
14667
14668 if (!args) SWIG_fail;
14669 swig_obj[0] = args;
14670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14671 if (!SWIG_IsOK(res1)) {
14672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetInputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14673 }
14674 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14675 {
14676 PyThreadState* __tstate = wxPyBeginAllowThreads();
14677 result = (wxInputStream *)(arg1)->GetInputStream();
14678 wxPyEndAllowThreads(__tstate);
14679 if (PyErr_Occurred()) SWIG_fail;
14680 }
14681 {
14682 wxPyInputStream * _ptr = NULL;
14683
14684 if (result) {
14685 _ptr = new wxPyInputStream(result);
14686 }
14687 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
14688 }
14689 return resultobj;
14690 fail:
14691 return NULL;
14692 }
14693
14694
14695 SWIGINTERN PyObject *_wrap_Process_GetErrorStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14696 PyObject *resultobj = 0;
14697 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14698 wxInputStream *result = 0 ;
14699 void *argp1 = 0 ;
14700 int res1 = 0 ;
14701 PyObject *swig_obj[1] ;
14702
14703 if (!args) SWIG_fail;
14704 swig_obj[0] = args;
14705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14706 if (!SWIG_IsOK(res1)) {
14707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetErrorStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14708 }
14709 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14710 {
14711 PyThreadState* __tstate = wxPyBeginAllowThreads();
14712 result = (wxInputStream *)(arg1)->GetErrorStream();
14713 wxPyEndAllowThreads(__tstate);
14714 if (PyErr_Occurred()) SWIG_fail;
14715 }
14716 {
14717 wxPyInputStream * _ptr = NULL;
14718
14719 if (result) {
14720 _ptr = new wxPyInputStream(result);
14721 }
14722 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
14723 }
14724 return resultobj;
14725 fail:
14726 return NULL;
14727 }
14728
14729
14730 SWIGINTERN PyObject *_wrap_Process_GetOutputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14731 PyObject *resultobj = 0;
14732 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14733 wxOutputStream *result = 0 ;
14734 void *argp1 = 0 ;
14735 int res1 = 0 ;
14736 PyObject *swig_obj[1] ;
14737
14738 if (!args) SWIG_fail;
14739 swig_obj[0] = args;
14740 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14741 if (!SWIG_IsOK(res1)) {
14742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetOutputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14743 }
14744 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14745 {
14746 PyThreadState* __tstate = wxPyBeginAllowThreads();
14747 result = (wxOutputStream *)(arg1)->GetOutputStream();
14748 wxPyEndAllowThreads(__tstate);
14749 if (PyErr_Occurred()) SWIG_fail;
14750 }
14751 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxOutputStream, 0 | 0 );
14752 return resultobj;
14753 fail:
14754 return NULL;
14755 }
14756
14757
14758 SWIGINTERN PyObject *_wrap_Process_CloseOutput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14759 PyObject *resultobj = 0;
14760 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14761 void *argp1 = 0 ;
14762 int res1 = 0 ;
14763 PyObject *swig_obj[1] ;
14764
14765 if (!args) SWIG_fail;
14766 swig_obj[0] = args;
14767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14768 if (!SWIG_IsOK(res1)) {
14769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_CloseOutput" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14770 }
14771 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14772 {
14773 PyThreadState* __tstate = wxPyBeginAllowThreads();
14774 (arg1)->CloseOutput();
14775 wxPyEndAllowThreads(__tstate);
14776 if (PyErr_Occurred()) SWIG_fail;
14777 }
14778 resultobj = SWIG_Py_Void();
14779 return resultobj;
14780 fail:
14781 return NULL;
14782 }
14783
14784
14785 SWIGINTERN PyObject *_wrap_Process_IsInputOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14786 PyObject *resultobj = 0;
14787 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14788 bool result;
14789 void *argp1 = 0 ;
14790 int res1 = 0 ;
14791 PyObject *swig_obj[1] ;
14792
14793 if (!args) SWIG_fail;
14794 swig_obj[0] = args;
14795 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14796 if (!SWIG_IsOK(res1)) {
14797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputOpened" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14798 }
14799 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14800 {
14801 PyThreadState* __tstate = wxPyBeginAllowThreads();
14802 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
14803 wxPyEndAllowThreads(__tstate);
14804 if (PyErr_Occurred()) SWIG_fail;
14805 }
14806 {
14807 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14808 }
14809 return resultobj;
14810 fail:
14811 return NULL;
14812 }
14813
14814
14815 SWIGINTERN PyObject *_wrap_Process_IsInputAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14816 PyObject *resultobj = 0;
14817 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14818 bool result;
14819 void *argp1 = 0 ;
14820 int res1 = 0 ;
14821 PyObject *swig_obj[1] ;
14822
14823 if (!args) SWIG_fail;
14824 swig_obj[0] = args;
14825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14826 if (!SWIG_IsOK(res1)) {
14827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14828 }
14829 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14830 {
14831 PyThreadState* __tstate = wxPyBeginAllowThreads();
14832 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
14833 wxPyEndAllowThreads(__tstate);
14834 if (PyErr_Occurred()) SWIG_fail;
14835 }
14836 {
14837 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14838 }
14839 return resultobj;
14840 fail:
14841 return NULL;
14842 }
14843
14844
14845 SWIGINTERN PyObject *_wrap_Process_IsErrorAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14846 PyObject *resultobj = 0;
14847 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14848 bool result;
14849 void *argp1 = 0 ;
14850 int res1 = 0 ;
14851 PyObject *swig_obj[1] ;
14852
14853 if (!args) SWIG_fail;
14854 swig_obj[0] = args;
14855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14856 if (!SWIG_IsOK(res1)) {
14857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsErrorAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14858 }
14859 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14860 {
14861 PyThreadState* __tstate = wxPyBeginAllowThreads();
14862 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
14863 wxPyEndAllowThreads(__tstate);
14864 if (PyErr_Occurred()) SWIG_fail;
14865 }
14866 {
14867 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14868 }
14869 return resultobj;
14870 fail:
14871 return NULL;
14872 }
14873
14874
14875 SWIGINTERN PyObject *Process_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14876 PyObject *obj;
14877 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14878 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyProcess, SWIG_NewClientData(obj));
14879 return SWIG_Py_Void();
14880 }
14881
14882 SWIGINTERN PyObject *Process_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14883 return SWIG_Python_InitShadowInstance(args);
14884 }
14885
14886 SWIGINTERN PyObject *_wrap_new_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14887 PyObject *resultobj = 0;
14888 int arg1 = (int) 0 ;
14889 int arg2 = (int) 0 ;
14890 int arg3 = (int) 0 ;
14891 wxProcessEvent *result = 0 ;
14892 int val1 ;
14893 int ecode1 = 0 ;
14894 int val2 ;
14895 int ecode2 = 0 ;
14896 int val3 ;
14897 int ecode3 = 0 ;
14898 PyObject * obj0 = 0 ;
14899 PyObject * obj1 = 0 ;
14900 PyObject * obj2 = 0 ;
14901 char * kwnames[] = {
14902 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
14903 };
14904
14905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14906 if (obj0) {
14907 ecode1 = SWIG_AsVal_int(obj0, &val1);
14908 if (!SWIG_IsOK(ecode1)) {
14909 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ProcessEvent" "', expected argument " "1"" of type '" "int""'");
14910 }
14911 arg1 = static_cast< int >(val1);
14912 }
14913 if (obj1) {
14914 ecode2 = SWIG_AsVal_int(obj1, &val2);
14915 if (!SWIG_IsOK(ecode2)) {
14916 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ProcessEvent" "', expected argument " "2"" of type '" "int""'");
14917 }
14918 arg2 = static_cast< int >(val2);
14919 }
14920 if (obj2) {
14921 ecode3 = SWIG_AsVal_int(obj2, &val3);
14922 if (!SWIG_IsOK(ecode3)) {
14923 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ProcessEvent" "', expected argument " "3"" of type '" "int""'");
14924 }
14925 arg3 = static_cast< int >(val3);
14926 }
14927 {
14928 PyThreadState* __tstate = wxPyBeginAllowThreads();
14929 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
14930 wxPyEndAllowThreads(__tstate);
14931 if (PyErr_Occurred()) SWIG_fail;
14932 }
14933 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_NEW | 0 );
14934 return resultobj;
14935 fail:
14936 return NULL;
14937 }
14938
14939
14940 SWIGINTERN PyObject *_wrap_ProcessEvent_GetPid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14941 PyObject *resultobj = 0;
14942 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14943 int result;
14944 void *argp1 = 0 ;
14945 int res1 = 0 ;
14946 PyObject *swig_obj[1] ;
14947
14948 if (!args) SWIG_fail;
14949 swig_obj[0] = args;
14950 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14951 if (!SWIG_IsOK(res1)) {
14952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetPid" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14953 }
14954 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14955 {
14956 PyThreadState* __tstate = wxPyBeginAllowThreads();
14957 result = (int)(arg1)->GetPid();
14958 wxPyEndAllowThreads(__tstate);
14959 if (PyErr_Occurred()) SWIG_fail;
14960 }
14961 resultobj = SWIG_From_int(static_cast< int >(result));
14962 return resultobj;
14963 fail:
14964 return NULL;
14965 }
14966
14967
14968 SWIGINTERN PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14969 PyObject *resultobj = 0;
14970 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14971 int result;
14972 void *argp1 = 0 ;
14973 int res1 = 0 ;
14974 PyObject *swig_obj[1] ;
14975
14976 if (!args) SWIG_fail;
14977 swig_obj[0] = args;
14978 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14979 if (!SWIG_IsOK(res1)) {
14980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetExitCode" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14981 }
14982 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14983 {
14984 PyThreadState* __tstate = wxPyBeginAllowThreads();
14985 result = (int)(arg1)->GetExitCode();
14986 wxPyEndAllowThreads(__tstate);
14987 if (PyErr_Occurred()) SWIG_fail;
14988 }
14989 resultobj = SWIG_From_int(static_cast< int >(result));
14990 return resultobj;
14991 fail:
14992 return NULL;
14993 }
14994
14995
14996 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14997 PyObject *resultobj = 0;
14998 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14999 int arg2 ;
15000 void *argp1 = 0 ;
15001 int res1 = 0 ;
15002 int val2 ;
15003 int ecode2 = 0 ;
15004 PyObject *swig_obj[2] ;
15005
15006 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_pid_set",2,2,swig_obj)) SWIG_fail;
15007 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
15008 if (!SWIG_IsOK(res1)) {
15009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
15010 }
15011 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
15012 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
15013 if (!SWIG_IsOK(ecode2)) {
15014 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "2"" of type '" "int""'");
15015 }
15016 arg2 = static_cast< int >(val2);
15017 if (arg1) (arg1)->m_pid = arg2;
15018
15019 resultobj = SWIG_Py_Void();
15020 return resultobj;
15021 fail:
15022 return NULL;
15023 }
15024
15025
15026 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15027 PyObject *resultobj = 0;
15028 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
15029 int result;
15030 void *argp1 = 0 ;
15031 int res1 = 0 ;
15032 PyObject *swig_obj[1] ;
15033
15034 if (!args) SWIG_fail;
15035 swig_obj[0] = args;
15036 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
15037 if (!SWIG_IsOK(res1)) {
15038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
15039 }
15040 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
15041 result = (int) ((arg1)->m_pid);
15042 resultobj = SWIG_From_int(static_cast< int >(result));
15043 return resultobj;
15044 fail:
15045 return NULL;
15046 }
15047
15048
15049 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15050 PyObject *resultobj = 0;
15051 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
15052 int arg2 ;
15053 void *argp1 = 0 ;
15054 int res1 = 0 ;
15055 int val2 ;
15056 int ecode2 = 0 ;
15057 PyObject *swig_obj[2] ;
15058
15059 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_exitcode_set",2,2,swig_obj)) SWIG_fail;
15060 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
15061 if (!SWIG_IsOK(res1)) {
15062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
15063 }
15064 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
15065 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
15066 if (!SWIG_IsOK(ecode2)) {
15067 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "2"" of type '" "int""'");
15068 }
15069 arg2 = static_cast< int >(val2);
15070 if (arg1) (arg1)->m_exitcode = arg2;
15071
15072 resultobj = SWIG_Py_Void();
15073 return resultobj;
15074 fail:
15075 return NULL;
15076 }
15077
15078
15079 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15080 PyObject *resultobj = 0;
15081 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
15082 int result;
15083 void *argp1 = 0 ;
15084 int res1 = 0 ;
15085 PyObject *swig_obj[1] ;
15086
15087 if (!args) SWIG_fail;
15088 swig_obj[0] = args;
15089 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
15090 if (!SWIG_IsOK(res1)) {
15091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
15092 }
15093 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
15094 result = (int) ((arg1)->m_exitcode);
15095 resultobj = SWIG_From_int(static_cast< int >(result));
15096 return resultobj;
15097 fail:
15098 return NULL;
15099 }
15100
15101
15102 SWIGINTERN PyObject *ProcessEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15103 PyObject *obj;
15104 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15105 SWIG_TypeNewClientData(SWIGTYPE_p_wxProcessEvent, SWIG_NewClientData(obj));
15106 return SWIG_Py_Void();
15107 }
15108
15109 SWIGINTERN PyObject *ProcessEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15110 return SWIG_Python_InitShadowInstance(args);
15111 }
15112
15113 SWIGINTERN PyObject *_wrap_Execute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15114 PyObject *resultobj = 0;
15115 wxString *arg1 = 0 ;
15116 int arg2 = (int) wxEXEC_ASYNC ;
15117 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
15118 long result;
15119 bool temp1 = false ;
15120 int val2 ;
15121 int ecode2 = 0 ;
15122 void *argp3 = 0 ;
15123 int res3 = 0 ;
15124 PyObject * obj0 = 0 ;
15125 PyObject * obj1 = 0 ;
15126 PyObject * obj2 = 0 ;
15127 char * kwnames[] = {
15128 (char *) "command",(char *) "flags",(char *) "process", NULL
15129 };
15130
15131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15132 {
15133 arg1 = wxString_in_helper(obj0);
15134 if (arg1 == NULL) SWIG_fail;
15135 temp1 = true;
15136 }
15137 if (obj1) {
15138 ecode2 = SWIG_AsVal_int(obj1, &val2);
15139 if (!SWIG_IsOK(ecode2)) {
15140 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Execute" "', expected argument " "2"" of type '" "int""'");
15141 }
15142 arg2 = static_cast< int >(val2);
15143 }
15144 if (obj2) {
15145 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxPyProcess, 0 | 0 );
15146 if (!SWIG_IsOK(res3)) {
15147 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Execute" "', expected argument " "3"" of type '" "wxPyProcess *""'");
15148 }
15149 arg3 = reinterpret_cast< wxPyProcess * >(argp3);
15150 }
15151 {
15152 if (!wxPyCheckForApp()) SWIG_fail;
15153 PyThreadState* __tstate = wxPyBeginAllowThreads();
15154 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
15155 wxPyEndAllowThreads(__tstate);
15156 if (PyErr_Occurred()) SWIG_fail;
15157 }
15158 resultobj = SWIG_From_long(static_cast< long >(result));
15159 {
15160 if (temp1)
15161 delete arg1;
15162 }
15163 return resultobj;
15164 fail:
15165 {
15166 if (temp1)
15167 delete arg1;
15168 }
15169 return NULL;
15170 }
15171
15172
15173 SWIGINTERN PyObject *_wrap_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15174 PyObject *resultobj = 0;
15175 long arg1 ;
15176 wxSignal arg2 = (wxSignal) wxSIGTERM ;
15177 wxKillError *arg3 = (wxKillError *) 0 ;
15178 int arg4 = (int) wxKILL_NOCHILDREN ;
15179 int result;
15180 long val1 ;
15181 int ecode1 = 0 ;
15182 int val2 ;
15183 int ecode2 = 0 ;
15184 wxKillError temp3 ;
15185 int val4 ;
15186 int ecode4 = 0 ;
15187 PyObject * obj0 = 0 ;
15188 PyObject * obj1 = 0 ;
15189 PyObject * obj2 = 0 ;
15190 char * kwnames[] = {
15191 (char *) "pid",(char *) "sig",(char *) "flags", NULL
15192 };
15193
15194 {
15195 arg3 = &temp3;
15196 }
15197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15198 ecode1 = SWIG_AsVal_long(obj0, &val1);
15199 if (!SWIG_IsOK(ecode1)) {
15200 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Kill" "', expected argument " "1"" of type '" "long""'");
15201 }
15202 arg1 = static_cast< long >(val1);
15203 if (obj1) {
15204 ecode2 = SWIG_AsVal_int(obj1, &val2);
15205 if (!SWIG_IsOK(ecode2)) {
15206 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Kill" "', expected argument " "2"" of type '" "wxSignal""'");
15207 }
15208 arg2 = static_cast< wxSignal >(val2);
15209 }
15210 if (obj2) {
15211 ecode4 = SWIG_AsVal_int(obj2, &val4);
15212 if (!SWIG_IsOK(ecode4)) {
15213 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Kill" "', expected argument " "4"" of type '" "int""'");
15214 }
15215 arg4 = static_cast< int >(val4);
15216 }
15217 {
15218 PyThreadState* __tstate = wxPyBeginAllowThreads();
15219 result = (int)wxKill(arg1,arg2,arg3,arg4);
15220 wxPyEndAllowThreads(__tstate);
15221 if (PyErr_Occurred()) SWIG_fail;
15222 }
15223 resultobj = SWIG_From_int(static_cast< int >(result));
15224 {
15225 PyObject* o;
15226 o = PyInt_FromLong((long) (*arg3));
15227
15228
15229
15230 resultobj = SWIG_Python_AppendOutput(resultobj, o);
15231
15232 }
15233 return resultobj;
15234 fail:
15235 return NULL;
15236 }
15237
15238
15239 SWIGINTERN PyObject *_wrap_new_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15240 PyObject *resultobj = 0;
15241 int arg1 = (int) wxJOYSTICK1 ;
15242 wxJoystick *result = 0 ;
15243 int val1 ;
15244 int ecode1 = 0 ;
15245 PyObject * obj0 = 0 ;
15246 char * kwnames[] = {
15247 (char *) "joystick", NULL
15248 };
15249
15250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) SWIG_fail;
15251 if (obj0) {
15252 ecode1 = SWIG_AsVal_int(obj0, &val1);
15253 if (!SWIG_IsOK(ecode1)) {
15254 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Joystick" "', expected argument " "1"" of type '" "int""'");
15255 }
15256 arg1 = static_cast< int >(val1);
15257 }
15258 {
15259 if (!wxPyCheckForApp()) SWIG_fail;
15260 PyThreadState* __tstate = wxPyBeginAllowThreads();
15261 result = (wxJoystick *)new wxJoystick(arg1);
15262 wxPyEndAllowThreads(__tstate);
15263 if (PyErr_Occurred()) SWIG_fail;
15264 }
15265 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystick, SWIG_POINTER_NEW | 0 );
15266 return resultobj;
15267 fail:
15268 return NULL;
15269 }
15270
15271
15272 SWIGINTERN PyObject *_wrap_delete_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15273 PyObject *resultobj = 0;
15274 wxJoystick *arg1 = (wxJoystick *) 0 ;
15275 void *argp1 = 0 ;
15276 int res1 = 0 ;
15277 PyObject *swig_obj[1] ;
15278
15279 if (!args) SWIG_fail;
15280 swig_obj[0] = args;
15281 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, SWIG_POINTER_DISOWN | 0 );
15282 if (!SWIG_IsOK(res1)) {
15283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Joystick" "', expected argument " "1"" of type '" "wxJoystick *""'");
15284 }
15285 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15286 {
15287 PyThreadState* __tstate = wxPyBeginAllowThreads();
15288 delete arg1;
15289
15290 wxPyEndAllowThreads(__tstate);
15291 if (PyErr_Occurred()) SWIG_fail;
15292 }
15293 resultobj = SWIG_Py_Void();
15294 return resultobj;
15295 fail:
15296 return NULL;
15297 }
15298
15299
15300 SWIGINTERN PyObject *_wrap_Joystick_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15301 PyObject *resultobj = 0;
15302 wxJoystick *arg1 = (wxJoystick *) 0 ;
15303 wxPoint 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_GetPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15313 }
15314 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15315 {
15316 PyThreadState* __tstate = wxPyBeginAllowThreads();
15317 result = (arg1)->GetPosition();
15318 wxPyEndAllowThreads(__tstate);
15319 if (PyErr_Occurred()) SWIG_fail;
15320 }
15321 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
15322 return resultobj;
15323 fail:
15324 return NULL;
15325 }
15326
15327
15328 SWIGINTERN PyObject *_wrap_Joystick_GetZPosition(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_GetZPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15341 }
15342 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15343 {
15344 PyThreadState* __tstate = wxPyBeginAllowThreads();
15345 result = (int)(arg1)->GetZPosition();
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_GetButtonState(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_GetButtonState" "', expected argument " "1"" of type '" "wxJoystick *""'");
15369 }
15370 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15371 {
15372 PyThreadState* __tstate = wxPyBeginAllowThreads();
15373 result = (int)(arg1)->GetButtonState();
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_GetPOVPosition(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_GetPOVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15397 }
15398 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15399 {
15400 PyThreadState* __tstate = wxPyBeginAllowThreads();
15401 result = (int)(arg1)->GetPOVPosition();
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_GetPOVCTSPosition(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_GetPOVCTSPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15425 }
15426 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15427 {
15428 PyThreadState* __tstate = wxPyBeginAllowThreads();
15429 result = (int)(arg1)->GetPOVCTSPosition();
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_GetRudderPosition(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_GetRudderPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15453 }
15454 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15455 {
15456 PyThreadState* __tstate = wxPyBeginAllowThreads();
15457 result = (int)(arg1)->GetRudderPosition();
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_GetUPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15469 PyObject *resultobj = 0;
15470 wxJoystick *arg1 = (wxJoystick *) 0 ;
15471 int result;
15472 void *argp1 = 0 ;
15473 int res1 = 0 ;
15474 PyObject *swig_obj[1] ;
15475
15476 if (!args) SWIG_fail;
15477 swig_obj[0] = args;
15478 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15479 if (!SWIG_IsOK(res1)) {
15480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15481 }
15482 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15483 {
15484 PyThreadState* __tstate = wxPyBeginAllowThreads();
15485 result = (int)(arg1)->GetUPosition();
15486 wxPyEndAllowThreads(__tstate);
15487 if (PyErr_Occurred()) SWIG_fail;
15488 }
15489 resultobj = SWIG_From_int(static_cast< int >(result));
15490 return resultobj;
15491 fail:
15492 return NULL;
15493 }
15494
15495
15496 SWIGINTERN PyObject *_wrap_Joystick_GetVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15497 PyObject *resultobj = 0;
15498 wxJoystick *arg1 = (wxJoystick *) 0 ;
15499 int result;
15500 void *argp1 = 0 ;
15501 int res1 = 0 ;
15502 PyObject *swig_obj[1] ;
15503
15504 if (!args) SWIG_fail;
15505 swig_obj[0] = args;
15506 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15507 if (!SWIG_IsOK(res1)) {
15508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15509 }
15510 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15511 {
15512 PyThreadState* __tstate = wxPyBeginAllowThreads();
15513 result = (int)(arg1)->GetVPosition();
15514 wxPyEndAllowThreads(__tstate);
15515 if (PyErr_Occurred()) SWIG_fail;
15516 }
15517 resultobj = SWIG_From_int(static_cast< int >(result));
15518 return resultobj;
15519 fail:
15520 return NULL;
15521 }
15522
15523
15524 SWIGINTERN PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15525 PyObject *resultobj = 0;
15526 wxJoystick *arg1 = (wxJoystick *) 0 ;
15527 int result;
15528 void *argp1 = 0 ;
15529 int res1 = 0 ;
15530 PyObject *swig_obj[1] ;
15531
15532 if (!args) SWIG_fail;
15533 swig_obj[0] = args;
15534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15535 if (!SWIG_IsOK(res1)) {
15536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
15537 }
15538 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15539 {
15540 PyThreadState* __tstate = wxPyBeginAllowThreads();
15541 result = (int)(arg1)->GetMovementThreshold();
15542 wxPyEndAllowThreads(__tstate);
15543 if (PyErr_Occurred()) SWIG_fail;
15544 }
15545 resultobj = SWIG_From_int(static_cast< int >(result));
15546 return resultobj;
15547 fail:
15548 return NULL;
15549 }
15550
15551
15552 SWIGINTERN PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15553 PyObject *resultobj = 0;
15554 wxJoystick *arg1 = (wxJoystick *) 0 ;
15555 int arg2 ;
15556 void *argp1 = 0 ;
15557 int res1 = 0 ;
15558 int val2 ;
15559 int ecode2 = 0 ;
15560 PyObject * obj0 = 0 ;
15561 PyObject * obj1 = 0 ;
15562 char * kwnames[] = {
15563 (char *) "self",(char *) "threshold", NULL
15564 };
15565
15566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) SWIG_fail;
15567 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15568 if (!SWIG_IsOK(res1)) {
15569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
15570 }
15571 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15572 ecode2 = SWIG_AsVal_int(obj1, &val2);
15573 if (!SWIG_IsOK(ecode2)) {
15574 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "2"" of type '" "int""'");
15575 }
15576 arg2 = static_cast< int >(val2);
15577 {
15578 PyThreadState* __tstate = wxPyBeginAllowThreads();
15579 (arg1)->SetMovementThreshold(arg2);
15580 wxPyEndAllowThreads(__tstate);
15581 if (PyErr_Occurred()) SWIG_fail;
15582 }
15583 resultobj = SWIG_Py_Void();
15584 return resultobj;
15585 fail:
15586 return NULL;
15587 }
15588
15589
15590 SWIGINTERN PyObject *_wrap_Joystick_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15591 PyObject *resultobj = 0;
15592 wxJoystick *arg1 = (wxJoystick *) 0 ;
15593 bool result;
15594 void *argp1 = 0 ;
15595 int res1 = 0 ;
15596 PyObject *swig_obj[1] ;
15597
15598 if (!args) SWIG_fail;
15599 swig_obj[0] = args;
15600 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15601 if (!SWIG_IsOK(res1)) {
15602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_IsOk" "', expected argument " "1"" of type '" "wxJoystick *""'");
15603 }
15604 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15605 {
15606 PyThreadState* __tstate = wxPyBeginAllowThreads();
15607 result = (bool)(arg1)->IsOk();
15608 wxPyEndAllowThreads(__tstate);
15609 if (PyErr_Occurred()) SWIG_fail;
15610 }
15611 {
15612 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15613 }
15614 return resultobj;
15615 fail:
15616 return NULL;
15617 }
15618
15619
15620 SWIGINTERN PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15621 PyObject *resultobj = 0;
15622 wxJoystick *arg1 = (wxJoystick *) 0 ;
15623 int 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_GetNumberJoysticks" "', expected argument " "1"" of type '" "wxJoystick *""'");
15633 }
15634 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15635 {
15636 PyThreadState* __tstate = wxPyBeginAllowThreads();
15637 result = (int)(arg1)->GetNumberJoysticks();
15638 wxPyEndAllowThreads(__tstate);
15639 if (PyErr_Occurred()) SWIG_fail;
15640 }
15641 resultobj = SWIG_From_int(static_cast< int >(result));
15642 return resultobj;
15643 fail:
15644 return NULL;
15645 }
15646
15647
15648 SWIGINTERN PyObject *_wrap_Joystick_GetManufacturerId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15649 PyObject *resultobj = 0;
15650 wxJoystick *arg1 = (wxJoystick *) 0 ;
15651 int result;
15652 void *argp1 = 0 ;
15653 int res1 = 0 ;
15654 PyObject *swig_obj[1] ;
15655
15656 if (!args) SWIG_fail;
15657 swig_obj[0] = args;
15658 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15659 if (!SWIG_IsOK(res1)) {
15660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetManufacturerId" "', expected argument " "1"" of type '" "wxJoystick *""'");
15661 }
15662 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15663 {
15664 PyThreadState* __tstate = wxPyBeginAllowThreads();
15665 result = (int)(arg1)->GetManufacturerId();
15666 wxPyEndAllowThreads(__tstate);
15667 if (PyErr_Occurred()) SWIG_fail;
15668 }
15669 resultobj = SWIG_From_int(static_cast< int >(result));
15670 return resultobj;
15671 fail:
15672 return NULL;
15673 }
15674
15675
15676 SWIGINTERN PyObject *_wrap_Joystick_GetProductId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15677 PyObject *resultobj = 0;
15678 wxJoystick *arg1 = (wxJoystick *) 0 ;
15679 int result;
15680 void *argp1 = 0 ;
15681 int res1 = 0 ;
15682 PyObject *swig_obj[1] ;
15683
15684 if (!args) SWIG_fail;
15685 swig_obj[0] = args;
15686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15687 if (!SWIG_IsOK(res1)) {
15688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductId" "', expected argument " "1"" of type '" "wxJoystick *""'");
15689 }
15690 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15691 {
15692 PyThreadState* __tstate = wxPyBeginAllowThreads();
15693 result = (int)(arg1)->GetProductId();
15694 wxPyEndAllowThreads(__tstate);
15695 if (PyErr_Occurred()) SWIG_fail;
15696 }
15697 resultobj = SWIG_From_int(static_cast< int >(result));
15698 return resultobj;
15699 fail:
15700 return NULL;
15701 }
15702
15703
15704 SWIGINTERN PyObject *_wrap_Joystick_GetProductName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15705 PyObject *resultobj = 0;
15706 wxJoystick *arg1 = (wxJoystick *) 0 ;
15707 wxString result;
15708 void *argp1 = 0 ;
15709 int res1 = 0 ;
15710 PyObject *swig_obj[1] ;
15711
15712 if (!args) SWIG_fail;
15713 swig_obj[0] = args;
15714 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15715 if (!SWIG_IsOK(res1)) {
15716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductName" "', expected argument " "1"" of type '" "wxJoystick *""'");
15717 }
15718 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15719 {
15720 PyThreadState* __tstate = wxPyBeginAllowThreads();
15721 result = (arg1)->GetProductName();
15722 wxPyEndAllowThreads(__tstate);
15723 if (PyErr_Occurred()) SWIG_fail;
15724 }
15725 {
15726 #if wxUSE_UNICODE
15727 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15728 #else
15729 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15730 #endif
15731 }
15732 return resultobj;
15733 fail:
15734 return NULL;
15735 }
15736
15737
15738 SWIGINTERN PyObject *_wrap_Joystick_GetXMin(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_GetXMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15751 }
15752 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15753 {
15754 PyThreadState* __tstate = wxPyBeginAllowThreads();
15755 result = (int)(arg1)->GetXMin();
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_GetYMin(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_GetYMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15779 }
15780 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15781 {
15782 PyThreadState* __tstate = wxPyBeginAllowThreads();
15783 result = (int)(arg1)->GetYMin();
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_GetZMin(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_GetZMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15807 }
15808 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15809 {
15810 PyThreadState* __tstate = wxPyBeginAllowThreads();
15811 result = (int)(arg1)->GetZMin();
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_GetXMax(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_GetXMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15835 }
15836 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15837 {
15838 PyThreadState* __tstate = wxPyBeginAllowThreads();
15839 result = (int)(arg1)->GetXMax();
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_GetYMax(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_GetYMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15863 }
15864 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15865 {
15866 PyThreadState* __tstate = wxPyBeginAllowThreads();
15867 result = (int)(arg1)->GetYMax();
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_GetZMax(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_GetZMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15891 }
15892 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15893 {
15894 PyThreadState* __tstate = wxPyBeginAllowThreads();
15895 result = (int)(arg1)->GetZMax();
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_GetNumberButtons(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_GetNumberButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
15919 }
15920 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15921 {
15922 PyThreadState* __tstate = wxPyBeginAllowThreads();
15923 result = (int)(arg1)->GetNumberButtons();
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_GetNumberAxes(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_GetNumberAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
15947 }
15948 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15949 {
15950 PyThreadState* __tstate = wxPyBeginAllowThreads();
15951 result = (int)(arg1)->GetNumberAxes();
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_GetMaxButtons(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_GetMaxButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
15975 }
15976 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15977 {
15978 PyThreadState* __tstate = wxPyBeginAllowThreads();
15979 result = (int)(arg1)->GetMaxButtons();
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_GetMaxAxes(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_GetMaxAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
16003 }
16004 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16005 {
16006 PyThreadState* __tstate = wxPyBeginAllowThreads();
16007 result = (int)(arg1)->GetMaxAxes();
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_GetPollingMin(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_GetPollingMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
16031 }
16032 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16033 {
16034 PyThreadState* __tstate = wxPyBeginAllowThreads();
16035 result = (int)(arg1)->GetPollingMin();
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_GetPollingMax(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_GetPollingMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16059 }
16060 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16061 {
16062 PyThreadState* __tstate = wxPyBeginAllowThreads();
16063 result = (int)(arg1)->GetPollingMax();
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_GetRudderMin(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_GetRudderMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
16087 }
16088 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16089 {
16090 PyThreadState* __tstate = wxPyBeginAllowThreads();
16091 result = (int)(arg1)->GetRudderMin();
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_GetRudderMax(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_GetRudderMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16115 }
16116 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16117 {
16118 PyThreadState* __tstate = wxPyBeginAllowThreads();
16119 result = (int)(arg1)->GetRudderMax();
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_GetUMin(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_GetUMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
16143 }
16144 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16145 {
16146 PyThreadState* __tstate = wxPyBeginAllowThreads();
16147 result = (int)(arg1)->GetUMin();
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_GetUMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16159 PyObject *resultobj = 0;
16160 wxJoystick *arg1 = (wxJoystick *) 0 ;
16161 int 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_GetUMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16171 }
16172 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16173 {
16174 PyThreadState* __tstate = wxPyBeginAllowThreads();
16175 result = (int)(arg1)->GetUMax();
16176 wxPyEndAllowThreads(__tstate);
16177 if (PyErr_Occurred()) SWIG_fail;
16178 }
16179 resultobj = SWIG_From_int(static_cast< int >(result));
16180 return resultobj;
16181 fail:
16182 return NULL;
16183 }
16184
16185
16186 SWIGINTERN PyObject *_wrap_Joystick_GetVMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16187 PyObject *resultobj = 0;
16188 wxJoystick *arg1 = (wxJoystick *) 0 ;
16189 int result;
16190 void *argp1 = 0 ;
16191 int res1 = 0 ;
16192 PyObject *swig_obj[1] ;
16193
16194 if (!args) SWIG_fail;
16195 swig_obj[0] = args;
16196 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16197 if (!SWIG_IsOK(res1)) {
16198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
16199 }
16200 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16201 {
16202 PyThreadState* __tstate = wxPyBeginAllowThreads();
16203 result = (int)(arg1)->GetVMin();
16204 wxPyEndAllowThreads(__tstate);
16205 if (PyErr_Occurred()) SWIG_fail;
16206 }
16207 resultobj = SWIG_From_int(static_cast< int >(result));
16208 return resultobj;
16209 fail:
16210 return NULL;
16211 }
16212
16213
16214 SWIGINTERN PyObject *_wrap_Joystick_GetVMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16215 PyObject *resultobj = 0;
16216 wxJoystick *arg1 = (wxJoystick *) 0 ;
16217 int result;
16218 void *argp1 = 0 ;
16219 int res1 = 0 ;
16220 PyObject *swig_obj[1] ;
16221
16222 if (!args) SWIG_fail;
16223 swig_obj[0] = args;
16224 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16225 if (!SWIG_IsOK(res1)) {
16226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16227 }
16228 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16229 {
16230 PyThreadState* __tstate = wxPyBeginAllowThreads();
16231 result = (int)(arg1)->GetVMax();
16232 wxPyEndAllowThreads(__tstate);
16233 if (PyErr_Occurred()) SWIG_fail;
16234 }
16235 resultobj = SWIG_From_int(static_cast< int >(result));
16236 return resultobj;
16237 fail:
16238 return NULL;
16239 }
16240
16241
16242 SWIGINTERN PyObject *_wrap_Joystick_HasRudder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16243 PyObject *resultobj = 0;
16244 wxJoystick *arg1 = (wxJoystick *) 0 ;
16245 bool result;
16246 void *argp1 = 0 ;
16247 int res1 = 0 ;
16248 PyObject *swig_obj[1] ;
16249
16250 if (!args) SWIG_fail;
16251 swig_obj[0] = args;
16252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16253 if (!SWIG_IsOK(res1)) {
16254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasRudder" "', expected argument " "1"" of type '" "wxJoystick *""'");
16255 }
16256 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16257 {
16258 PyThreadState* __tstate = wxPyBeginAllowThreads();
16259 result = (bool)(arg1)->HasRudder();
16260 wxPyEndAllowThreads(__tstate);
16261 if (PyErr_Occurred()) SWIG_fail;
16262 }
16263 {
16264 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16265 }
16266 return resultobj;
16267 fail:
16268 return NULL;
16269 }
16270
16271
16272 SWIGINTERN PyObject *_wrap_Joystick_HasZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16273 PyObject *resultobj = 0;
16274 wxJoystick *arg1 = (wxJoystick *) 0 ;
16275 bool result;
16276 void *argp1 = 0 ;
16277 int res1 = 0 ;
16278 PyObject *swig_obj[1] ;
16279
16280 if (!args) SWIG_fail;
16281 swig_obj[0] = args;
16282 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16283 if (!SWIG_IsOK(res1)) {
16284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasZ" "', expected argument " "1"" of type '" "wxJoystick *""'");
16285 }
16286 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16287 {
16288 PyThreadState* __tstate = wxPyBeginAllowThreads();
16289 result = (bool)(arg1)->HasZ();
16290 wxPyEndAllowThreads(__tstate);
16291 if (PyErr_Occurred()) SWIG_fail;
16292 }
16293 {
16294 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16295 }
16296 return resultobj;
16297 fail:
16298 return NULL;
16299 }
16300
16301
16302 SWIGINTERN PyObject *_wrap_Joystick_HasU(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16303 PyObject *resultobj = 0;
16304 wxJoystick *arg1 = (wxJoystick *) 0 ;
16305 bool result;
16306 void *argp1 = 0 ;
16307 int res1 = 0 ;
16308 PyObject *swig_obj[1] ;
16309
16310 if (!args) SWIG_fail;
16311 swig_obj[0] = args;
16312 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16313 if (!SWIG_IsOK(res1)) {
16314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasU" "', expected argument " "1"" of type '" "wxJoystick *""'");
16315 }
16316 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16317 {
16318 PyThreadState* __tstate = wxPyBeginAllowThreads();
16319 result = (bool)(arg1)->HasU();
16320 wxPyEndAllowThreads(__tstate);
16321 if (PyErr_Occurred()) SWIG_fail;
16322 }
16323 {
16324 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16325 }
16326 return resultobj;
16327 fail:
16328 return NULL;
16329 }
16330
16331
16332 SWIGINTERN PyObject *_wrap_Joystick_HasV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16333 PyObject *resultobj = 0;
16334 wxJoystick *arg1 = (wxJoystick *) 0 ;
16335 bool result;
16336 void *argp1 = 0 ;
16337 int res1 = 0 ;
16338 PyObject *swig_obj[1] ;
16339
16340 if (!args) SWIG_fail;
16341 swig_obj[0] = args;
16342 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16343 if (!SWIG_IsOK(res1)) {
16344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasV" "', expected argument " "1"" of type '" "wxJoystick *""'");
16345 }
16346 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16347 {
16348 PyThreadState* __tstate = wxPyBeginAllowThreads();
16349 result = (bool)(arg1)->HasV();
16350 wxPyEndAllowThreads(__tstate);
16351 if (PyErr_Occurred()) SWIG_fail;
16352 }
16353 {
16354 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16355 }
16356 return resultobj;
16357 fail:
16358 return NULL;
16359 }
16360
16361
16362 SWIGINTERN PyObject *_wrap_Joystick_HasPOV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16363 PyObject *resultobj = 0;
16364 wxJoystick *arg1 = (wxJoystick *) 0 ;
16365 bool result;
16366 void *argp1 = 0 ;
16367 int res1 = 0 ;
16368 PyObject *swig_obj[1] ;
16369
16370 if (!args) SWIG_fail;
16371 swig_obj[0] = args;
16372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16373 if (!SWIG_IsOK(res1)) {
16374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV" "', expected argument " "1"" of type '" "wxJoystick *""'");
16375 }
16376 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16377 {
16378 PyThreadState* __tstate = wxPyBeginAllowThreads();
16379 result = (bool)(arg1)->HasPOV();
16380 wxPyEndAllowThreads(__tstate);
16381 if (PyErr_Occurred()) SWIG_fail;
16382 }
16383 {
16384 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16385 }
16386 return resultobj;
16387 fail:
16388 return NULL;
16389 }
16390
16391
16392 SWIGINTERN PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16393 PyObject *resultobj = 0;
16394 wxJoystick *arg1 = (wxJoystick *) 0 ;
16395 bool result;
16396 void *argp1 = 0 ;
16397 int res1 = 0 ;
16398 PyObject *swig_obj[1] ;
16399
16400 if (!args) SWIG_fail;
16401 swig_obj[0] = args;
16402 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16403 if (!SWIG_IsOK(res1)) {
16404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV4Dir" "', expected argument " "1"" of type '" "wxJoystick *""'");
16405 }
16406 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16407 {
16408 PyThreadState* __tstate = wxPyBeginAllowThreads();
16409 result = (bool)(arg1)->HasPOV4Dir();
16410 wxPyEndAllowThreads(__tstate);
16411 if (PyErr_Occurred()) SWIG_fail;
16412 }
16413 {
16414 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16415 }
16416 return resultobj;
16417 fail:
16418 return NULL;
16419 }
16420
16421
16422 SWIGINTERN PyObject *_wrap_Joystick_HasPOVCTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16423 PyObject *resultobj = 0;
16424 wxJoystick *arg1 = (wxJoystick *) 0 ;
16425 bool result;
16426 void *argp1 = 0 ;
16427 int res1 = 0 ;
16428 PyObject *swig_obj[1] ;
16429
16430 if (!args) SWIG_fail;
16431 swig_obj[0] = args;
16432 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16433 if (!SWIG_IsOK(res1)) {
16434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOVCTS" "', expected argument " "1"" of type '" "wxJoystick *""'");
16435 }
16436 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16437 {
16438 PyThreadState* __tstate = wxPyBeginAllowThreads();
16439 result = (bool)(arg1)->HasPOVCTS();
16440 wxPyEndAllowThreads(__tstate);
16441 if (PyErr_Occurred()) SWIG_fail;
16442 }
16443 {
16444 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16445 }
16446 return resultobj;
16447 fail:
16448 return NULL;
16449 }
16450
16451
16452 SWIGINTERN PyObject *_wrap_Joystick_SetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16453 PyObject *resultobj = 0;
16454 wxJoystick *arg1 = (wxJoystick *) 0 ;
16455 wxWindow *arg2 = (wxWindow *) 0 ;
16456 int arg3 = (int) 0 ;
16457 bool result;
16458 void *argp1 = 0 ;
16459 int res1 = 0 ;
16460 void *argp2 = 0 ;
16461 int res2 = 0 ;
16462 int val3 ;
16463 int ecode3 = 0 ;
16464 PyObject * obj0 = 0 ;
16465 PyObject * obj1 = 0 ;
16466 PyObject * obj2 = 0 ;
16467 char * kwnames[] = {
16468 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
16469 };
16470
16471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16472 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16473 if (!SWIG_IsOK(res1)) {
16474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
16475 }
16476 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16477 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
16478 if (!SWIG_IsOK(res2)) {
16479 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Joystick_SetCapture" "', expected argument " "2"" of type '" "wxWindow *""'");
16480 }
16481 arg2 = reinterpret_cast< wxWindow * >(argp2);
16482 if (obj2) {
16483 ecode3 = SWIG_AsVal_int(obj2, &val3);
16484 if (!SWIG_IsOK(ecode3)) {
16485 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Joystick_SetCapture" "', expected argument " "3"" of type '" "int""'");
16486 }
16487 arg3 = static_cast< int >(val3);
16488 }
16489 {
16490 PyThreadState* __tstate = wxPyBeginAllowThreads();
16491 result = (bool)(arg1)->SetCapture(arg2,arg3);
16492 wxPyEndAllowThreads(__tstate);
16493 if (PyErr_Occurred()) SWIG_fail;
16494 }
16495 {
16496 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16497 }
16498 return resultobj;
16499 fail:
16500 return NULL;
16501 }
16502
16503
16504 SWIGINTERN PyObject *_wrap_Joystick_ReleaseCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16505 PyObject *resultobj = 0;
16506 wxJoystick *arg1 = (wxJoystick *) 0 ;
16507 bool result;
16508 void *argp1 = 0 ;
16509 int res1 = 0 ;
16510 PyObject *swig_obj[1] ;
16511
16512 if (!args) SWIG_fail;
16513 swig_obj[0] = args;
16514 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16515 if (!SWIG_IsOK(res1)) {
16516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_ReleaseCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
16517 }
16518 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16519 {
16520 PyThreadState* __tstate = wxPyBeginAllowThreads();
16521 result = (bool)(arg1)->ReleaseCapture();
16522 wxPyEndAllowThreads(__tstate);
16523 if (PyErr_Occurred()) SWIG_fail;
16524 }
16525 {
16526 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16527 }
16528 return resultobj;
16529 fail:
16530 return NULL;
16531 }
16532
16533
16534 SWIGINTERN PyObject *Joystick_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16535 PyObject *obj;
16536 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16537 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystick, SWIG_NewClientData(obj));
16538 return SWIG_Py_Void();
16539 }
16540
16541 SWIGINTERN PyObject *Joystick_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16542 return SWIG_Python_InitShadowInstance(args);
16543 }
16544
16545 SWIGINTERN PyObject *_wrap_new_JoystickEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16546 PyObject *resultobj = 0;
16547 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16548 int arg2 = (int) 0 ;
16549 int arg3 = (int) wxJOYSTICK1 ;
16550 int arg4 = (int) 0 ;
16551 wxJoystickEvent *result = 0 ;
16552 int val1 ;
16553 int ecode1 = 0 ;
16554 int val2 ;
16555 int ecode2 = 0 ;
16556 int val3 ;
16557 int ecode3 = 0 ;
16558 int val4 ;
16559 int ecode4 = 0 ;
16560 PyObject * obj0 = 0 ;
16561 PyObject * obj1 = 0 ;
16562 PyObject * obj2 = 0 ;
16563 PyObject * obj3 = 0 ;
16564 char * kwnames[] = {
16565 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
16566 };
16567
16568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16569 if (obj0) {
16570 ecode1 = SWIG_AsVal_int(obj0, &val1);
16571 if (!SWIG_IsOK(ecode1)) {
16572 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_JoystickEvent" "', expected argument " "1"" of type '" "wxEventType""'");
16573 }
16574 arg1 = static_cast< wxEventType >(val1);
16575 }
16576 if (obj1) {
16577 ecode2 = SWIG_AsVal_int(obj1, &val2);
16578 if (!SWIG_IsOK(ecode2)) {
16579 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_JoystickEvent" "', expected argument " "2"" of type '" "int""'");
16580 }
16581 arg2 = static_cast< int >(val2);
16582 }
16583 if (obj2) {
16584 ecode3 = SWIG_AsVal_int(obj2, &val3);
16585 if (!SWIG_IsOK(ecode3)) {
16586 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_JoystickEvent" "', expected argument " "3"" of type '" "int""'");
16587 }
16588 arg3 = static_cast< int >(val3);
16589 }
16590 if (obj3) {
16591 ecode4 = SWIG_AsVal_int(obj3, &val4);
16592 if (!SWIG_IsOK(ecode4)) {
16593 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_JoystickEvent" "', expected argument " "4"" of type '" "int""'");
16594 }
16595 arg4 = static_cast< int >(val4);
16596 }
16597 {
16598 PyThreadState* __tstate = wxPyBeginAllowThreads();
16599 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
16600 wxPyEndAllowThreads(__tstate);
16601 if (PyErr_Occurred()) SWIG_fail;
16602 }
16603 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_NEW | 0 );
16604 return resultobj;
16605 fail:
16606 return NULL;
16607 }
16608
16609
16610 SWIGINTERN PyObject *_wrap_JoystickEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16611 PyObject *resultobj = 0;
16612 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16613 wxPoint 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_GetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16623 }
16624 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16625 {
16626 PyThreadState* __tstate = wxPyBeginAllowThreads();
16627 result = ((wxJoystickEvent const *)arg1)->GetPosition();
16628 wxPyEndAllowThreads(__tstate);
16629 if (PyErr_Occurred()) SWIG_fail;
16630 }
16631 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
16632 return resultobj;
16633 fail:
16634 return NULL;
16635 }
16636
16637
16638 SWIGINTERN PyObject *_wrap_JoystickEvent_GetZPosition(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_GetZPosition" "', 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)->GetZPosition();
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_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16667 PyObject *resultobj = 0;
16668 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16669 int result;
16670 void *argp1 = 0 ;
16671 int res1 = 0 ;
16672 PyObject *swig_obj[1] ;
16673
16674 if (!args) SWIG_fail;
16675 swig_obj[0] = args;
16676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16677 if (!SWIG_IsOK(res1)) {
16678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16679 }
16680 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16681 {
16682 PyThreadState* __tstate = wxPyBeginAllowThreads();
16683 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
16684 wxPyEndAllowThreads(__tstate);
16685 if (PyErr_Occurred()) SWIG_fail;
16686 }
16687 resultobj = SWIG_From_int(static_cast< int >(result));
16688 return resultobj;
16689 fail:
16690 return NULL;
16691 }
16692
16693
16694 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16695 PyObject *resultobj = 0;
16696 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16697 int result;
16698 void *argp1 = 0 ;
16699 int res1 = 0 ;
16700 PyObject *swig_obj[1] ;
16701
16702 if (!args) SWIG_fail;
16703 swig_obj[0] = args;
16704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16705 if (!SWIG_IsOK(res1)) {
16706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16707 }
16708 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16709 {
16710 PyThreadState* __tstate = wxPyBeginAllowThreads();
16711 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
16712 wxPyEndAllowThreads(__tstate);
16713 if (PyErr_Occurred()) SWIG_fail;
16714 }
16715 resultobj = SWIG_From_int(static_cast< int >(result));
16716 return resultobj;
16717 fail:
16718 return NULL;
16719 }
16720
16721
16722 SWIGINTERN PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16723 PyObject *resultobj = 0;
16724 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16725 int result;
16726 void *argp1 = 0 ;
16727 int res1 = 0 ;
16728 PyObject *swig_obj[1] ;
16729
16730 if (!args) SWIG_fail;
16731 swig_obj[0] = args;
16732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16733 if (!SWIG_IsOK(res1)) {
16734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16735 }
16736 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16737 {
16738 PyThreadState* __tstate = wxPyBeginAllowThreads();
16739 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
16740 wxPyEndAllowThreads(__tstate);
16741 if (PyErr_Occurred()) SWIG_fail;
16742 }
16743 resultobj = SWIG_From_int(static_cast< int >(result));
16744 return resultobj;
16745 fail:
16746 return NULL;
16747 }
16748
16749
16750 SWIGINTERN PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16751 PyObject *resultobj = 0;
16752 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16753 int arg2 ;
16754 void *argp1 = 0 ;
16755 int res1 = 0 ;
16756 int val2 ;
16757 int ecode2 = 0 ;
16758 PyObject * obj0 = 0 ;
16759 PyObject * obj1 = 0 ;
16760 char * kwnames[] = {
16761 (char *) "self",(char *) "stick", NULL
16762 };
16763
16764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) SWIG_fail;
16765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16766 if (!SWIG_IsOK(res1)) {
16767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16768 }
16769 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16770 ecode2 = SWIG_AsVal_int(obj1, &val2);
16771 if (!SWIG_IsOK(ecode2)) {
16772 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "2"" of type '" "int""'");
16773 }
16774 arg2 = static_cast< int >(val2);
16775 {
16776 PyThreadState* __tstate = wxPyBeginAllowThreads();
16777 (arg1)->SetJoystick(arg2);
16778 wxPyEndAllowThreads(__tstate);
16779 if (PyErr_Occurred()) SWIG_fail;
16780 }
16781 resultobj = SWIG_Py_Void();
16782 return resultobj;
16783 fail:
16784 return NULL;
16785 }
16786
16787
16788 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16789 PyObject *resultobj = 0;
16790 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16791 int arg2 ;
16792 void *argp1 = 0 ;
16793 int res1 = 0 ;
16794 int val2 ;
16795 int ecode2 = 0 ;
16796 PyObject * obj0 = 0 ;
16797 PyObject * obj1 = 0 ;
16798 char * kwnames[] = {
16799 (char *) "self",(char *) "state", NULL
16800 };
16801
16802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) SWIG_fail;
16803 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16804 if (!SWIG_IsOK(res1)) {
16805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16806 }
16807 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16808 ecode2 = SWIG_AsVal_int(obj1, &val2);
16809 if (!SWIG_IsOK(ecode2)) {
16810 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "2"" of type '" "int""'");
16811 }
16812 arg2 = static_cast< int >(val2);
16813 {
16814 PyThreadState* __tstate = wxPyBeginAllowThreads();
16815 (arg1)->SetButtonState(arg2);
16816 wxPyEndAllowThreads(__tstate);
16817 if (PyErr_Occurred()) SWIG_fail;
16818 }
16819 resultobj = SWIG_Py_Void();
16820 return resultobj;
16821 fail:
16822 return NULL;
16823 }
16824
16825
16826 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16827 PyObject *resultobj = 0;
16828 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16829 int arg2 ;
16830 void *argp1 = 0 ;
16831 int res1 = 0 ;
16832 int val2 ;
16833 int ecode2 = 0 ;
16834 PyObject * obj0 = 0 ;
16835 PyObject * obj1 = 0 ;
16836 char * kwnames[] = {
16837 (char *) "self",(char *) "change", NULL
16838 };
16839
16840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) SWIG_fail;
16841 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16842 if (!SWIG_IsOK(res1)) {
16843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16844 }
16845 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16846 ecode2 = SWIG_AsVal_int(obj1, &val2);
16847 if (!SWIG_IsOK(ecode2)) {
16848 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "2"" of type '" "int""'");
16849 }
16850 arg2 = static_cast< int >(val2);
16851 {
16852 PyThreadState* __tstate = wxPyBeginAllowThreads();
16853 (arg1)->SetButtonChange(arg2);
16854 wxPyEndAllowThreads(__tstate);
16855 if (PyErr_Occurred()) SWIG_fail;
16856 }
16857 resultobj = SWIG_Py_Void();
16858 return resultobj;
16859 fail:
16860 return NULL;
16861 }
16862
16863
16864 SWIGINTERN PyObject *_wrap_JoystickEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16865 PyObject *resultobj = 0;
16866 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16867 wxPoint *arg2 = 0 ;
16868 void *argp1 = 0 ;
16869 int res1 = 0 ;
16870 wxPoint temp2 ;
16871 PyObject * obj0 = 0 ;
16872 PyObject * obj1 = 0 ;
16873 char * kwnames[] = {
16874 (char *) "self",(char *) "pos", NULL
16875 };
16876
16877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
16878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16879 if (!SWIG_IsOK(res1)) {
16880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16881 }
16882 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16883 {
16884 arg2 = &temp2;
16885 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
16886 }
16887 {
16888 PyThreadState* __tstate = wxPyBeginAllowThreads();
16889 (arg1)->SetPosition((wxPoint const &)*arg2);
16890 wxPyEndAllowThreads(__tstate);
16891 if (PyErr_Occurred()) SWIG_fail;
16892 }
16893 resultobj = SWIG_Py_Void();
16894 return resultobj;
16895 fail:
16896 return NULL;
16897 }
16898
16899
16900 SWIGINTERN PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16901 PyObject *resultobj = 0;
16902 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16903 int arg2 ;
16904 void *argp1 = 0 ;
16905 int res1 = 0 ;
16906 int val2 ;
16907 int ecode2 = 0 ;
16908 PyObject * obj0 = 0 ;
16909 PyObject * obj1 = 0 ;
16910 char * kwnames[] = {
16911 (char *) "self",(char *) "zPos", NULL
16912 };
16913
16914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) SWIG_fail;
16915 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16916 if (!SWIG_IsOK(res1)) {
16917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16918 }
16919 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16920 ecode2 = SWIG_AsVal_int(obj1, &val2);
16921 if (!SWIG_IsOK(ecode2)) {
16922 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "2"" of type '" "int""'");
16923 }
16924 arg2 = static_cast< int >(val2);
16925 {
16926 PyThreadState* __tstate = wxPyBeginAllowThreads();
16927 (arg1)->SetZPosition(arg2);
16928 wxPyEndAllowThreads(__tstate);
16929 if (PyErr_Occurred()) SWIG_fail;
16930 }
16931 resultobj = SWIG_Py_Void();
16932 return resultobj;
16933 fail:
16934 return NULL;
16935 }
16936
16937
16938 SWIGINTERN PyObject *_wrap_JoystickEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16939 PyObject *resultobj = 0;
16940 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16941 bool result;
16942 void *argp1 = 0 ;
16943 int res1 = 0 ;
16944 PyObject *swig_obj[1] ;
16945
16946 if (!args) SWIG_fail;
16947 swig_obj[0] = args;
16948 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16949 if (!SWIG_IsOK(res1)) {
16950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsButton" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16951 }
16952 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16953 {
16954 PyThreadState* __tstate = wxPyBeginAllowThreads();
16955 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
16956 wxPyEndAllowThreads(__tstate);
16957 if (PyErr_Occurred()) SWIG_fail;
16958 }
16959 {
16960 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16961 }
16962 return resultobj;
16963 fail:
16964 return NULL;
16965 }
16966
16967
16968 SWIGINTERN PyObject *_wrap_JoystickEvent_IsMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16969 PyObject *resultobj = 0;
16970 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16971 bool result;
16972 void *argp1 = 0 ;
16973 int res1 = 0 ;
16974 PyObject *swig_obj[1] ;
16975
16976 if (!args) SWIG_fail;
16977 swig_obj[0] = args;
16978 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16979 if (!SWIG_IsOK(res1)) {
16980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16981 }
16982 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16983 {
16984 PyThreadState* __tstate = wxPyBeginAllowThreads();
16985 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
16986 wxPyEndAllowThreads(__tstate);
16987 if (PyErr_Occurred()) SWIG_fail;
16988 }
16989 {
16990 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16991 }
16992 return resultobj;
16993 fail:
16994 return NULL;
16995 }
16996
16997
16998 SWIGINTERN PyObject *_wrap_JoystickEvent_IsZMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16999 PyObject *resultobj = 0;
17000 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
17001 bool result;
17002 void *argp1 = 0 ;
17003 int res1 = 0 ;
17004 PyObject *swig_obj[1] ;
17005
17006 if (!args) SWIG_fail;
17007 swig_obj[0] = args;
17008 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
17009 if (!SWIG_IsOK(res1)) {
17010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsZMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
17011 }
17012 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
17013 {
17014 PyThreadState* __tstate = wxPyBeginAllowThreads();
17015 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
17016 wxPyEndAllowThreads(__tstate);
17017 if (PyErr_Occurred()) SWIG_fail;
17018 }
17019 {
17020 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17021 }
17022 return resultobj;
17023 fail:
17024 return NULL;
17025 }
17026
17027
17028 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17029 PyObject *resultobj = 0;
17030 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
17031 int arg2 = (int) wxJOY_BUTTON_ANY ;
17032 bool result;
17033 void *argp1 = 0 ;
17034 int res1 = 0 ;
17035 int val2 ;
17036 int ecode2 = 0 ;
17037 PyObject * obj0 = 0 ;
17038 PyObject * obj1 = 0 ;
17039 char * kwnames[] = {
17040 (char *) "self",(char *) "but", NULL
17041 };
17042
17043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
17044 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
17045 if (!SWIG_IsOK(res1)) {
17046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
17047 }
17048 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
17049 if (obj1) {
17050 ecode2 = SWIG_AsVal_int(obj1, &val2);
17051 if (!SWIG_IsOK(ecode2)) {
17052 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
17053 }
17054 arg2 = static_cast< int >(val2);
17055 }
17056 {
17057 PyThreadState* __tstate = wxPyBeginAllowThreads();
17058 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
17059 wxPyEndAllowThreads(__tstate);
17060 if (PyErr_Occurred()) SWIG_fail;
17061 }
17062 {
17063 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17064 }
17065 return resultobj;
17066 fail:
17067 return NULL;
17068 }
17069
17070
17071 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17072 PyObject *resultobj = 0;
17073 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
17074 int arg2 = (int) wxJOY_BUTTON_ANY ;
17075 bool result;
17076 void *argp1 = 0 ;
17077 int res1 = 0 ;
17078 int val2 ;
17079 int ecode2 = 0 ;
17080 PyObject * obj0 = 0 ;
17081 PyObject * obj1 = 0 ;
17082 char * kwnames[] = {
17083 (char *) "self",(char *) "but", NULL
17084 };
17085
17086 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
17087 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
17088 if (!SWIG_IsOK(res1)) {
17089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
17090 }
17091 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
17092 if (obj1) {
17093 ecode2 = SWIG_AsVal_int(obj1, &val2);
17094 if (!SWIG_IsOK(ecode2)) {
17095 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
17096 }
17097 arg2 = static_cast< int >(val2);
17098 }
17099 {
17100 PyThreadState* __tstate = wxPyBeginAllowThreads();
17101 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
17102 wxPyEndAllowThreads(__tstate);
17103 if (PyErr_Occurred()) SWIG_fail;
17104 }
17105 {
17106 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17107 }
17108 return resultobj;
17109 fail:
17110 return NULL;
17111 }
17112
17113
17114 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17115 PyObject *resultobj = 0;
17116 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
17117 int arg2 = (int) wxJOY_BUTTON_ANY ;
17118 bool result;
17119 void *argp1 = 0 ;
17120 int res1 = 0 ;
17121 int val2 ;
17122 int ecode2 = 0 ;
17123 PyObject * obj0 = 0 ;
17124 PyObject * obj1 = 0 ;
17125 char * kwnames[] = {
17126 (char *) "self",(char *) "but", NULL
17127 };
17128
17129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
17130 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
17131 if (!SWIG_IsOK(res1)) {
17132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
17133 }
17134 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
17135 if (obj1) {
17136 ecode2 = SWIG_AsVal_int(obj1, &val2);
17137 if (!SWIG_IsOK(ecode2)) {
17138 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
17139 }
17140 arg2 = static_cast< int >(val2);
17141 }
17142 {
17143 PyThreadState* __tstate = wxPyBeginAllowThreads();
17144 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
17145 wxPyEndAllowThreads(__tstate);
17146 if (PyErr_Occurred()) SWIG_fail;
17147 }
17148 {
17149 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17150 }
17151 return resultobj;
17152 fail:
17153 return NULL;
17154 }
17155
17156
17157 SWIGINTERN PyObject *JoystickEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17158 PyObject *obj;
17159 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17160 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystickEvent, SWIG_NewClientData(obj));
17161 return SWIG_Py_Void();
17162 }
17163
17164 SWIGINTERN PyObject *JoystickEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17165 return SWIG_Python_InitShadowInstance(args);
17166 }
17167
17168 SWIGINTERN PyObject *_wrap_new_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17169 PyObject *resultobj = 0;
17170 wxString const &arg1_defvalue = wxPyEmptyString ;
17171 wxString *arg1 = (wxString *) &arg1_defvalue ;
17172 wxSound *result = 0 ;
17173 bool temp1 = false ;
17174 PyObject * obj0 = 0 ;
17175 char * kwnames[] = {
17176 (char *) "fileName", NULL
17177 };
17178
17179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) SWIG_fail;
17180 if (obj0) {
17181 {
17182 arg1 = wxString_in_helper(obj0);
17183 if (arg1 == NULL) SWIG_fail;
17184 temp1 = true;
17185 }
17186 }
17187 {
17188 if (!wxPyCheckForApp()) SWIG_fail;
17189 PyThreadState* __tstate = wxPyBeginAllowThreads();
17190 result = (wxSound *)new_wxSound((wxString const &)*arg1);
17191 wxPyEndAllowThreads(__tstate);
17192 if (PyErr_Occurred()) SWIG_fail;
17193 }
17194 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_NEW | 0 );
17195 {
17196 if (temp1)
17197 delete arg1;
17198 }
17199 return resultobj;
17200 fail:
17201 {
17202 if (temp1)
17203 delete arg1;
17204 }
17205 return NULL;
17206 }
17207
17208
17209 SWIGINTERN PyObject *_wrap_new_SoundFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17210 PyObject *resultobj = 0;
17211 PyObject *arg1 = (PyObject *) 0 ;
17212 wxSound *result = 0 ;
17213 PyObject * obj0 = 0 ;
17214 char * kwnames[] = {
17215 (char *) "data", NULL
17216 };
17217
17218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) SWIG_fail;
17219 arg1 = obj0;
17220 {
17221 if (!wxPyCheckForApp()) SWIG_fail;
17222 PyThreadState* __tstate = wxPyBeginAllowThreads();
17223 result = (wxSound *)new_wxSound(arg1);
17224 wxPyEndAllowThreads(__tstate);
17225 if (PyErr_Occurred()) SWIG_fail;
17226 }
17227 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_OWN | 0 );
17228 return resultobj;
17229 fail:
17230 return NULL;
17231 }
17232
17233
17234 SWIGINTERN PyObject *_wrap_delete_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17235 PyObject *resultobj = 0;
17236 wxSound *arg1 = (wxSound *) 0 ;
17237 void *argp1 = 0 ;
17238 int res1 = 0 ;
17239 PyObject *swig_obj[1] ;
17240
17241 if (!args) SWIG_fail;
17242 swig_obj[0] = args;
17243 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, SWIG_POINTER_DISOWN | 0 );
17244 if (!SWIG_IsOK(res1)) {
17245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sound" "', expected argument " "1"" of type '" "wxSound *""'");
17246 }
17247 arg1 = reinterpret_cast< wxSound * >(argp1);
17248 {
17249 PyThreadState* __tstate = wxPyBeginAllowThreads();
17250 delete arg1;
17251
17252 wxPyEndAllowThreads(__tstate);
17253 if (PyErr_Occurred()) SWIG_fail;
17254 }
17255 resultobj = SWIG_Py_Void();
17256 return resultobj;
17257 fail:
17258 return NULL;
17259 }
17260
17261
17262 SWIGINTERN PyObject *_wrap_Sound_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17263 PyObject *resultobj = 0;
17264 wxSound *arg1 = (wxSound *) 0 ;
17265 wxString *arg2 = 0 ;
17266 bool result;
17267 void *argp1 = 0 ;
17268 int res1 = 0 ;
17269 bool temp2 = false ;
17270 PyObject * obj0 = 0 ;
17271 PyObject * obj1 = 0 ;
17272 char * kwnames[] = {
17273 (char *) "self",(char *) "fileName", NULL
17274 };
17275
17276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) SWIG_fail;
17277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17278 if (!SWIG_IsOK(res1)) {
17279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Create" "', expected argument " "1"" of type '" "wxSound *""'");
17280 }
17281 arg1 = reinterpret_cast< wxSound * >(argp1);
17282 {
17283 arg2 = wxString_in_helper(obj1);
17284 if (arg2 == NULL) SWIG_fail;
17285 temp2 = true;
17286 }
17287 {
17288 PyThreadState* __tstate = wxPyBeginAllowThreads();
17289 result = (bool)(arg1)->Create((wxString const &)*arg2);
17290 wxPyEndAllowThreads(__tstate);
17291 if (PyErr_Occurred()) SWIG_fail;
17292 }
17293 {
17294 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17295 }
17296 {
17297 if (temp2)
17298 delete arg2;
17299 }
17300 return resultobj;
17301 fail:
17302 {
17303 if (temp2)
17304 delete arg2;
17305 }
17306 return NULL;
17307 }
17308
17309
17310 SWIGINTERN PyObject *_wrap_Sound_CreateFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17311 PyObject *resultobj = 0;
17312 wxSound *arg1 = (wxSound *) 0 ;
17313 PyObject *arg2 = (PyObject *) 0 ;
17314 bool result;
17315 void *argp1 = 0 ;
17316 int res1 = 0 ;
17317 PyObject * obj0 = 0 ;
17318 PyObject * obj1 = 0 ;
17319 char * kwnames[] = {
17320 (char *) "self",(char *) "data", NULL
17321 };
17322
17323 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) SWIG_fail;
17324 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17325 if (!SWIG_IsOK(res1)) {
17326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_CreateFromData" "', expected argument " "1"" of type '" "wxSound *""'");
17327 }
17328 arg1 = reinterpret_cast< wxSound * >(argp1);
17329 arg2 = obj1;
17330 {
17331 PyThreadState* __tstate = wxPyBeginAllowThreads();
17332 result = (bool)wxSound_CreateFromData(arg1,arg2);
17333 wxPyEndAllowThreads(__tstate);
17334 if (PyErr_Occurred()) SWIG_fail;
17335 }
17336 {
17337 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17338 }
17339 return resultobj;
17340 fail:
17341 return NULL;
17342 }
17343
17344
17345 SWIGINTERN PyObject *_wrap_Sound_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17346 PyObject *resultobj = 0;
17347 wxSound *arg1 = (wxSound *) 0 ;
17348 bool result;
17349 void *argp1 = 0 ;
17350 int res1 = 0 ;
17351 PyObject *swig_obj[1] ;
17352
17353 if (!args) SWIG_fail;
17354 swig_obj[0] = args;
17355 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17356 if (!SWIG_IsOK(res1)) {
17357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_IsOk" "', expected argument " "1"" of type '" "wxSound *""'");
17358 }
17359 arg1 = reinterpret_cast< wxSound * >(argp1);
17360 {
17361 PyThreadState* __tstate = wxPyBeginAllowThreads();
17362 result = (bool)(arg1)->IsOk();
17363 wxPyEndAllowThreads(__tstate);
17364 if (PyErr_Occurred()) SWIG_fail;
17365 }
17366 {
17367 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17368 }
17369 return resultobj;
17370 fail:
17371 return NULL;
17372 }
17373
17374
17375 SWIGINTERN PyObject *_wrap_Sound_Play(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17376 PyObject *resultobj = 0;
17377 wxSound *arg1 = (wxSound *) 0 ;
17378 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
17379 bool result;
17380 void *argp1 = 0 ;
17381 int res1 = 0 ;
17382 unsigned int val2 ;
17383 int ecode2 = 0 ;
17384 PyObject * obj0 = 0 ;
17385 PyObject * obj1 = 0 ;
17386 char * kwnames[] = {
17387 (char *) "self",(char *) "flags", NULL
17388 };
17389
17390 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) SWIG_fail;
17391 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17392 if (!SWIG_IsOK(res1)) {
17393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Play" "', expected argument " "1"" of type '" "wxSound const *""'");
17394 }
17395 arg1 = reinterpret_cast< wxSound * >(argp1);
17396 if (obj1) {
17397 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
17398 if (!SWIG_IsOK(ecode2)) {
17399 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_Play" "', expected argument " "2"" of type '" "unsigned int""'");
17400 }
17401 arg2 = static_cast< unsigned int >(val2);
17402 }
17403 {
17404 if (!wxPyCheckForApp()) SWIG_fail;
17405 PyThreadState* __tstate = wxPyBeginAllowThreads();
17406 result = (bool)((wxSound const *)arg1)->Play(arg2);
17407 wxPyEndAllowThreads(__tstate);
17408 if (PyErr_Occurred()) SWIG_fail;
17409 }
17410 {
17411 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17412 }
17413 return resultobj;
17414 fail:
17415 return NULL;
17416 }
17417
17418
17419 SWIGINTERN PyObject *_wrap_Sound_PlaySound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17420 PyObject *resultobj = 0;
17421 wxString *arg1 = 0 ;
17422 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
17423 bool result;
17424 bool temp1 = false ;
17425 unsigned int val2 ;
17426 int ecode2 = 0 ;
17427 PyObject * obj0 = 0 ;
17428 PyObject * obj1 = 0 ;
17429 char * kwnames[] = {
17430 (char *) "filename",(char *) "flags", NULL
17431 };
17432
17433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) SWIG_fail;
17434 {
17435 arg1 = wxString_in_helper(obj0);
17436 if (arg1 == NULL) SWIG_fail;
17437 temp1 = true;
17438 }
17439 if (obj1) {
17440 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
17441 if (!SWIG_IsOK(ecode2)) {
17442 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_PlaySound" "', expected argument " "2"" of type '" "unsigned int""'");
17443 }
17444 arg2 = static_cast< unsigned int >(val2);
17445 }
17446 {
17447 if (!wxPyCheckForApp()) SWIG_fail;
17448 PyThreadState* __tstate = wxPyBeginAllowThreads();
17449 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
17450 wxPyEndAllowThreads(__tstate);
17451 if (PyErr_Occurred()) SWIG_fail;
17452 }
17453 {
17454 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17455 }
17456 {
17457 if (temp1)
17458 delete arg1;
17459 }
17460 return resultobj;
17461 fail:
17462 {
17463 if (temp1)
17464 delete arg1;
17465 }
17466 return NULL;
17467 }
17468
17469
17470 SWIGINTERN PyObject *_wrap_Sound_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17471 PyObject *resultobj = 0;
17472
17473 if (!SWIG_Python_UnpackTuple(args,"Sound_Stop",0,0,0)) SWIG_fail;
17474 {
17475 if (!wxPyCheckForApp()) SWIG_fail;
17476 PyThreadState* __tstate = wxPyBeginAllowThreads();
17477 wxSound::Stop();
17478 wxPyEndAllowThreads(__tstate);
17479 if (PyErr_Occurred()) SWIG_fail;
17480 }
17481 resultobj = SWIG_Py_Void();
17482 return resultobj;
17483 fail:
17484 return NULL;
17485 }
17486
17487
17488 SWIGINTERN PyObject *Sound_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17489 PyObject *obj;
17490 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17491 SWIG_TypeNewClientData(SWIGTYPE_p_wxSound, SWIG_NewClientData(obj));
17492 return SWIG_Py_Void();
17493 }
17494
17495 SWIGINTERN PyObject *Sound_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17496 return SWIG_Python_InitShadowInstance(args);
17497 }
17498
17499 SWIGINTERN PyObject *_wrap_new_FileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17500 PyObject *resultobj = 0;
17501 wxString *arg1 = 0 ;
17502 wxString *arg2 = 0 ;
17503 wxString *arg3 = 0 ;
17504 wxString *arg4 = 0 ;
17505 wxFileTypeInfo *result = 0 ;
17506 bool temp1 = false ;
17507 bool temp2 = false ;
17508 bool temp3 = false ;
17509 bool temp4 = false ;
17510 PyObject * obj0 = 0 ;
17511 PyObject * obj1 = 0 ;
17512 PyObject * obj2 = 0 ;
17513 PyObject * obj3 = 0 ;
17514 char * kwnames[] = {
17515 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
17516 };
17517
17518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17519 {
17520 arg1 = wxString_in_helper(obj0);
17521 if (arg1 == NULL) SWIG_fail;
17522 temp1 = true;
17523 }
17524 {
17525 arg2 = wxString_in_helper(obj1);
17526 if (arg2 == NULL) SWIG_fail;
17527 temp2 = true;
17528 }
17529 {
17530 arg3 = wxString_in_helper(obj2);
17531 if (arg3 == NULL) SWIG_fail;
17532 temp3 = true;
17533 }
17534 {
17535 arg4 = wxString_in_helper(obj3);
17536 if (arg4 == NULL) SWIG_fail;
17537 temp4 = true;
17538 }
17539 {
17540 PyThreadState* __tstate = wxPyBeginAllowThreads();
17541 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
17542 wxPyEndAllowThreads(__tstate);
17543 if (PyErr_Occurred()) SWIG_fail;
17544 }
17545 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_NEW | 0 );
17546 {
17547 if (temp1)
17548 delete arg1;
17549 }
17550 {
17551 if (temp2)
17552 delete arg2;
17553 }
17554 {
17555 if (temp3)
17556 delete arg3;
17557 }
17558 {
17559 if (temp4)
17560 delete arg4;
17561 }
17562 return resultobj;
17563 fail:
17564 {
17565 if (temp1)
17566 delete arg1;
17567 }
17568 {
17569 if (temp2)
17570 delete arg2;
17571 }
17572 {
17573 if (temp3)
17574 delete arg3;
17575 }
17576 {
17577 if (temp4)
17578 delete arg4;
17579 }
17580 return NULL;
17581 }
17582
17583
17584 SWIGINTERN PyObject *_wrap_new_FileTypeInfoSequence(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17585 PyObject *resultobj = 0;
17586 wxArrayString *arg1 = 0 ;
17587 wxFileTypeInfo *result = 0 ;
17588 bool temp1 = false ;
17589 PyObject * obj0 = 0 ;
17590 char * kwnames[] = {
17591 (char *) "sArray", NULL
17592 };
17593
17594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) SWIG_fail;
17595 {
17596 if (! PySequence_Check(obj0)) {
17597 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
17598 SWIG_fail;
17599 }
17600 arg1 = new wxArrayString;
17601 temp1 = true;
17602 int i, len=PySequence_Length(obj0);
17603 for (i=0; i<len; i++) {
17604 PyObject* item = PySequence_GetItem(obj0, i);
17605 wxString* s = wxString_in_helper(item);
17606 if (PyErr_Occurred()) SWIG_fail;
17607 arg1->Add(*s);
17608 delete s;
17609 Py_DECREF(item);
17610 }
17611 }
17612 {
17613 PyThreadState* __tstate = wxPyBeginAllowThreads();
17614 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
17615 wxPyEndAllowThreads(__tstate);
17616 if (PyErr_Occurred()) SWIG_fail;
17617 }
17618 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
17619 {
17620 if (temp1) delete arg1;
17621 }
17622 return resultobj;
17623 fail:
17624 {
17625 if (temp1) delete arg1;
17626 }
17627 return NULL;
17628 }
17629
17630
17631 SWIGINTERN PyObject *_wrap_new_NullFileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17632 PyObject *resultobj = 0;
17633 wxFileTypeInfo *result = 0 ;
17634
17635 if (!SWIG_Python_UnpackTuple(args,"new_NullFileTypeInfo",0,0,0)) SWIG_fail;
17636 {
17637 PyThreadState* __tstate = wxPyBeginAllowThreads();
17638 result = (wxFileTypeInfo *)new wxFileTypeInfo();
17639 wxPyEndAllowThreads(__tstate);
17640 if (PyErr_Occurred()) SWIG_fail;
17641 }
17642 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
17643 return resultobj;
17644 fail:
17645 return NULL;
17646 }
17647
17648
17649 SWIGINTERN PyObject *_wrap_FileTypeInfo_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17650 PyObject *resultobj = 0;
17651 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17652 bool result;
17653 void *argp1 = 0 ;
17654 int res1 = 0 ;
17655 PyObject *swig_obj[1] ;
17656
17657 if (!args) SWIG_fail;
17658 swig_obj[0] = args;
17659 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17660 if (!SWIG_IsOK(res1)) {
17661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_IsValid" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17662 }
17663 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17664 {
17665 PyThreadState* __tstate = wxPyBeginAllowThreads();
17666 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
17667 wxPyEndAllowThreads(__tstate);
17668 if (PyErr_Occurred()) SWIG_fail;
17669 }
17670 {
17671 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17672 }
17673 return resultobj;
17674 fail:
17675 return NULL;
17676 }
17677
17678
17679 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17680 PyObject *resultobj = 0;
17681 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17682 wxString *arg2 = 0 ;
17683 int arg3 = (int) 0 ;
17684 void *argp1 = 0 ;
17685 int res1 = 0 ;
17686 bool temp2 = false ;
17687 int val3 ;
17688 int ecode3 = 0 ;
17689 PyObject * obj0 = 0 ;
17690 PyObject * obj1 = 0 ;
17691 PyObject * obj2 = 0 ;
17692 char * kwnames[] = {
17693 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
17694 };
17695
17696 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17697 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17698 if (!SWIG_IsOK(res1)) {
17699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
17700 }
17701 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17702 {
17703 arg2 = wxString_in_helper(obj1);
17704 if (arg2 == NULL) SWIG_fail;
17705 temp2 = true;
17706 }
17707 if (obj2) {
17708 ecode3 = SWIG_AsVal_int(obj2, &val3);
17709 if (!SWIG_IsOK(ecode3)) {
17710 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "3"" of type '" "int""'");
17711 }
17712 arg3 = static_cast< int >(val3);
17713 }
17714 {
17715 PyThreadState* __tstate = wxPyBeginAllowThreads();
17716 (arg1)->SetIcon((wxString const &)*arg2,arg3);
17717 wxPyEndAllowThreads(__tstate);
17718 if (PyErr_Occurred()) SWIG_fail;
17719 }
17720 resultobj = SWIG_Py_Void();
17721 {
17722 if (temp2)
17723 delete arg2;
17724 }
17725 return resultobj;
17726 fail:
17727 {
17728 if (temp2)
17729 delete arg2;
17730 }
17731 return NULL;
17732 }
17733
17734
17735 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17736 PyObject *resultobj = 0;
17737 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17738 wxString *arg2 = 0 ;
17739 void *argp1 = 0 ;
17740 int res1 = 0 ;
17741 bool temp2 = false ;
17742 PyObject * obj0 = 0 ;
17743 PyObject * obj1 = 0 ;
17744 char * kwnames[] = {
17745 (char *) "self",(char *) "shortDesc", NULL
17746 };
17747
17748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) SWIG_fail;
17749 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17750 if (!SWIG_IsOK(res1)) {
17751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
17752 }
17753 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17754 {
17755 arg2 = wxString_in_helper(obj1);
17756 if (arg2 == NULL) SWIG_fail;
17757 temp2 = true;
17758 }
17759 {
17760 PyThreadState* __tstate = wxPyBeginAllowThreads();
17761 (arg1)->SetShortDesc((wxString const &)*arg2);
17762 wxPyEndAllowThreads(__tstate);
17763 if (PyErr_Occurred()) SWIG_fail;
17764 }
17765 resultobj = SWIG_Py_Void();
17766 {
17767 if (temp2)
17768 delete arg2;
17769 }
17770 return resultobj;
17771 fail:
17772 {
17773 if (temp2)
17774 delete arg2;
17775 }
17776 return NULL;
17777 }
17778
17779
17780 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17781 PyObject *resultobj = 0;
17782 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17783 wxString *result = 0 ;
17784 void *argp1 = 0 ;
17785 int res1 = 0 ;
17786 PyObject *swig_obj[1] ;
17787
17788 if (!args) SWIG_fail;
17789 swig_obj[0] = args;
17790 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17791 if (!SWIG_IsOK(res1)) {
17792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetMimeType" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17793 }
17794 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17795 {
17796 PyThreadState* __tstate = wxPyBeginAllowThreads();
17797 {
17798 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
17799 result = (wxString *) &_result_ref;
17800 }
17801 wxPyEndAllowThreads(__tstate);
17802 if (PyErr_Occurred()) SWIG_fail;
17803 }
17804 {
17805 #if wxUSE_UNICODE
17806 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17807 #else
17808 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17809 #endif
17810 }
17811 return resultobj;
17812 fail:
17813 return NULL;
17814 }
17815
17816
17817 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17818 PyObject *resultobj = 0;
17819 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17820 wxString *result = 0 ;
17821 void *argp1 = 0 ;
17822 int res1 = 0 ;
17823 PyObject *swig_obj[1] ;
17824
17825 if (!args) SWIG_fail;
17826 swig_obj[0] = args;
17827 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17828 if (!SWIG_IsOK(res1)) {
17829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17830 }
17831 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17832 {
17833 PyThreadState* __tstate = wxPyBeginAllowThreads();
17834 {
17835 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
17836 result = (wxString *) &_result_ref;
17837 }
17838 wxPyEndAllowThreads(__tstate);
17839 if (PyErr_Occurred()) SWIG_fail;
17840 }
17841 {
17842 #if wxUSE_UNICODE
17843 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17844 #else
17845 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17846 #endif
17847 }
17848 return resultobj;
17849 fail:
17850 return NULL;
17851 }
17852
17853
17854 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17855 PyObject *resultobj = 0;
17856 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17857 wxString *result = 0 ;
17858 void *argp1 = 0 ;
17859 int res1 = 0 ;
17860 PyObject *swig_obj[1] ;
17861
17862 if (!args) SWIG_fail;
17863 swig_obj[0] = args;
17864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17865 if (!SWIG_IsOK(res1)) {
17866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17867 }
17868 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17869 {
17870 PyThreadState* __tstate = wxPyBeginAllowThreads();
17871 {
17872 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
17873 result = (wxString *) &_result_ref;
17874 }
17875 wxPyEndAllowThreads(__tstate);
17876 if (PyErr_Occurred()) SWIG_fail;
17877 }
17878 {
17879 #if wxUSE_UNICODE
17880 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17881 #else
17882 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17883 #endif
17884 }
17885 return resultobj;
17886 fail:
17887 return NULL;
17888 }
17889
17890
17891 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17892 PyObject *resultobj = 0;
17893 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17894 wxString *result = 0 ;
17895 void *argp1 = 0 ;
17896 int res1 = 0 ;
17897 PyObject *swig_obj[1] ;
17898
17899 if (!args) SWIG_fail;
17900 swig_obj[0] = args;
17901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17902 if (!SWIG_IsOK(res1)) {
17903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17904 }
17905 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17906 {
17907 PyThreadState* __tstate = wxPyBeginAllowThreads();
17908 {
17909 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
17910 result = (wxString *) &_result_ref;
17911 }
17912 wxPyEndAllowThreads(__tstate);
17913 if (PyErr_Occurred()) SWIG_fail;
17914 }
17915 {
17916 #if wxUSE_UNICODE
17917 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17918 #else
17919 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17920 #endif
17921 }
17922 return resultobj;
17923 fail:
17924 return NULL;
17925 }
17926
17927
17928 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17929 PyObject *resultobj = 0;
17930 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17931 wxString *result = 0 ;
17932 void *argp1 = 0 ;
17933 int res1 = 0 ;
17934 PyObject *swig_obj[1] ;
17935
17936 if (!args) SWIG_fail;
17937 swig_obj[0] = args;
17938 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17939 if (!SWIG_IsOK(res1)) {
17940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetDescription" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17941 }
17942 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17943 {
17944 PyThreadState* __tstate = wxPyBeginAllowThreads();
17945 {
17946 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
17947 result = (wxString *) &_result_ref;
17948 }
17949 wxPyEndAllowThreads(__tstate);
17950 if (PyErr_Occurred()) SWIG_fail;
17951 }
17952 {
17953 #if wxUSE_UNICODE
17954 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17955 #else
17956 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17957 #endif
17958 }
17959 return resultobj;
17960 fail:
17961 return NULL;
17962 }
17963
17964
17965 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17966 PyObject *resultobj = 0;
17967 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17968 wxArrayString *result = 0 ;
17969 void *argp1 = 0 ;
17970 int res1 = 0 ;
17971 PyObject *swig_obj[1] ;
17972
17973 if (!args) SWIG_fail;
17974 swig_obj[0] = args;
17975 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17976 if (!SWIG_IsOK(res1)) {
17977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensions" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17978 }
17979 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17980 {
17981 PyThreadState* __tstate = wxPyBeginAllowThreads();
17982 {
17983 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
17984 result = (wxArrayString *) &_result_ref;
17985 }
17986 wxPyEndAllowThreads(__tstate);
17987 if (PyErr_Occurred()) SWIG_fail;
17988 }
17989 {
17990 resultobj = wxArrayString2PyList_helper(*result);
17991 }
17992 return resultobj;
17993 fail:
17994 return NULL;
17995 }
17996
17997
17998 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17999 PyObject *resultobj = 0;
18000 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
18001 size_t result;
18002 void *argp1 = 0 ;
18003 int res1 = 0 ;
18004 PyObject *swig_obj[1] ;
18005
18006 if (!args) SWIG_fail;
18007 swig_obj[0] = args;
18008 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
18009 if (!SWIG_IsOK(res1)) {
18010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensionsCount" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
18011 }
18012 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
18013 {
18014 PyThreadState* __tstate = wxPyBeginAllowThreads();
18015 result = (size_t)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
18016 wxPyEndAllowThreads(__tstate);
18017 if (PyErr_Occurred()) SWIG_fail;
18018 }
18019 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
18020 return resultobj;
18021 fail:
18022 return NULL;
18023 }
18024
18025
18026 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18027 PyObject *resultobj = 0;
18028 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
18029 wxString *result = 0 ;
18030 void *argp1 = 0 ;
18031 int res1 = 0 ;
18032 PyObject *swig_obj[1] ;
18033
18034 if (!args) SWIG_fail;
18035 swig_obj[0] = args;
18036 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
18037 if (!SWIG_IsOK(res1)) {
18038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconFile" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
18039 }
18040 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
18041 {
18042 PyThreadState* __tstate = wxPyBeginAllowThreads();
18043 {
18044 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
18045 result = (wxString *) &_result_ref;
18046 }
18047 wxPyEndAllowThreads(__tstate);
18048 if (PyErr_Occurred()) SWIG_fail;
18049 }
18050 {
18051 #if wxUSE_UNICODE
18052 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
18053 #else
18054 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
18055 #endif
18056 }
18057 return resultobj;
18058 fail:
18059 return NULL;
18060 }
18061
18062
18063 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18064 PyObject *resultobj = 0;
18065 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
18066 int result;
18067 void *argp1 = 0 ;
18068 int res1 = 0 ;
18069 PyObject *swig_obj[1] ;
18070
18071 if (!args) SWIG_fail;
18072 swig_obj[0] = args;
18073 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
18074 if (!SWIG_IsOK(res1)) {
18075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconIndex" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
18076 }
18077 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
18078 {
18079 PyThreadState* __tstate = wxPyBeginAllowThreads();
18080 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
18081 wxPyEndAllowThreads(__tstate);
18082 if (PyErr_Occurred()) SWIG_fail;
18083 }
18084 resultobj = SWIG_From_int(static_cast< int >(result));
18085 return resultobj;
18086 fail:
18087 return NULL;
18088 }
18089
18090
18091 SWIGINTERN PyObject *FileTypeInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18092 PyObject *obj;
18093 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18094 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileTypeInfo, SWIG_NewClientData(obj));
18095 return SWIG_Py_Void();
18096 }
18097
18098 SWIGINTERN PyObject *FileTypeInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18099 return SWIG_Python_InitShadowInstance(args);
18100 }
18101
18102 SWIGINTERN PyObject *_wrap_new_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18103 PyObject *resultobj = 0;
18104 wxFileTypeInfo *arg1 = 0 ;
18105 wxFileType *result = 0 ;
18106 void *argp1 = 0 ;
18107 int res1 = 0 ;
18108 PyObject * obj0 = 0 ;
18109 char * kwnames[] = {
18110 (char *) "ftInfo", NULL
18111 };
18112
18113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) SWIG_fail;
18114 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
18115 if (!SWIG_IsOK(res1)) {
18116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
18117 }
18118 if (!argp1) {
18119 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
18120 }
18121 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
18122 {
18123 PyThreadState* __tstate = wxPyBeginAllowThreads();
18124 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
18125 wxPyEndAllowThreads(__tstate);
18126 if (PyErr_Occurred()) SWIG_fail;
18127 }
18128 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_NEW | 0 );
18129 return resultobj;
18130 fail:
18131 return NULL;
18132 }
18133
18134
18135 SWIGINTERN PyObject *_wrap_delete_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18136 PyObject *resultobj = 0;
18137 wxFileType *arg1 = (wxFileType *) 0 ;
18138 void *argp1 = 0 ;
18139 int res1 = 0 ;
18140 PyObject *swig_obj[1] ;
18141
18142 if (!args) SWIG_fail;
18143 swig_obj[0] = args;
18144 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, SWIG_POINTER_DISOWN | 0 );
18145 if (!SWIG_IsOK(res1)) {
18146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileType" "', expected argument " "1"" of type '" "wxFileType *""'");
18147 }
18148 arg1 = reinterpret_cast< wxFileType * >(argp1);
18149 {
18150 PyThreadState* __tstate = wxPyBeginAllowThreads();
18151 delete arg1;
18152
18153 wxPyEndAllowThreads(__tstate);
18154 if (PyErr_Occurred()) SWIG_fail;
18155 }
18156 resultobj = SWIG_Py_Void();
18157 return resultobj;
18158 fail:
18159 return NULL;
18160 }
18161
18162
18163 SWIGINTERN PyObject *_wrap_FileType_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18164 PyObject *resultobj = 0;
18165 wxFileType *arg1 = (wxFileType *) 0 ;
18166 PyObject *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_GetMimeType" "', expected argument " "1"" of type '" "wxFileType *""'");
18176 }
18177 arg1 = reinterpret_cast< wxFileType * >(argp1);
18178 {
18179 PyThreadState* __tstate = wxPyBeginAllowThreads();
18180 result = (PyObject *)wxFileType_GetMimeType(arg1);
18181 wxPyEndAllowThreads(__tstate);
18182 if (PyErr_Occurred()) SWIG_fail;
18183 }
18184 resultobj = result;
18185 return resultobj;
18186 fail:
18187 return NULL;
18188 }
18189
18190
18191 SWIGINTERN PyObject *_wrap_FileType_GetMimeTypes(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_GetMimeTypes" "', expected argument " "1"" of type '" "wxFileType *""'");
18204 }
18205 arg1 = reinterpret_cast< wxFileType * >(argp1);
18206 {
18207 PyThreadState* __tstate = wxPyBeginAllowThreads();
18208 result = (PyObject *)wxFileType_GetMimeTypes(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_GetExtensions(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_GetExtensions" "', expected argument " "1"" of type '" "wxFileType *""'");
18232 }
18233 arg1 = reinterpret_cast< wxFileType * >(argp1);
18234 {
18235 PyThreadState* __tstate = wxPyBeginAllowThreads();
18236 result = (PyObject *)wxFileType_GetExtensions(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_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18248 PyObject *resultobj = 0;
18249 wxFileType *arg1 = (wxFileType *) 0 ;
18250 wxIcon *result = 0 ;
18251 void *argp1 = 0 ;
18252 int res1 = 0 ;
18253 PyObject *swig_obj[1] ;
18254
18255 if (!args) SWIG_fail;
18256 swig_obj[0] = args;
18257 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18258 if (!SWIG_IsOK(res1)) {
18259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
18260 }
18261 arg1 = reinterpret_cast< wxFileType * >(argp1);
18262 {
18263 PyThreadState* __tstate = wxPyBeginAllowThreads();
18264 result = (wxIcon *)wxFileType_GetIcon(arg1);
18265 wxPyEndAllowThreads(__tstate);
18266 if (PyErr_Occurred()) SWIG_fail;
18267 }
18268 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
18269 return resultobj;
18270 fail:
18271 return NULL;
18272 }
18273
18274
18275 SWIGINTERN PyObject *_wrap_FileType_GetIconInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18276 PyObject *resultobj = 0;
18277 wxFileType *arg1 = (wxFileType *) 0 ;
18278 PyObject *result = 0 ;
18279 void *argp1 = 0 ;
18280 int res1 = 0 ;
18281 PyObject *swig_obj[1] ;
18282
18283 if (!args) SWIG_fail;
18284 swig_obj[0] = args;
18285 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18286 if (!SWIG_IsOK(res1)) {
18287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIconInfo" "', expected argument " "1"" of type '" "wxFileType *""'");
18288 }
18289 arg1 = reinterpret_cast< wxFileType * >(argp1);
18290 {
18291 PyThreadState* __tstate = wxPyBeginAllowThreads();
18292 result = (PyObject *)wxFileType_GetIconInfo(arg1);
18293 wxPyEndAllowThreads(__tstate);
18294 if (PyErr_Occurred()) SWIG_fail;
18295 }
18296 resultobj = result;
18297 return resultobj;
18298 fail:
18299 return NULL;
18300 }
18301
18302
18303 SWIGINTERN PyObject *_wrap_FileType_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18304 PyObject *resultobj = 0;
18305 wxFileType *arg1 = (wxFileType *) 0 ;
18306 PyObject *result = 0 ;
18307 void *argp1 = 0 ;
18308 int res1 = 0 ;
18309 PyObject *swig_obj[1] ;
18310
18311 if (!args) SWIG_fail;
18312 swig_obj[0] = args;
18313 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18314 if (!SWIG_IsOK(res1)) {
18315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetDescription" "', expected argument " "1"" of type '" "wxFileType *""'");
18316 }
18317 arg1 = reinterpret_cast< wxFileType * >(argp1);
18318 {
18319 PyThreadState* __tstate = wxPyBeginAllowThreads();
18320 result = (PyObject *)wxFileType_GetDescription(arg1);
18321 wxPyEndAllowThreads(__tstate);
18322 if (PyErr_Occurred()) SWIG_fail;
18323 }
18324 resultobj = result;
18325 return resultobj;
18326 fail:
18327 return NULL;
18328 }
18329
18330
18331 SWIGINTERN PyObject *_wrap_FileType_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18332 PyObject *resultobj = 0;
18333 wxFileType *arg1 = (wxFileType *) 0 ;
18334 wxString *arg2 = 0 ;
18335 wxString const &arg3_defvalue = wxPyEmptyString ;
18336 wxString *arg3 = (wxString *) &arg3_defvalue ;
18337 PyObject *result = 0 ;
18338 void *argp1 = 0 ;
18339 int res1 = 0 ;
18340 bool temp2 = false ;
18341 bool temp3 = false ;
18342 PyObject * obj0 = 0 ;
18343 PyObject * obj1 = 0 ;
18344 PyObject * obj2 = 0 ;
18345 char * kwnames[] = {
18346 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18347 };
18348
18349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18351 if (!SWIG_IsOK(res1)) {
18352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18353 }
18354 arg1 = reinterpret_cast< wxFileType * >(argp1);
18355 {
18356 arg2 = wxString_in_helper(obj1);
18357 if (arg2 == NULL) SWIG_fail;
18358 temp2 = true;
18359 }
18360 if (obj2) {
18361 {
18362 arg3 = wxString_in_helper(obj2);
18363 if (arg3 == NULL) SWIG_fail;
18364 temp3 = true;
18365 }
18366 }
18367 {
18368 PyThreadState* __tstate = wxPyBeginAllowThreads();
18369 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18370 wxPyEndAllowThreads(__tstate);
18371 if (PyErr_Occurred()) SWIG_fail;
18372 }
18373 resultobj = result;
18374 {
18375 if (temp2)
18376 delete arg2;
18377 }
18378 {
18379 if (temp3)
18380 delete arg3;
18381 }
18382 return resultobj;
18383 fail:
18384 {
18385 if (temp2)
18386 delete arg2;
18387 }
18388 {
18389 if (temp3)
18390 delete arg3;
18391 }
18392 return NULL;
18393 }
18394
18395
18396 SWIGINTERN PyObject *_wrap_FileType_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18397 PyObject *resultobj = 0;
18398 wxFileType *arg1 = (wxFileType *) 0 ;
18399 wxString *arg2 = 0 ;
18400 wxString const &arg3_defvalue = wxPyEmptyString ;
18401 wxString *arg3 = (wxString *) &arg3_defvalue ;
18402 PyObject *result = 0 ;
18403 void *argp1 = 0 ;
18404 int res1 = 0 ;
18405 bool temp2 = false ;
18406 bool temp3 = false ;
18407 PyObject * obj0 = 0 ;
18408 PyObject * obj1 = 0 ;
18409 PyObject * obj2 = 0 ;
18410 char * kwnames[] = {
18411 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18412 };
18413
18414 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18415 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18416 if (!SWIG_IsOK(res1)) {
18417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18418 }
18419 arg1 = reinterpret_cast< wxFileType * >(argp1);
18420 {
18421 arg2 = wxString_in_helper(obj1);
18422 if (arg2 == NULL) SWIG_fail;
18423 temp2 = true;
18424 }
18425 if (obj2) {
18426 {
18427 arg3 = wxString_in_helper(obj2);
18428 if (arg3 == NULL) SWIG_fail;
18429 temp3 = true;
18430 }
18431 }
18432 {
18433 PyThreadState* __tstate = wxPyBeginAllowThreads();
18434 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18435 wxPyEndAllowThreads(__tstate);
18436 if (PyErr_Occurred()) SWIG_fail;
18437 }
18438 resultobj = result;
18439 {
18440 if (temp2)
18441 delete arg2;
18442 }
18443 {
18444 if (temp3)
18445 delete arg3;
18446 }
18447 return resultobj;
18448 fail:
18449 {
18450 if (temp2)
18451 delete arg2;
18452 }
18453 {
18454 if (temp3)
18455 delete arg3;
18456 }
18457 return NULL;
18458 }
18459
18460
18461 SWIGINTERN PyObject *_wrap_FileType_GetAllCommands(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18462 PyObject *resultobj = 0;
18463 wxFileType *arg1 = (wxFileType *) 0 ;
18464 wxString *arg2 = 0 ;
18465 wxString const &arg3_defvalue = wxPyEmptyString ;
18466 wxString *arg3 = (wxString *) &arg3_defvalue ;
18467 PyObject *result = 0 ;
18468 void *argp1 = 0 ;
18469 int res1 = 0 ;
18470 bool temp2 = false ;
18471 bool temp3 = false ;
18472 PyObject * obj0 = 0 ;
18473 PyObject * obj1 = 0 ;
18474 PyObject * obj2 = 0 ;
18475 char * kwnames[] = {
18476 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18477 };
18478
18479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18480 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18481 if (!SWIG_IsOK(res1)) {
18482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetAllCommands" "', expected argument " "1"" of type '" "wxFileType *""'");
18483 }
18484 arg1 = reinterpret_cast< wxFileType * >(argp1);
18485 {
18486 arg2 = wxString_in_helper(obj1);
18487 if (arg2 == NULL) SWIG_fail;
18488 temp2 = true;
18489 }
18490 if (obj2) {
18491 {
18492 arg3 = wxString_in_helper(obj2);
18493 if (arg3 == NULL) SWIG_fail;
18494 temp3 = true;
18495 }
18496 }
18497 {
18498 PyThreadState* __tstate = wxPyBeginAllowThreads();
18499 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18500 wxPyEndAllowThreads(__tstate);
18501 if (PyErr_Occurred()) SWIG_fail;
18502 }
18503 resultobj = result;
18504 {
18505 if (temp2)
18506 delete arg2;
18507 }
18508 {
18509 if (temp3)
18510 delete arg3;
18511 }
18512 return resultobj;
18513 fail:
18514 {
18515 if (temp2)
18516 delete arg2;
18517 }
18518 {
18519 if (temp3)
18520 delete arg3;
18521 }
18522 return NULL;
18523 }
18524
18525
18526 SWIGINTERN PyObject *_wrap_FileType_SetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18527 PyObject *resultobj = 0;
18528 wxFileType *arg1 = (wxFileType *) 0 ;
18529 wxString *arg2 = 0 ;
18530 wxString *arg3 = 0 ;
18531 bool arg4 = (bool) true ;
18532 bool result;
18533 void *argp1 = 0 ;
18534 int res1 = 0 ;
18535 bool temp2 = false ;
18536 bool temp3 = false ;
18537 bool val4 ;
18538 int ecode4 = 0 ;
18539 PyObject * obj0 = 0 ;
18540 PyObject * obj1 = 0 ;
18541 PyObject * obj2 = 0 ;
18542 PyObject * obj3 = 0 ;
18543 char * kwnames[] = {
18544 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
18545 };
18546
18547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18549 if (!SWIG_IsOK(res1)) {
18550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18551 }
18552 arg1 = reinterpret_cast< wxFileType * >(argp1);
18553 {
18554 arg2 = wxString_in_helper(obj1);
18555 if (arg2 == NULL) SWIG_fail;
18556 temp2 = true;
18557 }
18558 {
18559 arg3 = wxString_in_helper(obj2);
18560 if (arg3 == NULL) SWIG_fail;
18561 temp3 = true;
18562 }
18563 if (obj3) {
18564 ecode4 = SWIG_AsVal_bool(obj3, &val4);
18565 if (!SWIG_IsOK(ecode4)) {
18566 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileType_SetCommand" "', expected argument " "4"" of type '" "bool""'");
18567 }
18568 arg4 = static_cast< bool >(val4);
18569 }
18570 {
18571 PyThreadState* __tstate = wxPyBeginAllowThreads();
18572 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
18573 wxPyEndAllowThreads(__tstate);
18574 if (PyErr_Occurred()) SWIG_fail;
18575 }
18576 {
18577 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18578 }
18579 {
18580 if (temp2)
18581 delete arg2;
18582 }
18583 {
18584 if (temp3)
18585 delete arg3;
18586 }
18587 return resultobj;
18588 fail:
18589 {
18590 if (temp2)
18591 delete arg2;
18592 }
18593 {
18594 if (temp3)
18595 delete arg3;
18596 }
18597 return NULL;
18598 }
18599
18600
18601 SWIGINTERN PyObject *_wrap_FileType_SetDefaultIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18602 PyObject *resultobj = 0;
18603 wxFileType *arg1 = (wxFileType *) 0 ;
18604 wxString const &arg2_defvalue = wxPyEmptyString ;
18605 wxString *arg2 = (wxString *) &arg2_defvalue ;
18606 int arg3 = (int) 0 ;
18607 bool result;
18608 void *argp1 = 0 ;
18609 int res1 = 0 ;
18610 bool temp2 = false ;
18611 int val3 ;
18612 int ecode3 = 0 ;
18613 PyObject * obj0 = 0 ;
18614 PyObject * obj1 = 0 ;
18615 PyObject * obj2 = 0 ;
18616 char * kwnames[] = {
18617 (char *) "self",(char *) "cmd",(char *) "index", NULL
18618 };
18619
18620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18622 if (!SWIG_IsOK(res1)) {
18623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetDefaultIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
18624 }
18625 arg1 = reinterpret_cast< wxFileType * >(argp1);
18626 if (obj1) {
18627 {
18628 arg2 = wxString_in_helper(obj1);
18629 if (arg2 == NULL) SWIG_fail;
18630 temp2 = true;
18631 }
18632 }
18633 if (obj2) {
18634 ecode3 = SWIG_AsVal_int(obj2, &val3);
18635 if (!SWIG_IsOK(ecode3)) {
18636 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileType_SetDefaultIcon" "', expected argument " "3"" of type '" "int""'");
18637 }
18638 arg3 = static_cast< int >(val3);
18639 }
18640 {
18641 PyThreadState* __tstate = wxPyBeginAllowThreads();
18642 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
18643 wxPyEndAllowThreads(__tstate);
18644 if (PyErr_Occurred()) SWIG_fail;
18645 }
18646 {
18647 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18648 }
18649 {
18650 if (temp2)
18651 delete arg2;
18652 }
18653 return resultobj;
18654 fail:
18655 {
18656 if (temp2)
18657 delete arg2;
18658 }
18659 return NULL;
18660 }
18661
18662
18663 SWIGINTERN PyObject *_wrap_FileType_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18664 PyObject *resultobj = 0;
18665 wxFileType *arg1 = (wxFileType *) 0 ;
18666 bool result;
18667 void *argp1 = 0 ;
18668 int res1 = 0 ;
18669 PyObject *swig_obj[1] ;
18670
18671 if (!args) SWIG_fail;
18672 swig_obj[0] = args;
18673 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18674 if (!SWIG_IsOK(res1)) {
18675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_Unassociate" "', expected argument " "1"" of type '" "wxFileType *""'");
18676 }
18677 arg1 = reinterpret_cast< wxFileType * >(argp1);
18678 {
18679 PyThreadState* __tstate = wxPyBeginAllowThreads();
18680 result = (bool)(arg1)->Unassociate();
18681 wxPyEndAllowThreads(__tstate);
18682 if (PyErr_Occurred()) SWIG_fail;
18683 }
18684 {
18685 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18686 }
18687 return resultobj;
18688 fail:
18689 return NULL;
18690 }
18691
18692
18693 SWIGINTERN PyObject *_wrap_FileType_ExpandCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18694 PyObject *resultobj = 0;
18695 wxString *arg1 = 0 ;
18696 wxString *arg2 = 0 ;
18697 wxString const &arg3_defvalue = wxPyEmptyString ;
18698 wxString *arg3 = (wxString *) &arg3_defvalue ;
18699 wxString result;
18700 bool temp1 = false ;
18701 bool temp2 = false ;
18702 bool temp3 = false ;
18703 PyObject * obj0 = 0 ;
18704 PyObject * obj1 = 0 ;
18705 PyObject * obj2 = 0 ;
18706 char * kwnames[] = {
18707 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
18708 };
18709
18710 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18711 {
18712 arg1 = wxString_in_helper(obj0);
18713 if (arg1 == NULL) SWIG_fail;
18714 temp1 = true;
18715 }
18716 {
18717 arg2 = wxString_in_helper(obj1);
18718 if (arg2 == NULL) SWIG_fail;
18719 temp2 = true;
18720 }
18721 if (obj2) {
18722 {
18723 arg3 = wxString_in_helper(obj2);
18724 if (arg3 == NULL) SWIG_fail;
18725 temp3 = true;
18726 }
18727 }
18728 {
18729 PyThreadState* __tstate = wxPyBeginAllowThreads();
18730 result = wxFileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18731 wxPyEndAllowThreads(__tstate);
18732 if (PyErr_Occurred()) SWIG_fail;
18733 }
18734 {
18735 #if wxUSE_UNICODE
18736 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18737 #else
18738 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18739 #endif
18740 }
18741 {
18742 if (temp1)
18743 delete arg1;
18744 }
18745 {
18746 if (temp2)
18747 delete arg2;
18748 }
18749 {
18750 if (temp3)
18751 delete arg3;
18752 }
18753 return resultobj;
18754 fail:
18755 {
18756 if (temp1)
18757 delete arg1;
18758 }
18759 {
18760 if (temp2)
18761 delete arg2;
18762 }
18763 {
18764 if (temp3)
18765 delete arg3;
18766 }
18767 return NULL;
18768 }
18769
18770
18771 SWIGINTERN PyObject *FileType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18772 PyObject *obj;
18773 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18774 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileType, SWIG_NewClientData(obj));
18775 return SWIG_Py_Void();
18776 }
18777
18778 SWIGINTERN PyObject *FileType_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18779 return SWIG_Python_InitShadowInstance(args);
18780 }
18781
18782 SWIGINTERN int TheMimeTypesManager_set(PyObject *) {
18783 SWIG_Error(SWIG_AttributeError,"Variable TheMimeTypesManager is read-only.");
18784 return 1;
18785 }
18786
18787
18788 SWIGINTERN PyObject *TheMimeTypesManager_get(void) {
18789 PyObject *pyobj = 0;
18790
18791 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0 );
18792 return pyobj;
18793 }
18794
18795
18796 SWIGINTERN PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18797 PyObject *resultobj = 0;
18798 wxString *arg1 = 0 ;
18799 wxString *arg2 = 0 ;
18800 bool result;
18801 bool temp1 = false ;
18802 bool temp2 = false ;
18803 PyObject * obj0 = 0 ;
18804 PyObject * obj1 = 0 ;
18805 char * kwnames[] = {
18806 (char *) "mimeType",(char *) "wildcard", NULL
18807 };
18808
18809 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) SWIG_fail;
18810 {
18811 arg1 = wxString_in_helper(obj0);
18812 if (arg1 == NULL) SWIG_fail;
18813 temp1 = true;
18814 }
18815 {
18816 arg2 = wxString_in_helper(obj1);
18817 if (arg2 == NULL) SWIG_fail;
18818 temp2 = true;
18819 }
18820 {
18821 PyThreadState* __tstate = wxPyBeginAllowThreads();
18822 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
18823 wxPyEndAllowThreads(__tstate);
18824 if (PyErr_Occurred()) SWIG_fail;
18825 }
18826 {
18827 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18828 }
18829 {
18830 if (temp1)
18831 delete arg1;
18832 }
18833 {
18834 if (temp2)
18835 delete arg2;
18836 }
18837 return resultobj;
18838 fail:
18839 {
18840 if (temp1)
18841 delete arg1;
18842 }
18843 {
18844 if (temp2)
18845 delete arg2;
18846 }
18847 return NULL;
18848 }
18849
18850
18851 SWIGINTERN PyObject *_wrap_new_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18852 PyObject *resultobj = 0;
18853 wxMimeTypesManager *result = 0 ;
18854
18855 if (!SWIG_Python_UnpackTuple(args,"new_MimeTypesManager",0,0,0)) SWIG_fail;
18856 {
18857 PyThreadState* __tstate = wxPyBeginAllowThreads();
18858 result = (wxMimeTypesManager *)new wxMimeTypesManager();
18859 wxPyEndAllowThreads(__tstate);
18860 if (PyErr_Occurred()) SWIG_fail;
18861 }
18862 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_NEW | 0 );
18863 return resultobj;
18864 fail:
18865 return NULL;
18866 }
18867
18868
18869 SWIGINTERN PyObject *_wrap_MimeTypesManager_Initialize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18870 PyObject *resultobj = 0;
18871 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18872 int arg2 = (int) wxMAILCAP_ALL ;
18873 wxString const &arg3_defvalue = wxPyEmptyString ;
18874 wxString *arg3 = (wxString *) &arg3_defvalue ;
18875 void *argp1 = 0 ;
18876 int res1 = 0 ;
18877 int val2 ;
18878 int ecode2 = 0 ;
18879 bool temp3 = false ;
18880 PyObject * obj0 = 0 ;
18881 PyObject * obj1 = 0 ;
18882 PyObject * obj2 = 0 ;
18883 char * kwnames[] = {
18884 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
18885 };
18886
18887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18889 if (!SWIG_IsOK(res1)) {
18890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Initialize" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18891 }
18892 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18893 if (obj1) {
18894 ecode2 = SWIG_AsVal_int(obj1, &val2);
18895 if (!SWIG_IsOK(ecode2)) {
18896 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MimeTypesManager_Initialize" "', expected argument " "2"" of type '" "int""'");
18897 }
18898 arg2 = static_cast< int >(val2);
18899 }
18900 if (obj2) {
18901 {
18902 arg3 = wxString_in_helper(obj2);
18903 if (arg3 == NULL) SWIG_fail;
18904 temp3 = true;
18905 }
18906 }
18907 {
18908 PyThreadState* __tstate = wxPyBeginAllowThreads();
18909 (arg1)->Initialize(arg2,(wxString const &)*arg3);
18910 wxPyEndAllowThreads(__tstate);
18911 if (PyErr_Occurred()) SWIG_fail;
18912 }
18913 resultobj = SWIG_Py_Void();
18914 {
18915 if (temp3)
18916 delete arg3;
18917 }
18918 return resultobj;
18919 fail:
18920 {
18921 if (temp3)
18922 delete arg3;
18923 }
18924 return NULL;
18925 }
18926
18927
18928 SWIGINTERN PyObject *_wrap_MimeTypesManager_ClearData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18929 PyObject *resultobj = 0;
18930 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18931 void *argp1 = 0 ;
18932 int res1 = 0 ;
18933 PyObject *swig_obj[1] ;
18934
18935 if (!args) SWIG_fail;
18936 swig_obj[0] = args;
18937 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18938 if (!SWIG_IsOK(res1)) {
18939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ClearData" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18940 }
18941 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18942 {
18943 PyThreadState* __tstate = wxPyBeginAllowThreads();
18944 (arg1)->ClearData();
18945 wxPyEndAllowThreads(__tstate);
18946 if (PyErr_Occurred()) SWIG_fail;
18947 }
18948 resultobj = SWIG_Py_Void();
18949 return resultobj;
18950 fail:
18951 return NULL;
18952 }
18953
18954
18955 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18956 PyObject *resultobj = 0;
18957 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18958 wxString *arg2 = 0 ;
18959 wxFileType *result = 0 ;
18960 void *argp1 = 0 ;
18961 int res1 = 0 ;
18962 bool temp2 = false ;
18963 PyObject * obj0 = 0 ;
18964 PyObject * obj1 = 0 ;
18965 char * kwnames[] = {
18966 (char *) "self",(char *) "ext", NULL
18967 };
18968
18969 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) SWIG_fail;
18970 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18971 if (!SWIG_IsOK(res1)) {
18972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromExtension" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18973 }
18974 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18975 {
18976 arg2 = wxString_in_helper(obj1);
18977 if (arg2 == NULL) SWIG_fail;
18978 temp2 = true;
18979 }
18980 {
18981 PyThreadState* __tstate = wxPyBeginAllowThreads();
18982 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
18983 wxPyEndAllowThreads(__tstate);
18984 if (PyErr_Occurred()) SWIG_fail;
18985 }
18986 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
18987 {
18988 if (temp2)
18989 delete arg2;
18990 }
18991 return resultobj;
18992 fail:
18993 {
18994 if (temp2)
18995 delete arg2;
18996 }
18997 return NULL;
18998 }
18999
19000
19001 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19002 PyObject *resultobj = 0;
19003 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19004 wxString *arg2 = 0 ;
19005 wxFileType *result = 0 ;
19006 void *argp1 = 0 ;
19007 int res1 = 0 ;
19008 bool temp2 = false ;
19009 PyObject * obj0 = 0 ;
19010 PyObject * obj1 = 0 ;
19011 char * kwnames[] = {
19012 (char *) "self",(char *) "mimeType", NULL
19013 };
19014
19015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
19016 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19017 if (!SWIG_IsOK(res1)) {
19018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromMimeType" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19019 }
19020 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19021 {
19022 arg2 = wxString_in_helper(obj1);
19023 if (arg2 == NULL) SWIG_fail;
19024 temp2 = true;
19025 }
19026 {
19027 PyThreadState* __tstate = wxPyBeginAllowThreads();
19028 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
19029 wxPyEndAllowThreads(__tstate);
19030 if (PyErr_Occurred()) SWIG_fail;
19031 }
19032 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
19033 {
19034 if (temp2)
19035 delete arg2;
19036 }
19037 return resultobj;
19038 fail:
19039 {
19040 if (temp2)
19041 delete arg2;
19042 }
19043 return NULL;
19044 }
19045
19046
19047 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19048 PyObject *resultobj = 0;
19049 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19050 wxString *arg2 = 0 ;
19051 bool arg3 = (bool) false ;
19052 bool result;
19053 void *argp1 = 0 ;
19054 int res1 = 0 ;
19055 bool temp2 = false ;
19056 bool val3 ;
19057 int ecode3 = 0 ;
19058 PyObject * obj0 = 0 ;
19059 PyObject * obj1 = 0 ;
19060 PyObject * obj2 = 0 ;
19061 char * kwnames[] = {
19062 (char *) "self",(char *) "filename",(char *) "fallback", NULL
19063 };
19064
19065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19067 if (!SWIG_IsOK(res1)) {
19068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19069 }
19070 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19071 {
19072 arg2 = wxString_in_helper(obj1);
19073 if (arg2 == NULL) SWIG_fail;
19074 temp2 = true;
19075 }
19076 if (obj2) {
19077 ecode3 = SWIG_AsVal_bool(obj2, &val3);
19078 if (!SWIG_IsOK(ecode3)) {
19079 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "3"" of type '" "bool""'");
19080 }
19081 arg3 = static_cast< bool >(val3);
19082 }
19083 {
19084 PyThreadState* __tstate = wxPyBeginAllowThreads();
19085 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
19086 wxPyEndAllowThreads(__tstate);
19087 if (PyErr_Occurred()) SWIG_fail;
19088 }
19089 {
19090 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19091 }
19092 {
19093 if (temp2)
19094 delete arg2;
19095 }
19096 return resultobj;
19097 fail:
19098 {
19099 if (temp2)
19100 delete arg2;
19101 }
19102 return NULL;
19103 }
19104
19105
19106 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19107 PyObject *resultobj = 0;
19108 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19109 wxString *arg2 = 0 ;
19110 bool result;
19111 void *argp1 = 0 ;
19112 int res1 = 0 ;
19113 bool temp2 = false ;
19114 PyObject * obj0 = 0 ;
19115 PyObject * obj1 = 0 ;
19116 char * kwnames[] = {
19117 (char *) "self",(char *) "filename", NULL
19118 };
19119
19120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) SWIG_fail;
19121 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19122 if (!SWIG_IsOK(res1)) {
19123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMimeTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19124 }
19125 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19126 {
19127 arg2 = wxString_in_helper(obj1);
19128 if (arg2 == NULL) SWIG_fail;
19129 temp2 = true;
19130 }
19131 {
19132 PyThreadState* __tstate = wxPyBeginAllowThreads();
19133 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
19134 wxPyEndAllowThreads(__tstate);
19135 if (PyErr_Occurred()) SWIG_fail;
19136 }
19137 {
19138 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19139 }
19140 {
19141 if (temp2)
19142 delete arg2;
19143 }
19144 return resultobj;
19145 fail:
19146 {
19147 if (temp2)
19148 delete arg2;
19149 }
19150 return NULL;
19151 }
19152
19153
19154 SWIGINTERN PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19155 PyObject *resultobj = 0;
19156 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19157 PyObject *result = 0 ;
19158 void *argp1 = 0 ;
19159 int res1 = 0 ;
19160 PyObject *swig_obj[1] ;
19161
19162 if (!args) SWIG_fail;
19163 swig_obj[0] = args;
19164 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19165 if (!SWIG_IsOK(res1)) {
19166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_EnumAllFileTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19167 }
19168 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19169 {
19170 PyThreadState* __tstate = wxPyBeginAllowThreads();
19171 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
19172 wxPyEndAllowThreads(__tstate);
19173 if (PyErr_Occurred()) SWIG_fail;
19174 }
19175 resultobj = result;
19176 return resultobj;
19177 fail:
19178 return NULL;
19179 }
19180
19181
19182 SWIGINTERN PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19183 PyObject *resultobj = 0;
19184 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19185 wxFileTypeInfo *arg2 = 0 ;
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_AddFallback",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_AddFallback" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19200 }
19201 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19202 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
19203 if (!SWIG_IsOK(res2)) {
19204 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19205 }
19206 if (!argp2) {
19207 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19208 }
19209 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
19210 {
19211 PyThreadState* __tstate = wxPyBeginAllowThreads();
19212 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
19213 wxPyEndAllowThreads(__tstate);
19214 if (PyErr_Occurred()) SWIG_fail;
19215 }
19216 resultobj = SWIG_Py_Void();
19217 return resultobj;
19218 fail:
19219 return NULL;
19220 }
19221
19222
19223 SWIGINTERN PyObject *_wrap_MimeTypesManager_Associate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19224 PyObject *resultobj = 0;
19225 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19226 wxFileTypeInfo *arg2 = 0 ;
19227 wxFileType *result = 0 ;
19228 void *argp1 = 0 ;
19229 int res1 = 0 ;
19230 void *argp2 = 0 ;
19231 int res2 = 0 ;
19232 PyObject * obj0 = 0 ;
19233 PyObject * obj1 = 0 ;
19234 char * kwnames[] = {
19235 (char *) "self",(char *) "ftInfo", NULL
19236 };
19237
19238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) SWIG_fail;
19239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19240 if (!SWIG_IsOK(res1)) {
19241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Associate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19242 }
19243 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19244 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
19245 if (!SWIG_IsOK(res2)) {
19246 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19247 }
19248 if (!argp2) {
19249 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19250 }
19251 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
19252 {
19253 PyThreadState* __tstate = wxPyBeginAllowThreads();
19254 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
19255 wxPyEndAllowThreads(__tstate);
19256 if (PyErr_Occurred()) SWIG_fail;
19257 }
19258 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
19259 return resultobj;
19260 fail:
19261 return NULL;
19262 }
19263
19264
19265 SWIGINTERN PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19266 PyObject *resultobj = 0;
19267 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19268 wxFileType *arg2 = (wxFileType *) 0 ;
19269 bool result;
19270 void *argp1 = 0 ;
19271 int res1 = 0 ;
19272 void *argp2 = 0 ;
19273 int res2 = 0 ;
19274 PyObject * obj0 = 0 ;
19275 PyObject * obj1 = 0 ;
19276 char * kwnames[] = {
19277 (char *) "self",(char *) "ft", NULL
19278 };
19279
19280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) SWIG_fail;
19281 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19282 if (!SWIG_IsOK(res1)) {
19283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19284 }
19285 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19286 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFileType, 0 | 0 );
19287 if (!SWIG_IsOK(res2)) {
19288 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "2"" of type '" "wxFileType *""'");
19289 }
19290 arg2 = reinterpret_cast< wxFileType * >(argp2);
19291 {
19292 PyThreadState* __tstate = wxPyBeginAllowThreads();
19293 result = (bool)(arg1)->Unassociate(arg2);
19294 wxPyEndAllowThreads(__tstate);
19295 if (PyErr_Occurred()) SWIG_fail;
19296 }
19297 {
19298 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19299 }
19300 return resultobj;
19301 fail:
19302 return NULL;
19303 }
19304
19305
19306 SWIGINTERN PyObject *_wrap_delete_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19307 PyObject *resultobj = 0;
19308 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19309 void *argp1 = 0 ;
19310 int res1 = 0 ;
19311 PyObject *swig_obj[1] ;
19312
19313 if (!args) SWIG_fail;
19314 swig_obj[0] = args;
19315 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_DISOWN | 0 );
19316 if (!SWIG_IsOK(res1)) {
19317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MimeTypesManager" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19318 }
19319 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19320 {
19321 PyThreadState* __tstate = wxPyBeginAllowThreads();
19322 delete arg1;
19323
19324 wxPyEndAllowThreads(__tstate);
19325 if (PyErr_Occurred()) SWIG_fail;
19326 }
19327 resultobj = SWIG_Py_Void();
19328 return resultobj;
19329 fail:
19330 return NULL;
19331 }
19332
19333
19334 SWIGINTERN PyObject *MimeTypesManager_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19335 PyObject *obj;
19336 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19337 SWIG_TypeNewClientData(SWIGTYPE_p_wxMimeTypesManager, SWIG_NewClientData(obj));
19338 return SWIG_Py_Void();
19339 }
19340
19341 SWIGINTERN PyObject *MimeTypesManager_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19342 return SWIG_Python_InitShadowInstance(args);
19343 }
19344
19345 SWIGINTERN int ART_TOOLBAR_set(PyObject *) {
19346 SWIG_Error(SWIG_AttributeError,"Variable ART_TOOLBAR is read-only.");
19347 return 1;
19348 }
19349
19350
19351 SWIGINTERN PyObject *ART_TOOLBAR_get(void) {
19352 PyObject *pyobj = 0;
19353
19354 {
19355 #if wxUSE_UNICODE
19356 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
19357 #else
19358 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
19359 #endif
19360 }
19361 return pyobj;
19362 }
19363
19364
19365 SWIGINTERN int ART_MENU_set(PyObject *) {
19366 SWIG_Error(SWIG_AttributeError,"Variable ART_MENU is read-only.");
19367 return 1;
19368 }
19369
19370
19371 SWIGINTERN PyObject *ART_MENU_get(void) {
19372 PyObject *pyobj = 0;
19373
19374 {
19375 #if wxUSE_UNICODE
19376 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
19377 #else
19378 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
19379 #endif
19380 }
19381 return pyobj;
19382 }
19383
19384
19385 SWIGINTERN int ART_FRAME_ICON_set(PyObject *) {
19386 SWIG_Error(SWIG_AttributeError,"Variable ART_FRAME_ICON is read-only.");
19387 return 1;
19388 }
19389
19390
19391 SWIGINTERN PyObject *ART_FRAME_ICON_get(void) {
19392 PyObject *pyobj = 0;
19393
19394 {
19395 #if wxUSE_UNICODE
19396 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
19397 #else
19398 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
19399 #endif
19400 }
19401 return pyobj;
19402 }
19403
19404
19405 SWIGINTERN int ART_CMN_DIALOG_set(PyObject *) {
19406 SWIG_Error(SWIG_AttributeError,"Variable ART_CMN_DIALOG is read-only.");
19407 return 1;
19408 }
19409
19410
19411 SWIGINTERN PyObject *ART_CMN_DIALOG_get(void) {
19412 PyObject *pyobj = 0;
19413
19414 {
19415 #if wxUSE_UNICODE
19416 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
19417 #else
19418 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
19419 #endif
19420 }
19421 return pyobj;
19422 }
19423
19424
19425 SWIGINTERN int ART_HELP_BROWSER_set(PyObject *) {
19426 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BROWSER is read-only.");
19427 return 1;
19428 }
19429
19430
19431 SWIGINTERN PyObject *ART_HELP_BROWSER_get(void) {
19432 PyObject *pyobj = 0;
19433
19434 {
19435 #if wxUSE_UNICODE
19436 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
19437 #else
19438 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
19439 #endif
19440 }
19441 return pyobj;
19442 }
19443
19444
19445 SWIGINTERN int ART_MESSAGE_BOX_set(PyObject *) {
19446 SWIG_Error(SWIG_AttributeError,"Variable ART_MESSAGE_BOX is read-only.");
19447 return 1;
19448 }
19449
19450
19451 SWIGINTERN PyObject *ART_MESSAGE_BOX_get(void) {
19452 PyObject *pyobj = 0;
19453
19454 {
19455 #if wxUSE_UNICODE
19456 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
19457 #else
19458 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
19459 #endif
19460 }
19461 return pyobj;
19462 }
19463
19464
19465 SWIGINTERN int ART_BUTTON_set(PyObject *) {
19466 SWIG_Error(SWIG_AttributeError,"Variable ART_BUTTON is read-only.");
19467 return 1;
19468 }
19469
19470
19471 SWIGINTERN PyObject *ART_BUTTON_get(void) {
19472 PyObject *pyobj = 0;
19473
19474 {
19475 #if wxUSE_UNICODE
19476 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
19477 #else
19478 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
19479 #endif
19480 }
19481 return pyobj;
19482 }
19483
19484
19485 SWIGINTERN int ART_OTHER_set(PyObject *) {
19486 SWIG_Error(SWIG_AttributeError,"Variable ART_OTHER is read-only.");
19487 return 1;
19488 }
19489
19490
19491 SWIGINTERN PyObject *ART_OTHER_get(void) {
19492 PyObject *pyobj = 0;
19493
19494 {
19495 #if wxUSE_UNICODE
19496 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
19497 #else
19498 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
19499 #endif
19500 }
19501 return pyobj;
19502 }
19503
19504
19505 SWIGINTERN int ART_ADD_BOOKMARK_set(PyObject *) {
19506 SWIG_Error(SWIG_AttributeError,"Variable ART_ADD_BOOKMARK is read-only.");
19507 return 1;
19508 }
19509
19510
19511 SWIGINTERN PyObject *ART_ADD_BOOKMARK_get(void) {
19512 PyObject *pyobj = 0;
19513
19514 {
19515 #if wxUSE_UNICODE
19516 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
19517 #else
19518 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
19519 #endif
19520 }
19521 return pyobj;
19522 }
19523
19524
19525 SWIGINTERN int ART_DEL_BOOKMARK_set(PyObject *) {
19526 SWIG_Error(SWIG_AttributeError,"Variable ART_DEL_BOOKMARK is read-only.");
19527 return 1;
19528 }
19529
19530
19531 SWIGINTERN PyObject *ART_DEL_BOOKMARK_get(void) {
19532 PyObject *pyobj = 0;
19533
19534 {
19535 #if wxUSE_UNICODE
19536 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
19537 #else
19538 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
19539 #endif
19540 }
19541 return pyobj;
19542 }
19543
19544
19545 SWIGINTERN int ART_HELP_SIDE_PANEL_set(PyObject *) {
19546 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
19547 return 1;
19548 }
19549
19550
19551 SWIGINTERN PyObject *ART_HELP_SIDE_PANEL_get(void) {
19552 PyObject *pyobj = 0;
19553
19554 {
19555 #if wxUSE_UNICODE
19556 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
19557 #else
19558 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
19559 #endif
19560 }
19561 return pyobj;
19562 }
19563
19564
19565 SWIGINTERN int ART_HELP_SETTINGS_set(PyObject *) {
19566 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SETTINGS is read-only.");
19567 return 1;
19568 }
19569
19570
19571 SWIGINTERN PyObject *ART_HELP_SETTINGS_get(void) {
19572 PyObject *pyobj = 0;
19573
19574 {
19575 #if wxUSE_UNICODE
19576 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
19577 #else
19578 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
19579 #endif
19580 }
19581 return pyobj;
19582 }
19583
19584
19585 SWIGINTERN int ART_HELP_BOOK_set(PyObject *) {
19586 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BOOK is read-only.");
19587 return 1;
19588 }
19589
19590
19591 SWIGINTERN PyObject *ART_HELP_BOOK_get(void) {
19592 PyObject *pyobj = 0;
19593
19594 {
19595 #if wxUSE_UNICODE
19596 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
19597 #else
19598 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
19599 #endif
19600 }
19601 return pyobj;
19602 }
19603
19604
19605 SWIGINTERN int ART_HELP_FOLDER_set(PyObject *) {
19606 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_FOLDER is read-only.");
19607 return 1;
19608 }
19609
19610
19611 SWIGINTERN PyObject *ART_HELP_FOLDER_get(void) {
19612 PyObject *pyobj = 0;
19613
19614 {
19615 #if wxUSE_UNICODE
19616 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
19617 #else
19618 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
19619 #endif
19620 }
19621 return pyobj;
19622 }
19623
19624
19625 SWIGINTERN int ART_HELP_PAGE_set(PyObject *) {
19626 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_PAGE is read-only.");
19627 return 1;
19628 }
19629
19630
19631 SWIGINTERN PyObject *ART_HELP_PAGE_get(void) {
19632 PyObject *pyobj = 0;
19633
19634 {
19635 #if wxUSE_UNICODE
19636 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
19637 #else
19638 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
19639 #endif
19640 }
19641 return pyobj;
19642 }
19643
19644
19645 SWIGINTERN int ART_GO_BACK_set(PyObject *) {
19646 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_BACK is read-only.");
19647 return 1;
19648 }
19649
19650
19651 SWIGINTERN PyObject *ART_GO_BACK_get(void) {
19652 PyObject *pyobj = 0;
19653
19654 {
19655 #if wxUSE_UNICODE
19656 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
19657 #else
19658 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
19659 #endif
19660 }
19661 return pyobj;
19662 }
19663
19664
19665 SWIGINTERN int ART_GO_FORWARD_set(PyObject *) {
19666 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_FORWARD is read-only.");
19667 return 1;
19668 }
19669
19670
19671 SWIGINTERN PyObject *ART_GO_FORWARD_get(void) {
19672 PyObject *pyobj = 0;
19673
19674 {
19675 #if wxUSE_UNICODE
19676 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
19677 #else
19678 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
19679 #endif
19680 }
19681 return pyobj;
19682 }
19683
19684
19685 SWIGINTERN int ART_GO_UP_set(PyObject *) {
19686 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_UP is read-only.");
19687 return 1;
19688 }
19689
19690
19691 SWIGINTERN PyObject *ART_GO_UP_get(void) {
19692 PyObject *pyobj = 0;
19693
19694 {
19695 #if wxUSE_UNICODE
19696 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
19697 #else
19698 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
19699 #endif
19700 }
19701 return pyobj;
19702 }
19703
19704
19705 SWIGINTERN int ART_GO_DOWN_set(PyObject *) {
19706 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DOWN is read-only.");
19707 return 1;
19708 }
19709
19710
19711 SWIGINTERN PyObject *ART_GO_DOWN_get(void) {
19712 PyObject *pyobj = 0;
19713
19714 {
19715 #if wxUSE_UNICODE
19716 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
19717 #else
19718 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
19719 #endif
19720 }
19721 return pyobj;
19722 }
19723
19724
19725 SWIGINTERN int ART_GO_TO_PARENT_set(PyObject *) {
19726 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_TO_PARENT is read-only.");
19727 return 1;
19728 }
19729
19730
19731 SWIGINTERN PyObject *ART_GO_TO_PARENT_get(void) {
19732 PyObject *pyobj = 0;
19733
19734 {
19735 #if wxUSE_UNICODE
19736 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
19737 #else
19738 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
19739 #endif
19740 }
19741 return pyobj;
19742 }
19743
19744
19745 SWIGINTERN int ART_GO_HOME_set(PyObject *) {
19746 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_HOME is read-only.");
19747 return 1;
19748 }
19749
19750
19751 SWIGINTERN PyObject *ART_GO_HOME_get(void) {
19752 PyObject *pyobj = 0;
19753
19754 {
19755 #if wxUSE_UNICODE
19756 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
19757 #else
19758 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
19759 #endif
19760 }
19761 return pyobj;
19762 }
19763
19764
19765 SWIGINTERN int ART_FILE_OPEN_set(PyObject *) {
19766 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_OPEN is read-only.");
19767 return 1;
19768 }
19769
19770
19771 SWIGINTERN PyObject *ART_FILE_OPEN_get(void) {
19772 PyObject *pyobj = 0;
19773
19774 {
19775 #if wxUSE_UNICODE
19776 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
19777 #else
19778 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
19779 #endif
19780 }
19781 return pyobj;
19782 }
19783
19784
19785 SWIGINTERN int ART_FILE_SAVE_set(PyObject *) {
19786 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE is read-only.");
19787 return 1;
19788 }
19789
19790
19791 SWIGINTERN PyObject *ART_FILE_SAVE_get(void) {
19792 PyObject *pyobj = 0;
19793
19794 {
19795 #if wxUSE_UNICODE
19796 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
19797 #else
19798 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
19799 #endif
19800 }
19801 return pyobj;
19802 }
19803
19804
19805 SWIGINTERN int ART_FILE_SAVE_AS_set(PyObject *) {
19806 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE_AS is read-only.");
19807 return 1;
19808 }
19809
19810
19811 SWIGINTERN PyObject *ART_FILE_SAVE_AS_get(void) {
19812 PyObject *pyobj = 0;
19813
19814 {
19815 #if wxUSE_UNICODE
19816 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
19817 #else
19818 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
19819 #endif
19820 }
19821 return pyobj;
19822 }
19823
19824
19825 SWIGINTERN int ART_PRINT_set(PyObject *) {
19826 SWIG_Error(SWIG_AttributeError,"Variable ART_PRINT is read-only.");
19827 return 1;
19828 }
19829
19830
19831 SWIGINTERN PyObject *ART_PRINT_get(void) {
19832 PyObject *pyobj = 0;
19833
19834 {
19835 #if wxUSE_UNICODE
19836 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
19837 #else
19838 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
19839 #endif
19840 }
19841 return pyobj;
19842 }
19843
19844
19845 SWIGINTERN int ART_HELP_set(PyObject *) {
19846 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP is read-only.");
19847 return 1;
19848 }
19849
19850
19851 SWIGINTERN PyObject *ART_HELP_get(void) {
19852 PyObject *pyobj = 0;
19853
19854 {
19855 #if wxUSE_UNICODE
19856 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
19857 #else
19858 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
19859 #endif
19860 }
19861 return pyobj;
19862 }
19863
19864
19865 SWIGINTERN int ART_TIP_set(PyObject *) {
19866 SWIG_Error(SWIG_AttributeError,"Variable ART_TIP is read-only.");
19867 return 1;
19868 }
19869
19870
19871 SWIGINTERN PyObject *ART_TIP_get(void) {
19872 PyObject *pyobj = 0;
19873
19874 {
19875 #if wxUSE_UNICODE
19876 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
19877 #else
19878 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
19879 #endif
19880 }
19881 return pyobj;
19882 }
19883
19884
19885 SWIGINTERN int ART_REPORT_VIEW_set(PyObject *) {
19886 SWIG_Error(SWIG_AttributeError,"Variable ART_REPORT_VIEW is read-only.");
19887 return 1;
19888 }
19889
19890
19891 SWIGINTERN PyObject *ART_REPORT_VIEW_get(void) {
19892 PyObject *pyobj = 0;
19893
19894 {
19895 #if wxUSE_UNICODE
19896 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
19897 #else
19898 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
19899 #endif
19900 }
19901 return pyobj;
19902 }
19903
19904
19905 SWIGINTERN int ART_LIST_VIEW_set(PyObject *) {
19906 SWIG_Error(SWIG_AttributeError,"Variable ART_LIST_VIEW is read-only.");
19907 return 1;
19908 }
19909
19910
19911 SWIGINTERN PyObject *ART_LIST_VIEW_get(void) {
19912 PyObject *pyobj = 0;
19913
19914 {
19915 #if wxUSE_UNICODE
19916 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
19917 #else
19918 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
19919 #endif
19920 }
19921 return pyobj;
19922 }
19923
19924
19925 SWIGINTERN int ART_NEW_DIR_set(PyObject *) {
19926 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW_DIR is read-only.");
19927 return 1;
19928 }
19929
19930
19931 SWIGINTERN PyObject *ART_NEW_DIR_get(void) {
19932 PyObject *pyobj = 0;
19933
19934 {
19935 #if wxUSE_UNICODE
19936 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
19937 #else
19938 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
19939 #endif
19940 }
19941 return pyobj;
19942 }
19943
19944
19945 SWIGINTERN int ART_HARDDISK_set(PyObject *) {
19946 SWIG_Error(SWIG_AttributeError,"Variable ART_HARDDISK is read-only.");
19947 return 1;
19948 }
19949
19950
19951 SWIGINTERN PyObject *ART_HARDDISK_get(void) {
19952 PyObject *pyobj = 0;
19953
19954 {
19955 #if wxUSE_UNICODE
19956 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
19957 #else
19958 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
19959 #endif
19960 }
19961 return pyobj;
19962 }
19963
19964
19965 SWIGINTERN int ART_FLOPPY_set(PyObject *) {
19966 SWIG_Error(SWIG_AttributeError,"Variable ART_FLOPPY is read-only.");
19967 return 1;
19968 }
19969
19970
19971 SWIGINTERN PyObject *ART_FLOPPY_get(void) {
19972 PyObject *pyobj = 0;
19973
19974 {
19975 #if wxUSE_UNICODE
19976 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
19977 #else
19978 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
19979 #endif
19980 }
19981 return pyobj;
19982 }
19983
19984
19985 SWIGINTERN int ART_CDROM_set(PyObject *) {
19986 SWIG_Error(SWIG_AttributeError,"Variable ART_CDROM is read-only.");
19987 return 1;
19988 }
19989
19990
19991 SWIGINTERN PyObject *ART_CDROM_get(void) {
19992 PyObject *pyobj = 0;
19993
19994 {
19995 #if wxUSE_UNICODE
19996 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
19997 #else
19998 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
19999 #endif
20000 }
20001 return pyobj;
20002 }
20003
20004
20005 SWIGINTERN int ART_REMOVABLE_set(PyObject *) {
20006 SWIG_Error(SWIG_AttributeError,"Variable ART_REMOVABLE is read-only.");
20007 return 1;
20008 }
20009
20010
20011 SWIGINTERN PyObject *ART_REMOVABLE_get(void) {
20012 PyObject *pyobj = 0;
20013
20014 {
20015 #if wxUSE_UNICODE
20016 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
20017 #else
20018 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
20019 #endif
20020 }
20021 return pyobj;
20022 }
20023
20024
20025 SWIGINTERN int ART_FOLDER_set(PyObject *) {
20026 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER is read-only.");
20027 return 1;
20028 }
20029
20030
20031 SWIGINTERN PyObject *ART_FOLDER_get(void) {
20032 PyObject *pyobj = 0;
20033
20034 {
20035 #if wxUSE_UNICODE
20036 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
20037 #else
20038 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
20039 #endif
20040 }
20041 return pyobj;
20042 }
20043
20044
20045 SWIGINTERN int ART_FOLDER_OPEN_set(PyObject *) {
20046 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER_OPEN is read-only.");
20047 return 1;
20048 }
20049
20050
20051 SWIGINTERN PyObject *ART_FOLDER_OPEN_get(void) {
20052 PyObject *pyobj = 0;
20053
20054 {
20055 #if wxUSE_UNICODE
20056 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
20057 #else
20058 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
20059 #endif
20060 }
20061 return pyobj;
20062 }
20063
20064
20065 SWIGINTERN int ART_GO_DIR_UP_set(PyObject *) {
20066 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DIR_UP is read-only.");
20067 return 1;
20068 }
20069
20070
20071 SWIGINTERN PyObject *ART_GO_DIR_UP_get(void) {
20072 PyObject *pyobj = 0;
20073
20074 {
20075 #if wxUSE_UNICODE
20076 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
20077 #else
20078 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
20079 #endif
20080 }
20081 return pyobj;
20082 }
20083
20084
20085 SWIGINTERN int ART_EXECUTABLE_FILE_set(PyObject *) {
20086 SWIG_Error(SWIG_AttributeError,"Variable ART_EXECUTABLE_FILE is read-only.");
20087 return 1;
20088 }
20089
20090
20091 SWIGINTERN PyObject *ART_EXECUTABLE_FILE_get(void) {
20092 PyObject *pyobj = 0;
20093
20094 {
20095 #if wxUSE_UNICODE
20096 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
20097 #else
20098 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
20099 #endif
20100 }
20101 return pyobj;
20102 }
20103
20104
20105 SWIGINTERN int ART_NORMAL_FILE_set(PyObject *) {
20106 SWIG_Error(SWIG_AttributeError,"Variable ART_NORMAL_FILE is read-only.");
20107 return 1;
20108 }
20109
20110
20111 SWIGINTERN PyObject *ART_NORMAL_FILE_get(void) {
20112 PyObject *pyobj = 0;
20113
20114 {
20115 #if wxUSE_UNICODE
20116 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
20117 #else
20118 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
20119 #endif
20120 }
20121 return pyobj;
20122 }
20123
20124
20125 SWIGINTERN int ART_TICK_MARK_set(PyObject *) {
20126 SWIG_Error(SWIG_AttributeError,"Variable ART_TICK_MARK is read-only.");
20127 return 1;
20128 }
20129
20130
20131 SWIGINTERN PyObject *ART_TICK_MARK_get(void) {
20132 PyObject *pyobj = 0;
20133
20134 {
20135 #if wxUSE_UNICODE
20136 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
20137 #else
20138 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
20139 #endif
20140 }
20141 return pyobj;
20142 }
20143
20144
20145 SWIGINTERN int ART_CROSS_MARK_set(PyObject *) {
20146 SWIG_Error(SWIG_AttributeError,"Variable ART_CROSS_MARK is read-only.");
20147 return 1;
20148 }
20149
20150
20151 SWIGINTERN PyObject *ART_CROSS_MARK_get(void) {
20152 PyObject *pyobj = 0;
20153
20154 {
20155 #if wxUSE_UNICODE
20156 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
20157 #else
20158 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
20159 #endif
20160 }
20161 return pyobj;
20162 }
20163
20164
20165 SWIGINTERN int ART_ERROR_set(PyObject *) {
20166 SWIG_Error(SWIG_AttributeError,"Variable ART_ERROR is read-only.");
20167 return 1;
20168 }
20169
20170
20171 SWIGINTERN PyObject *ART_ERROR_get(void) {
20172 PyObject *pyobj = 0;
20173
20174 {
20175 #if wxUSE_UNICODE
20176 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
20177 #else
20178 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
20179 #endif
20180 }
20181 return pyobj;
20182 }
20183
20184
20185 SWIGINTERN int ART_QUESTION_set(PyObject *) {
20186 SWIG_Error(SWIG_AttributeError,"Variable ART_QUESTION is read-only.");
20187 return 1;
20188 }
20189
20190
20191 SWIGINTERN PyObject *ART_QUESTION_get(void) {
20192 PyObject *pyobj = 0;
20193
20194 {
20195 #if wxUSE_UNICODE
20196 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
20197 #else
20198 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
20199 #endif
20200 }
20201 return pyobj;
20202 }
20203
20204
20205 SWIGINTERN int ART_WARNING_set(PyObject *) {
20206 SWIG_Error(SWIG_AttributeError,"Variable ART_WARNING is read-only.");
20207 return 1;
20208 }
20209
20210
20211 SWIGINTERN PyObject *ART_WARNING_get(void) {
20212 PyObject *pyobj = 0;
20213
20214 {
20215 #if wxUSE_UNICODE
20216 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
20217 #else
20218 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
20219 #endif
20220 }
20221 return pyobj;
20222 }
20223
20224
20225 SWIGINTERN int ART_INFORMATION_set(PyObject *) {
20226 SWIG_Error(SWIG_AttributeError,"Variable ART_INFORMATION is read-only.");
20227 return 1;
20228 }
20229
20230
20231 SWIGINTERN PyObject *ART_INFORMATION_get(void) {
20232 PyObject *pyobj = 0;
20233
20234 {
20235 #if wxUSE_UNICODE
20236 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
20237 #else
20238 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
20239 #endif
20240 }
20241 return pyobj;
20242 }
20243
20244
20245 SWIGINTERN int ART_MISSING_IMAGE_set(PyObject *) {
20246 SWIG_Error(SWIG_AttributeError,"Variable ART_MISSING_IMAGE is read-only.");
20247 return 1;
20248 }
20249
20250
20251 SWIGINTERN PyObject *ART_MISSING_IMAGE_get(void) {
20252 PyObject *pyobj = 0;
20253
20254 {
20255 #if wxUSE_UNICODE
20256 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
20257 #else
20258 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
20259 #endif
20260 }
20261 return pyobj;
20262 }
20263
20264
20265 SWIGINTERN int ART_COPY_set(PyObject *) {
20266 SWIG_Error(SWIG_AttributeError,"Variable ART_COPY is read-only.");
20267 return 1;
20268 }
20269
20270
20271 SWIGINTERN PyObject *ART_COPY_get(void) {
20272 PyObject *pyobj = 0;
20273
20274 {
20275 #if wxUSE_UNICODE
20276 pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
20277 #else
20278 pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
20279 #endif
20280 }
20281 return pyobj;
20282 }
20283
20284
20285 SWIGINTERN int ART_CUT_set(PyObject *) {
20286 SWIG_Error(SWIG_AttributeError,"Variable ART_CUT is read-only.");
20287 return 1;
20288 }
20289
20290
20291 SWIGINTERN PyObject *ART_CUT_get(void) {
20292 PyObject *pyobj = 0;
20293
20294 {
20295 #if wxUSE_UNICODE
20296 pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
20297 #else
20298 pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
20299 #endif
20300 }
20301 return pyobj;
20302 }
20303
20304
20305 SWIGINTERN int ART_PASTE_set(PyObject *) {
20306 SWIG_Error(SWIG_AttributeError,"Variable ART_PASTE is read-only.");
20307 return 1;
20308 }
20309
20310
20311 SWIGINTERN PyObject *ART_PASTE_get(void) {
20312 PyObject *pyobj = 0;
20313
20314 {
20315 #if wxUSE_UNICODE
20316 pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
20317 #else
20318 pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
20319 #endif
20320 }
20321 return pyobj;
20322 }
20323
20324
20325 SWIGINTERN int ART_DELETE_set(PyObject *) {
20326 SWIG_Error(SWIG_AttributeError,"Variable ART_DELETE is read-only.");
20327 return 1;
20328 }
20329
20330
20331 SWIGINTERN PyObject *ART_DELETE_get(void) {
20332 PyObject *pyobj = 0;
20333
20334 {
20335 #if wxUSE_UNICODE
20336 pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
20337 #else
20338 pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
20339 #endif
20340 }
20341 return pyobj;
20342 }
20343
20344
20345 SWIGINTERN int ART_NEW_set(PyObject *) {
20346 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW is read-only.");
20347 return 1;
20348 }
20349
20350
20351 SWIGINTERN PyObject *ART_NEW_get(void) {
20352 PyObject *pyobj = 0;
20353
20354 {
20355 #if wxUSE_UNICODE
20356 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
20357 #else
20358 pyobj = PyString_FromStringAndSize((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
20359 #endif
20360 }
20361 return pyobj;
20362 }
20363
20364
20365 SWIGINTERN int ART_UNDO_set(PyObject *) {
20366 SWIG_Error(SWIG_AttributeError,"Variable ART_UNDO is read-only.");
20367 return 1;
20368 }
20369
20370
20371 SWIGINTERN PyObject *ART_UNDO_get(void) {
20372 PyObject *pyobj = 0;
20373
20374 {
20375 #if wxUSE_UNICODE
20376 pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
20377 #else
20378 pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
20379 #endif
20380 }
20381 return pyobj;
20382 }
20383
20384
20385 SWIGINTERN int ART_REDO_set(PyObject *) {
20386 SWIG_Error(SWIG_AttributeError,"Variable ART_REDO is read-only.");
20387 return 1;
20388 }
20389
20390
20391 SWIGINTERN PyObject *ART_REDO_get(void) {
20392 PyObject *pyobj = 0;
20393
20394 {
20395 #if wxUSE_UNICODE
20396 pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
20397 #else
20398 pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
20399 #endif
20400 }
20401 return pyobj;
20402 }
20403
20404
20405 SWIGINTERN int ART_QUIT_set(PyObject *) {
20406 SWIG_Error(SWIG_AttributeError,"Variable ART_QUIT is read-only.");
20407 return 1;
20408 }
20409
20410
20411 SWIGINTERN PyObject *ART_QUIT_get(void) {
20412 PyObject *pyobj = 0;
20413
20414 {
20415 #if wxUSE_UNICODE
20416 pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
20417 #else
20418 pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
20419 #endif
20420 }
20421 return pyobj;
20422 }
20423
20424
20425 SWIGINTERN int ART_FIND_set(PyObject *) {
20426 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND is read-only.");
20427 return 1;
20428 }
20429
20430
20431 SWIGINTERN PyObject *ART_FIND_get(void) {
20432 PyObject *pyobj = 0;
20433
20434 {
20435 #if wxUSE_UNICODE
20436 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
20437 #else
20438 pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
20439 #endif
20440 }
20441 return pyobj;
20442 }
20443
20444
20445 SWIGINTERN int ART_FIND_AND_REPLACE_set(PyObject *) {
20446 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND_AND_REPLACE is read-only.");
20447 return 1;
20448 }
20449
20450
20451 SWIGINTERN PyObject *ART_FIND_AND_REPLACE_get(void) {
20452 PyObject *pyobj = 0;
20453
20454 {
20455 #if wxUSE_UNICODE
20456 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
20457 #else
20458 pyobj = PyString_FromStringAndSize((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
20459 #endif
20460 }
20461 return pyobj;
20462 }
20463
20464
20465 SWIGINTERN PyObject *_wrap_new_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20466 PyObject *resultobj = 0;
20467 wxPyArtProvider *result = 0 ;
20468
20469 if (!SWIG_Python_UnpackTuple(args,"new_ArtProvider",0,0,0)) SWIG_fail;
20470 {
20471 if (!wxPyCheckForApp()) SWIG_fail;
20472 PyThreadState* __tstate = wxPyBeginAllowThreads();
20473 result = (wxPyArtProvider *)new wxPyArtProvider();
20474 wxPyEndAllowThreads(__tstate);
20475 if (PyErr_Occurred()) SWIG_fail;
20476 }
20477 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_NEW | 0 );
20478 return resultobj;
20479 fail:
20480 return NULL;
20481 }
20482
20483
20484 SWIGINTERN PyObject *_wrap_delete_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20485 PyObject *resultobj = 0;
20486 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20487 void *argp1 = 0 ;
20488 int res1 = 0 ;
20489 PyObject *swig_obj[1] ;
20490
20491 if (!args) SWIG_fail;
20492 swig_obj[0] = args;
20493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
20494 if (!SWIG_IsOK(res1)) {
20495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArtProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20496 }
20497 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20498 {
20499 PyThreadState* __tstate = wxPyBeginAllowThreads();
20500 delete arg1;
20501
20502 wxPyEndAllowThreads(__tstate);
20503 if (PyErr_Occurred()) SWIG_fail;
20504 }
20505 resultobj = SWIG_Py_Void();
20506 return resultobj;
20507 fail:
20508 return NULL;
20509 }
20510
20511
20512 SWIGINTERN PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20513 PyObject *resultobj = 0;
20514 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20515 PyObject *arg2 = (PyObject *) 0 ;
20516 PyObject *arg3 = (PyObject *) 0 ;
20517 void *argp1 = 0 ;
20518 int res1 = 0 ;
20519 PyObject * obj0 = 0 ;
20520 PyObject * obj1 = 0 ;
20521 PyObject * obj2 = 0 ;
20522 char * kwnames[] = {
20523 (char *) "self",(char *) "self",(char *) "_class", NULL
20524 };
20525
20526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20527 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20528 if (!SWIG_IsOK(res1)) {
20529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20530 }
20531 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20532 arg2 = obj1;
20533 arg3 = obj2;
20534 {
20535 PyThreadState* __tstate = wxPyBeginAllowThreads();
20536 (arg1)->_setCallbackInfo(arg2,arg3);
20537 wxPyEndAllowThreads(__tstate);
20538 if (PyErr_Occurred()) SWIG_fail;
20539 }
20540 resultobj = SWIG_Py_Void();
20541 return resultobj;
20542 fail:
20543 return NULL;
20544 }
20545
20546
20547 SWIGINTERN PyObject *_wrap_ArtProvider_Push(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20548 PyObject *resultobj = 0;
20549 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20550 int res1 = 0 ;
20551 PyObject * obj0 = 0 ;
20552 char * kwnames[] = {
20553 (char *) "provider", NULL
20554 };
20555
20556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Push",kwnames,&obj0)) SWIG_fail;
20557 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
20558 if (!SWIG_IsOK(res1)) {
20559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Push" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20560 }
20561 {
20562 PyThreadState* __tstate = wxPyBeginAllowThreads();
20563 wxPyArtProvider::Push(arg1);
20564 wxPyEndAllowThreads(__tstate);
20565 if (PyErr_Occurred()) SWIG_fail;
20566 }
20567 resultobj = SWIG_Py_Void();
20568 return resultobj;
20569 fail:
20570 return NULL;
20571 }
20572
20573
20574 SWIGINTERN PyObject *_wrap_ArtProvider_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20575 PyObject *resultobj = 0;
20576 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20577 int res1 = 0 ;
20578 PyObject * obj0 = 0 ;
20579 char * kwnames[] = {
20580 (char *) "provider", NULL
20581 };
20582
20583 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Insert",kwnames,&obj0)) SWIG_fail;
20584 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
20585 if (!SWIG_IsOK(res1)) {
20586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Insert" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20587 }
20588 {
20589 PyThreadState* __tstate = wxPyBeginAllowThreads();
20590 wxPyArtProvider::Insert(arg1);
20591 wxPyEndAllowThreads(__tstate);
20592 if (PyErr_Occurred()) SWIG_fail;
20593 }
20594 resultobj = SWIG_Py_Void();
20595 return resultobj;
20596 fail:
20597 return NULL;
20598 }
20599
20600
20601 SWIGINTERN PyObject *_wrap_ArtProvider_Pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20602 PyObject *resultobj = 0;
20603 bool result;
20604
20605 if (!SWIG_Python_UnpackTuple(args,"ArtProvider_Pop",0,0,0)) SWIG_fail;
20606 {
20607 PyThreadState* __tstate = wxPyBeginAllowThreads();
20608 result = (bool)wxPyArtProvider::Pop();
20609 wxPyEndAllowThreads(__tstate);
20610 if (PyErr_Occurred()) SWIG_fail;
20611 }
20612 {
20613 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20614 }
20615 return resultobj;
20616 fail:
20617 return NULL;
20618 }
20619
20620
20621 SWIGINTERN PyObject *_wrap_ArtProvider_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20622 PyObject *resultobj = 0;
20623 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20624 bool result;
20625 void *argp1 = 0 ;
20626 int res1 = 0 ;
20627 PyObject * obj0 = 0 ;
20628 char * kwnames[] = {
20629 (char *) "provider", NULL
20630 };
20631
20632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Delete",kwnames,&obj0)) SWIG_fail;
20633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20634 if (!SWIG_IsOK(res1)) {
20635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Delete" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20636 }
20637 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20638 {
20639 PyThreadState* __tstate = wxPyBeginAllowThreads();
20640 result = (bool)wxPyArtProvider::Delete(arg1);
20641 wxPyEndAllowThreads(__tstate);
20642 if (PyErr_Occurred()) SWIG_fail;
20643 }
20644 {
20645 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20646 }
20647 return resultobj;
20648 fail:
20649 return NULL;
20650 }
20651
20652
20653 SWIGINTERN PyObject *_wrap_ArtProvider_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20654 PyObject *resultobj = 0;
20655 wxString *arg1 = 0 ;
20656 wxString const &arg2_defvalue = wxPyART_OTHER ;
20657 wxString *arg2 = (wxString *) &arg2_defvalue ;
20658 wxSize const &arg3_defvalue = wxDefaultSize ;
20659 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
20660 wxBitmap result;
20661 bool temp1 = false ;
20662 bool temp2 = false ;
20663 wxSize temp3 ;
20664 PyObject * obj0 = 0 ;
20665 PyObject * obj1 = 0 ;
20666 PyObject * obj2 = 0 ;
20667 char * kwnames[] = {
20668 (char *) "id",(char *) "client",(char *) "size", NULL
20669 };
20670
20671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20672 {
20673 arg1 = wxString_in_helper(obj0);
20674 if (arg1 == NULL) SWIG_fail;
20675 temp1 = true;
20676 }
20677 if (obj1) {
20678 {
20679 arg2 = wxString_in_helper(obj1);
20680 if (arg2 == NULL) SWIG_fail;
20681 temp2 = true;
20682 }
20683 }
20684 if (obj2) {
20685 {
20686 arg3 = &temp3;
20687 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
20688 }
20689 }
20690 {
20691 if (!wxPyCheckForApp()) SWIG_fail;
20692 PyThreadState* __tstate = wxPyBeginAllowThreads();
20693 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
20694 wxPyEndAllowThreads(__tstate);
20695 if (PyErr_Occurred()) SWIG_fail;
20696 }
20697 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
20698 {
20699 if (temp1)
20700 delete arg1;
20701 }
20702 {
20703 if (temp2)
20704 delete arg2;
20705 }
20706 return resultobj;
20707 fail:
20708 {
20709 if (temp1)
20710 delete arg1;
20711 }
20712 {
20713 if (temp2)
20714 delete arg2;
20715 }
20716 return NULL;
20717 }
20718
20719
20720 SWIGINTERN PyObject *_wrap_ArtProvider_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20721 PyObject *resultobj = 0;
20722 wxString *arg1 = 0 ;
20723 wxString const &arg2_defvalue = wxPyART_OTHER ;
20724 wxString *arg2 = (wxString *) &arg2_defvalue ;
20725 wxSize const &arg3_defvalue = wxDefaultSize ;
20726 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
20727 wxIcon result;
20728 bool temp1 = false ;
20729 bool temp2 = false ;
20730 wxSize temp3 ;
20731 PyObject * obj0 = 0 ;
20732 PyObject * obj1 = 0 ;
20733 PyObject * obj2 = 0 ;
20734 char * kwnames[] = {
20735 (char *) "id",(char *) "client",(char *) "size", NULL
20736 };
20737
20738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20739 {
20740 arg1 = wxString_in_helper(obj0);
20741 if (arg1 == NULL) SWIG_fail;
20742 temp1 = true;
20743 }
20744 if (obj1) {
20745 {
20746 arg2 = wxString_in_helper(obj1);
20747 if (arg2 == NULL) SWIG_fail;
20748 temp2 = true;
20749 }
20750 }
20751 if (obj2) {
20752 {
20753 arg3 = &temp3;
20754 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
20755 }
20756 }
20757 {
20758 if (!wxPyCheckForApp()) SWIG_fail;
20759 PyThreadState* __tstate = wxPyBeginAllowThreads();
20760 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
20761 wxPyEndAllowThreads(__tstate);
20762 if (PyErr_Occurred()) SWIG_fail;
20763 }
20764 resultobj = SWIG_NewPointerObj((new wxIcon(static_cast< const wxIcon& >(result))), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
20765 {
20766 if (temp1)
20767 delete arg1;
20768 }
20769 {
20770 if (temp2)
20771 delete arg2;
20772 }
20773 return resultobj;
20774 fail:
20775 {
20776 if (temp1)
20777 delete arg1;
20778 }
20779 {
20780 if (temp2)
20781 delete arg2;
20782 }
20783 return NULL;
20784 }
20785
20786
20787 SWIGINTERN PyObject *_wrap_ArtProvider_GetSizeHint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20788 PyObject *resultobj = 0;
20789 wxString *arg1 = 0 ;
20790 bool arg2 = (bool) false ;
20791 wxSize result;
20792 bool temp1 = false ;
20793 bool val2 ;
20794 int ecode2 = 0 ;
20795 PyObject * obj0 = 0 ;
20796 PyObject * obj1 = 0 ;
20797 char * kwnames[] = {
20798 (char *) "client",(char *) "platform_dependent", NULL
20799 };
20800
20801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ArtProvider_GetSizeHint",kwnames,&obj0,&obj1)) SWIG_fail;
20802 {
20803 arg1 = wxString_in_helper(obj0);
20804 if (arg1 == NULL) SWIG_fail;
20805 temp1 = true;
20806 }
20807 if (obj1) {
20808 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20809 if (!SWIG_IsOK(ecode2)) {
20810 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ArtProvider_GetSizeHint" "', expected argument " "2"" of type '" "bool""'");
20811 }
20812 arg2 = static_cast< bool >(val2);
20813 }
20814 {
20815 PyThreadState* __tstate = wxPyBeginAllowThreads();
20816 result = wxPyArtProvider::GetSizeHint((wxString const &)*arg1,arg2);
20817 wxPyEndAllowThreads(__tstate);
20818 if (PyErr_Occurred()) SWIG_fail;
20819 }
20820 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
20821 {
20822 if (temp1)
20823 delete arg1;
20824 }
20825 return resultobj;
20826 fail:
20827 {
20828 if (temp1)
20829 delete arg1;
20830 }
20831 return NULL;
20832 }
20833
20834
20835 SWIGINTERN PyObject *_wrap_ArtProvider_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20836 PyObject *resultobj = 0;
20837 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20838 void *argp1 = 0 ;
20839 int res1 = 0 ;
20840 PyObject *swig_obj[1] ;
20841
20842 if (!args) SWIG_fail;
20843 swig_obj[0] = args;
20844 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20845 if (!SWIG_IsOK(res1)) {
20846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Destroy" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20847 }
20848 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20849 {
20850 PyThreadState* __tstate = wxPyBeginAllowThreads();
20851 wxPyArtProvider_Destroy(arg1);
20852 wxPyEndAllowThreads(__tstate);
20853 if (PyErr_Occurred()) SWIG_fail;
20854 }
20855 resultobj = SWIG_Py_Void();
20856 return resultobj;
20857 fail:
20858 return NULL;
20859 }
20860
20861
20862 SWIGINTERN PyObject *ArtProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20863 PyObject *obj;
20864 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20865 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyArtProvider, SWIG_NewClientData(obj));
20866 return SWIG_Py_Void();
20867 }
20868
20869 SWIGINTERN PyObject *ArtProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20870 return SWIG_Python_InitShadowInstance(args);
20871 }
20872
20873 SWIGINTERN PyObject *_wrap_delete_ConfigBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20874 PyObject *resultobj = 0;
20875 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20876 void *argp1 = 0 ;
20877 int res1 = 0 ;
20878 PyObject *swig_obj[1] ;
20879
20880 if (!args) SWIG_fail;
20881 swig_obj[0] = args;
20882 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
20883 if (!SWIG_IsOK(res1)) {
20884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigBase" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20885 }
20886 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20887 {
20888 PyThreadState* __tstate = wxPyBeginAllowThreads();
20889 delete arg1;
20890
20891 wxPyEndAllowThreads(__tstate);
20892 if (PyErr_Occurred()) SWIG_fail;
20893 }
20894 resultobj = SWIG_Py_Void();
20895 return resultobj;
20896 fail:
20897 return NULL;
20898 }
20899
20900
20901 SWIGINTERN PyObject *_wrap_ConfigBase_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20902 PyObject *resultobj = 0;
20903 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20904 wxConfigBase *result = 0 ;
20905 int res1 = 0 ;
20906 PyObject * obj0 = 0 ;
20907 char * kwnames[] = {
20908 (char *) "config", NULL
20909 };
20910
20911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) SWIG_fail;
20912 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
20913 if (!SWIG_IsOK(res1)) {
20914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Set" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20915 }
20916 {
20917 PyThreadState* __tstate = wxPyBeginAllowThreads();
20918 result = (wxConfigBase *)wxConfigBase::Set(arg1);
20919 wxPyEndAllowThreads(__tstate);
20920 if (PyErr_Occurred()) SWIG_fail;
20921 }
20922 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
20923 return resultobj;
20924 fail:
20925 return NULL;
20926 }
20927
20928
20929 SWIGINTERN PyObject *_wrap_ConfigBase_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20930 PyObject *resultobj = 0;
20931 bool arg1 = (bool) true ;
20932 wxConfigBase *result = 0 ;
20933 bool val1 ;
20934 int ecode1 = 0 ;
20935 PyObject * obj0 = 0 ;
20936 char * kwnames[] = {
20937 (char *) "createOnDemand", NULL
20938 };
20939
20940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) SWIG_fail;
20941 if (obj0) {
20942 ecode1 = SWIG_AsVal_bool(obj0, &val1);
20943 if (!SWIG_IsOK(ecode1)) {
20944 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ConfigBase_Get" "', expected argument " "1"" of type '" "bool""'");
20945 }
20946 arg1 = static_cast< bool >(val1);
20947 }
20948 {
20949 PyThreadState* __tstate = wxPyBeginAllowThreads();
20950 result = (wxConfigBase *)wxConfigBase::Get(arg1);
20951 wxPyEndAllowThreads(__tstate);
20952 if (PyErr_Occurred()) SWIG_fail;
20953 }
20954 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
20955 return resultobj;
20956 fail:
20957 return NULL;
20958 }
20959
20960
20961 SWIGINTERN PyObject *_wrap_ConfigBase_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20962 PyObject *resultobj = 0;
20963 wxConfigBase *result = 0 ;
20964
20965 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_Create",0,0,0)) SWIG_fail;
20966 {
20967 PyThreadState* __tstate = wxPyBeginAllowThreads();
20968 result = (wxConfigBase *)wxConfigBase::Create();
20969 wxPyEndAllowThreads(__tstate);
20970 if (PyErr_Occurred()) SWIG_fail;
20971 }
20972 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
20973 return resultobj;
20974 fail:
20975 return NULL;
20976 }
20977
20978
20979 SWIGINTERN PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20980 PyObject *resultobj = 0;
20981
20982 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_DontCreateOnDemand",0,0,0)) SWIG_fail;
20983 {
20984 PyThreadState* __tstate = wxPyBeginAllowThreads();
20985 wxConfigBase::DontCreateOnDemand();
20986 wxPyEndAllowThreads(__tstate);
20987 if (PyErr_Occurred()) SWIG_fail;
20988 }
20989 resultobj = SWIG_Py_Void();
20990 return resultobj;
20991 fail:
20992 return NULL;
20993 }
20994
20995
20996 SWIGINTERN PyObject *_wrap_ConfigBase_SetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20997 PyObject *resultobj = 0;
20998 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20999 wxString *arg2 = 0 ;
21000 void *argp1 = 0 ;
21001 int res1 = 0 ;
21002 bool temp2 = false ;
21003 PyObject * obj0 = 0 ;
21004 PyObject * obj1 = 0 ;
21005 char * kwnames[] = {
21006 (char *) "self",(char *) "path", NULL
21007 };
21008
21009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) SWIG_fail;
21010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21011 if (!SWIG_IsOK(res1)) {
21012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetPath" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21013 }
21014 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21015 {
21016 arg2 = wxString_in_helper(obj1);
21017 if (arg2 == NULL) SWIG_fail;
21018 temp2 = true;
21019 }
21020 {
21021 PyThreadState* __tstate = wxPyBeginAllowThreads();
21022 (arg1)->SetPath((wxString const &)*arg2);
21023 wxPyEndAllowThreads(__tstate);
21024 if (PyErr_Occurred()) SWIG_fail;
21025 }
21026 resultobj = SWIG_Py_Void();
21027 {
21028 if (temp2)
21029 delete arg2;
21030 }
21031 return resultobj;
21032 fail:
21033 {
21034 if (temp2)
21035 delete arg2;
21036 }
21037 return NULL;
21038 }
21039
21040
21041 SWIGINTERN PyObject *_wrap_ConfigBase_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21042 PyObject *resultobj = 0;
21043 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21044 wxString *result = 0 ;
21045 void *argp1 = 0 ;
21046 int res1 = 0 ;
21047 PyObject *swig_obj[1] ;
21048
21049 if (!args) SWIG_fail;
21050 swig_obj[0] = args;
21051 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21052 if (!SWIG_IsOK(res1)) {
21053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetPath" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21054 }
21055 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21056 {
21057 PyThreadState* __tstate = wxPyBeginAllowThreads();
21058 {
21059 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
21060 result = (wxString *) &_result_ref;
21061 }
21062 wxPyEndAllowThreads(__tstate);
21063 if (PyErr_Occurred()) SWIG_fail;
21064 }
21065 {
21066 #if wxUSE_UNICODE
21067 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
21068 #else
21069 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
21070 #endif
21071 }
21072 return resultobj;
21073 fail:
21074 return NULL;
21075 }
21076
21077
21078 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21079 PyObject *resultobj = 0;
21080 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21081 PyObject *result = 0 ;
21082 void *argp1 = 0 ;
21083 int res1 = 0 ;
21084 PyObject *swig_obj[1] ;
21085
21086 if (!args) SWIG_fail;
21087 swig_obj[0] = args;
21088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21089 if (!SWIG_IsOK(res1)) {
21090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21091 }
21092 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21093 {
21094 PyThreadState* __tstate = wxPyBeginAllowThreads();
21095 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
21096 wxPyEndAllowThreads(__tstate);
21097 if (PyErr_Occurred()) SWIG_fail;
21098 }
21099 resultobj = result;
21100 return resultobj;
21101 fail:
21102 return NULL;
21103 }
21104
21105
21106 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21107 PyObject *resultobj = 0;
21108 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21109 long arg2 ;
21110 PyObject *result = 0 ;
21111 void *argp1 = 0 ;
21112 int res1 = 0 ;
21113 long val2 ;
21114 int ecode2 = 0 ;
21115 PyObject * obj0 = 0 ;
21116 PyObject * obj1 = 0 ;
21117 char * kwnames[] = {
21118 (char *) "self",(char *) "index", NULL
21119 };
21120
21121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) SWIG_fail;
21122 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21123 if (!SWIG_IsOK(res1)) {
21124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21125 }
21126 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21127 ecode2 = SWIG_AsVal_long(obj1, &val2);
21128 if (!SWIG_IsOK(ecode2)) {
21129 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "2"" of type '" "long""'");
21130 }
21131 arg2 = static_cast< long >(val2);
21132 {
21133 PyThreadState* __tstate = wxPyBeginAllowThreads();
21134 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
21135 wxPyEndAllowThreads(__tstate);
21136 if (PyErr_Occurred()) SWIG_fail;
21137 }
21138 resultobj = result;
21139 return resultobj;
21140 fail:
21141 return NULL;
21142 }
21143
21144
21145 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21146 PyObject *resultobj = 0;
21147 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21148 PyObject *result = 0 ;
21149 void *argp1 = 0 ;
21150 int res1 = 0 ;
21151 PyObject *swig_obj[1] ;
21152
21153 if (!args) SWIG_fail;
21154 swig_obj[0] = args;
21155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21156 if (!SWIG_IsOK(res1)) {
21157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21158 }
21159 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21160 {
21161 PyThreadState* __tstate = wxPyBeginAllowThreads();
21162 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
21163 wxPyEndAllowThreads(__tstate);
21164 if (PyErr_Occurred()) SWIG_fail;
21165 }
21166 resultobj = result;
21167 return resultobj;
21168 fail:
21169 return NULL;
21170 }
21171
21172
21173 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21174 PyObject *resultobj = 0;
21175 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21176 long arg2 ;
21177 PyObject *result = 0 ;
21178 void *argp1 = 0 ;
21179 int res1 = 0 ;
21180 long val2 ;
21181 int ecode2 = 0 ;
21182 PyObject * obj0 = 0 ;
21183 PyObject * obj1 = 0 ;
21184 char * kwnames[] = {
21185 (char *) "self",(char *) "index", NULL
21186 };
21187
21188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) SWIG_fail;
21189 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21190 if (!SWIG_IsOK(res1)) {
21191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21192 }
21193 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21194 ecode2 = SWIG_AsVal_long(obj1, &val2);
21195 if (!SWIG_IsOK(ecode2)) {
21196 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "2"" of type '" "long""'");
21197 }
21198 arg2 = static_cast< long >(val2);
21199 {
21200 PyThreadState* __tstate = wxPyBeginAllowThreads();
21201 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
21202 wxPyEndAllowThreads(__tstate);
21203 if (PyErr_Occurred()) SWIG_fail;
21204 }
21205 resultobj = result;
21206 return resultobj;
21207 fail:
21208 return NULL;
21209 }
21210
21211
21212 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21213 PyObject *resultobj = 0;
21214 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21215 bool arg2 = (bool) false ;
21216 size_t result;
21217 void *argp1 = 0 ;
21218 int res1 = 0 ;
21219 bool val2 ;
21220 int ecode2 = 0 ;
21221 PyObject * obj0 = 0 ;
21222 PyObject * obj1 = 0 ;
21223 char * kwnames[] = {
21224 (char *) "self",(char *) "recursive", NULL
21225 };
21226
21227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) SWIG_fail;
21228 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21229 if (!SWIG_IsOK(res1)) {
21230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21231 }
21232 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21233 if (obj1) {
21234 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21235 if (!SWIG_IsOK(ecode2)) {
21236 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "2"" of type '" "bool""'");
21237 }
21238 arg2 = static_cast< bool >(val2);
21239 }
21240 {
21241 PyThreadState* __tstate = wxPyBeginAllowThreads();
21242 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
21243 wxPyEndAllowThreads(__tstate);
21244 if (PyErr_Occurred()) SWIG_fail;
21245 }
21246 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
21247 return resultobj;
21248 fail:
21249 return NULL;
21250 }
21251
21252
21253 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21254 PyObject *resultobj = 0;
21255 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21256 bool arg2 = (bool) false ;
21257 size_t result;
21258 void *argp1 = 0 ;
21259 int res1 = 0 ;
21260 bool val2 ;
21261 int ecode2 = 0 ;
21262 PyObject * obj0 = 0 ;
21263 PyObject * obj1 = 0 ;
21264 char * kwnames[] = {
21265 (char *) "self",(char *) "recursive", NULL
21266 };
21267
21268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) SWIG_fail;
21269 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21270 if (!SWIG_IsOK(res1)) {
21271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21272 }
21273 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21274 if (obj1) {
21275 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21276 if (!SWIG_IsOK(ecode2)) {
21277 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "2"" of type '" "bool""'");
21278 }
21279 arg2 = static_cast< bool >(val2);
21280 }
21281 {
21282 PyThreadState* __tstate = wxPyBeginAllowThreads();
21283 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
21284 wxPyEndAllowThreads(__tstate);
21285 if (PyErr_Occurred()) SWIG_fail;
21286 }
21287 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
21288 return resultobj;
21289 fail:
21290 return NULL;
21291 }
21292
21293
21294 SWIGINTERN PyObject *_wrap_ConfigBase_HasGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21295 PyObject *resultobj = 0;
21296 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21297 wxString *arg2 = 0 ;
21298 bool result;
21299 void *argp1 = 0 ;
21300 int res1 = 0 ;
21301 bool temp2 = false ;
21302 PyObject * obj0 = 0 ;
21303 PyObject * obj1 = 0 ;
21304 char * kwnames[] = {
21305 (char *) "self",(char *) "name", NULL
21306 };
21307
21308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) SWIG_fail;
21309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21310 if (!SWIG_IsOK(res1)) {
21311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasGroup" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21312 }
21313 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21314 {
21315 arg2 = wxString_in_helper(obj1);
21316 if (arg2 == NULL) SWIG_fail;
21317 temp2 = true;
21318 }
21319 {
21320 PyThreadState* __tstate = wxPyBeginAllowThreads();
21321 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
21322 wxPyEndAllowThreads(__tstate);
21323 if (PyErr_Occurred()) SWIG_fail;
21324 }
21325 {
21326 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21327 }
21328 {
21329 if (temp2)
21330 delete arg2;
21331 }
21332 return resultobj;
21333 fail:
21334 {
21335 if (temp2)
21336 delete arg2;
21337 }
21338 return NULL;
21339 }
21340
21341
21342 SWIGINTERN PyObject *_wrap_ConfigBase_HasEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21343 PyObject *resultobj = 0;
21344 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21345 wxString *arg2 = 0 ;
21346 bool result;
21347 void *argp1 = 0 ;
21348 int res1 = 0 ;
21349 bool temp2 = false ;
21350 PyObject * obj0 = 0 ;
21351 PyObject * obj1 = 0 ;
21352 char * kwnames[] = {
21353 (char *) "self",(char *) "name", NULL
21354 };
21355
21356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) SWIG_fail;
21357 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21358 if (!SWIG_IsOK(res1)) {
21359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasEntry" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21360 }
21361 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21362 {
21363 arg2 = wxString_in_helper(obj1);
21364 if (arg2 == NULL) SWIG_fail;
21365 temp2 = true;
21366 }
21367 {
21368 PyThreadState* __tstate = wxPyBeginAllowThreads();
21369 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
21370 wxPyEndAllowThreads(__tstate);
21371 if (PyErr_Occurred()) SWIG_fail;
21372 }
21373 {
21374 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21375 }
21376 {
21377 if (temp2)
21378 delete arg2;
21379 }
21380 return resultobj;
21381 fail:
21382 {
21383 if (temp2)
21384 delete arg2;
21385 }
21386 return NULL;
21387 }
21388
21389
21390 SWIGINTERN PyObject *_wrap_ConfigBase_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21391 PyObject *resultobj = 0;
21392 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21393 wxString *arg2 = 0 ;
21394 bool result;
21395 void *argp1 = 0 ;
21396 int res1 = 0 ;
21397 bool temp2 = false ;
21398 PyObject * obj0 = 0 ;
21399 PyObject * obj1 = 0 ;
21400 char * kwnames[] = {
21401 (char *) "self",(char *) "name", NULL
21402 };
21403
21404 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) SWIG_fail;
21405 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21406 if (!SWIG_IsOK(res1)) {
21407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Exists" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21408 }
21409 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21410 {
21411 arg2 = wxString_in_helper(obj1);
21412 if (arg2 == NULL) SWIG_fail;
21413 temp2 = true;
21414 }
21415 {
21416 PyThreadState* __tstate = wxPyBeginAllowThreads();
21417 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
21418 wxPyEndAllowThreads(__tstate);
21419 if (PyErr_Occurred()) SWIG_fail;
21420 }
21421 {
21422 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21423 }
21424 {
21425 if (temp2)
21426 delete arg2;
21427 }
21428 return resultobj;
21429 fail:
21430 {
21431 if (temp2)
21432 delete arg2;
21433 }
21434 return NULL;
21435 }
21436
21437
21438 SWIGINTERN PyObject *_wrap_ConfigBase_GetEntryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21439 PyObject *resultobj = 0;
21440 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21441 wxString *arg2 = 0 ;
21442 wxConfigBase::EntryType result;
21443 void *argp1 = 0 ;
21444 int res1 = 0 ;
21445 bool temp2 = false ;
21446 PyObject * obj0 = 0 ;
21447 PyObject * obj1 = 0 ;
21448 char * kwnames[] = {
21449 (char *) "self",(char *) "name", NULL
21450 };
21451
21452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) SWIG_fail;
21453 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21454 if (!SWIG_IsOK(res1)) {
21455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetEntryType" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21456 }
21457 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21458 {
21459 arg2 = wxString_in_helper(obj1);
21460 if (arg2 == NULL) SWIG_fail;
21461 temp2 = true;
21462 }
21463 {
21464 PyThreadState* __tstate = wxPyBeginAllowThreads();
21465 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
21466 wxPyEndAllowThreads(__tstate);
21467 if (PyErr_Occurred()) SWIG_fail;
21468 }
21469 resultobj = SWIG_From_int(static_cast< int >(result));
21470 {
21471 if (temp2)
21472 delete arg2;
21473 }
21474 return resultobj;
21475 fail:
21476 {
21477 if (temp2)
21478 delete arg2;
21479 }
21480 return NULL;
21481 }
21482
21483
21484 SWIGINTERN PyObject *_wrap_ConfigBase_Read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21485 PyObject *resultobj = 0;
21486 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21487 wxString *arg2 = 0 ;
21488 wxString const &arg3_defvalue = wxPyEmptyString ;
21489 wxString *arg3 = (wxString *) &arg3_defvalue ;
21490 wxString result;
21491 void *argp1 = 0 ;
21492 int res1 = 0 ;
21493 bool temp2 = false ;
21494 bool temp3 = false ;
21495 PyObject * obj0 = 0 ;
21496 PyObject * obj1 = 0 ;
21497 PyObject * obj2 = 0 ;
21498 char * kwnames[] = {
21499 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21500 };
21501
21502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21503 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21504 if (!SWIG_IsOK(res1)) {
21505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Read" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21506 }
21507 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21508 {
21509 arg2 = wxString_in_helper(obj1);
21510 if (arg2 == NULL) SWIG_fail;
21511 temp2 = true;
21512 }
21513 if (obj2) {
21514 {
21515 arg3 = wxString_in_helper(obj2);
21516 if (arg3 == NULL) SWIG_fail;
21517 temp3 = true;
21518 }
21519 }
21520 {
21521 PyThreadState* __tstate = wxPyBeginAllowThreads();
21522 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
21523 wxPyEndAllowThreads(__tstate);
21524 if (PyErr_Occurred()) SWIG_fail;
21525 }
21526 {
21527 #if wxUSE_UNICODE
21528 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21529 #else
21530 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21531 #endif
21532 }
21533 {
21534 if (temp2)
21535 delete arg2;
21536 }
21537 {
21538 if (temp3)
21539 delete arg3;
21540 }
21541 return resultobj;
21542 fail:
21543 {
21544 if (temp2)
21545 delete arg2;
21546 }
21547 {
21548 if (temp3)
21549 delete arg3;
21550 }
21551 return NULL;
21552 }
21553
21554
21555 SWIGINTERN PyObject *_wrap_ConfigBase_ReadInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21556 PyObject *resultobj = 0;
21557 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21558 wxString *arg2 = 0 ;
21559 long arg3 = (long) 0 ;
21560 long result;
21561 void *argp1 = 0 ;
21562 int res1 = 0 ;
21563 bool temp2 = false ;
21564 long val3 ;
21565 int ecode3 = 0 ;
21566 PyObject * obj0 = 0 ;
21567 PyObject * obj1 = 0 ;
21568 PyObject * obj2 = 0 ;
21569 char * kwnames[] = {
21570 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21571 };
21572
21573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21575 if (!SWIG_IsOK(res1)) {
21576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21577 }
21578 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21579 {
21580 arg2 = wxString_in_helper(obj1);
21581 if (arg2 == NULL) SWIG_fail;
21582 temp2 = true;
21583 }
21584 if (obj2) {
21585 ecode3 = SWIG_AsVal_long(obj2, &val3);
21586 if (!SWIG_IsOK(ecode3)) {
21587 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadInt" "', expected argument " "3"" of type '" "long""'");
21588 }
21589 arg3 = static_cast< long >(val3);
21590 }
21591 {
21592 PyThreadState* __tstate = wxPyBeginAllowThreads();
21593 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
21594 wxPyEndAllowThreads(__tstate);
21595 if (PyErr_Occurred()) SWIG_fail;
21596 }
21597 resultobj = SWIG_From_long(static_cast< long >(result));
21598 {
21599 if (temp2)
21600 delete arg2;
21601 }
21602 return resultobj;
21603 fail:
21604 {
21605 if (temp2)
21606 delete arg2;
21607 }
21608 return NULL;
21609 }
21610
21611
21612 SWIGINTERN PyObject *_wrap_ConfigBase_ReadFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21613 PyObject *resultobj = 0;
21614 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21615 wxString *arg2 = 0 ;
21616 double arg3 = (double) 0.0 ;
21617 double result;
21618 void *argp1 = 0 ;
21619 int res1 = 0 ;
21620 bool temp2 = false ;
21621 double val3 ;
21622 int ecode3 = 0 ;
21623 PyObject * obj0 = 0 ;
21624 PyObject * obj1 = 0 ;
21625 PyObject * obj2 = 0 ;
21626 char * kwnames[] = {
21627 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21628 };
21629
21630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21631 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21632 if (!SWIG_IsOK(res1)) {
21633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21634 }
21635 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21636 {
21637 arg2 = wxString_in_helper(obj1);
21638 if (arg2 == NULL) SWIG_fail;
21639 temp2 = true;
21640 }
21641 if (obj2) {
21642 ecode3 = SWIG_AsVal_double(obj2, &val3);
21643 if (!SWIG_IsOK(ecode3)) {
21644 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadFloat" "', expected argument " "3"" of type '" "double""'");
21645 }
21646 arg3 = static_cast< double >(val3);
21647 }
21648 {
21649 PyThreadState* __tstate = wxPyBeginAllowThreads();
21650 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
21651 wxPyEndAllowThreads(__tstate);
21652 if (PyErr_Occurred()) SWIG_fail;
21653 }
21654 resultobj = SWIG_From_double(static_cast< double >(result));
21655 {
21656 if (temp2)
21657 delete arg2;
21658 }
21659 return resultobj;
21660 fail:
21661 {
21662 if (temp2)
21663 delete arg2;
21664 }
21665 return NULL;
21666 }
21667
21668
21669 SWIGINTERN PyObject *_wrap_ConfigBase_ReadBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21670 PyObject *resultobj = 0;
21671 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21672 wxString *arg2 = 0 ;
21673 bool arg3 = (bool) false ;
21674 bool result;
21675 void *argp1 = 0 ;
21676 int res1 = 0 ;
21677 bool temp2 = false ;
21678 bool val3 ;
21679 int ecode3 = 0 ;
21680 PyObject * obj0 = 0 ;
21681 PyObject * obj1 = 0 ;
21682 PyObject * obj2 = 0 ;
21683 char * kwnames[] = {
21684 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21685 };
21686
21687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21688 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21689 if (!SWIG_IsOK(res1)) {
21690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21691 }
21692 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21693 {
21694 arg2 = wxString_in_helper(obj1);
21695 if (arg2 == NULL) SWIG_fail;
21696 temp2 = true;
21697 }
21698 if (obj2) {
21699 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21700 if (!SWIG_IsOK(ecode3)) {
21701 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadBool" "', expected argument " "3"" of type '" "bool""'");
21702 }
21703 arg3 = static_cast< bool >(val3);
21704 }
21705 {
21706 PyThreadState* __tstate = wxPyBeginAllowThreads();
21707 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
21708 wxPyEndAllowThreads(__tstate);
21709 if (PyErr_Occurred()) SWIG_fail;
21710 }
21711 {
21712 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21713 }
21714 {
21715 if (temp2)
21716 delete arg2;
21717 }
21718 return resultobj;
21719 fail:
21720 {
21721 if (temp2)
21722 delete arg2;
21723 }
21724 return NULL;
21725 }
21726
21727
21728 SWIGINTERN PyObject *_wrap_ConfigBase_Write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21729 PyObject *resultobj = 0;
21730 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21731 wxString *arg2 = 0 ;
21732 wxString *arg3 = 0 ;
21733 bool result;
21734 void *argp1 = 0 ;
21735 int res1 = 0 ;
21736 bool temp2 = false ;
21737 bool temp3 = false ;
21738 PyObject * obj0 = 0 ;
21739 PyObject * obj1 = 0 ;
21740 PyObject * obj2 = 0 ;
21741 char * kwnames[] = {
21742 (char *) "self",(char *) "key",(char *) "value", NULL
21743 };
21744
21745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21746 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21747 if (!SWIG_IsOK(res1)) {
21748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Write" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21749 }
21750 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21751 {
21752 arg2 = wxString_in_helper(obj1);
21753 if (arg2 == NULL) SWIG_fail;
21754 temp2 = true;
21755 }
21756 {
21757 arg3 = wxString_in_helper(obj2);
21758 if (arg3 == NULL) SWIG_fail;
21759 temp3 = true;
21760 }
21761 {
21762 PyThreadState* __tstate = wxPyBeginAllowThreads();
21763 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
21764 wxPyEndAllowThreads(__tstate);
21765 if (PyErr_Occurred()) SWIG_fail;
21766 }
21767 {
21768 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21769 }
21770 {
21771 if (temp2)
21772 delete arg2;
21773 }
21774 {
21775 if (temp3)
21776 delete arg3;
21777 }
21778 return resultobj;
21779 fail:
21780 {
21781 if (temp2)
21782 delete arg2;
21783 }
21784 {
21785 if (temp3)
21786 delete arg3;
21787 }
21788 return NULL;
21789 }
21790
21791
21792 SWIGINTERN PyObject *_wrap_ConfigBase_WriteInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21793 PyObject *resultobj = 0;
21794 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21795 wxString *arg2 = 0 ;
21796 long arg3 ;
21797 bool result;
21798 void *argp1 = 0 ;
21799 int res1 = 0 ;
21800 bool temp2 = false ;
21801 long val3 ;
21802 int ecode3 = 0 ;
21803 PyObject * obj0 = 0 ;
21804 PyObject * obj1 = 0 ;
21805 PyObject * obj2 = 0 ;
21806 char * kwnames[] = {
21807 (char *) "self",(char *) "key",(char *) "value", NULL
21808 };
21809
21810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21811 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21812 if (!SWIG_IsOK(res1)) {
21813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21814 }
21815 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21816 {
21817 arg2 = wxString_in_helper(obj1);
21818 if (arg2 == NULL) SWIG_fail;
21819 temp2 = true;
21820 }
21821 ecode3 = SWIG_AsVal_long(obj2, &val3);
21822 if (!SWIG_IsOK(ecode3)) {
21823 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteInt" "', expected argument " "3"" of type '" "long""'");
21824 }
21825 arg3 = static_cast< long >(val3);
21826 {
21827 PyThreadState* __tstate = wxPyBeginAllowThreads();
21828 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21829 wxPyEndAllowThreads(__tstate);
21830 if (PyErr_Occurred()) SWIG_fail;
21831 }
21832 {
21833 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21834 }
21835 {
21836 if (temp2)
21837 delete arg2;
21838 }
21839 return resultobj;
21840 fail:
21841 {
21842 if (temp2)
21843 delete arg2;
21844 }
21845 return NULL;
21846 }
21847
21848
21849 SWIGINTERN PyObject *_wrap_ConfigBase_WriteFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21850 PyObject *resultobj = 0;
21851 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21852 wxString *arg2 = 0 ;
21853 double arg3 ;
21854 bool result;
21855 void *argp1 = 0 ;
21856 int res1 = 0 ;
21857 bool temp2 = false ;
21858 double val3 ;
21859 int ecode3 = 0 ;
21860 PyObject * obj0 = 0 ;
21861 PyObject * obj1 = 0 ;
21862 PyObject * obj2 = 0 ;
21863 char * kwnames[] = {
21864 (char *) "self",(char *) "key",(char *) "value", NULL
21865 };
21866
21867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21869 if (!SWIG_IsOK(res1)) {
21870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21871 }
21872 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21873 {
21874 arg2 = wxString_in_helper(obj1);
21875 if (arg2 == NULL) SWIG_fail;
21876 temp2 = true;
21877 }
21878 ecode3 = SWIG_AsVal_double(obj2, &val3);
21879 if (!SWIG_IsOK(ecode3)) {
21880 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteFloat" "', expected argument " "3"" of type '" "double""'");
21881 }
21882 arg3 = static_cast< double >(val3);
21883 {
21884 PyThreadState* __tstate = wxPyBeginAllowThreads();
21885 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21886 wxPyEndAllowThreads(__tstate);
21887 if (PyErr_Occurred()) SWIG_fail;
21888 }
21889 {
21890 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21891 }
21892 {
21893 if (temp2)
21894 delete arg2;
21895 }
21896 return resultobj;
21897 fail:
21898 {
21899 if (temp2)
21900 delete arg2;
21901 }
21902 return NULL;
21903 }
21904
21905
21906 SWIGINTERN PyObject *_wrap_ConfigBase_WriteBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21907 PyObject *resultobj = 0;
21908 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21909 wxString *arg2 = 0 ;
21910 bool arg3 ;
21911 bool result;
21912 void *argp1 = 0 ;
21913 int res1 = 0 ;
21914 bool temp2 = false ;
21915 bool val3 ;
21916 int ecode3 = 0 ;
21917 PyObject * obj0 = 0 ;
21918 PyObject * obj1 = 0 ;
21919 PyObject * obj2 = 0 ;
21920 char * kwnames[] = {
21921 (char *) "self",(char *) "key",(char *) "value", NULL
21922 };
21923
21924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21926 if (!SWIG_IsOK(res1)) {
21927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21928 }
21929 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21930 {
21931 arg2 = wxString_in_helper(obj1);
21932 if (arg2 == NULL) SWIG_fail;
21933 temp2 = true;
21934 }
21935 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21936 if (!SWIG_IsOK(ecode3)) {
21937 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteBool" "', expected argument " "3"" of type '" "bool""'");
21938 }
21939 arg3 = static_cast< bool >(val3);
21940 {
21941 PyThreadState* __tstate = wxPyBeginAllowThreads();
21942 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21943 wxPyEndAllowThreads(__tstate);
21944 if (PyErr_Occurred()) SWIG_fail;
21945 }
21946 {
21947 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21948 }
21949 {
21950 if (temp2)
21951 delete arg2;
21952 }
21953 return resultobj;
21954 fail:
21955 {
21956 if (temp2)
21957 delete arg2;
21958 }
21959 return NULL;
21960 }
21961
21962
21963 SWIGINTERN PyObject *_wrap_ConfigBase_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21964 PyObject *resultobj = 0;
21965 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21966 bool arg2 = (bool) false ;
21967 bool result;
21968 void *argp1 = 0 ;
21969 int res1 = 0 ;
21970 bool val2 ;
21971 int ecode2 = 0 ;
21972 PyObject * obj0 = 0 ;
21973 PyObject * obj1 = 0 ;
21974 char * kwnames[] = {
21975 (char *) "self",(char *) "currentOnly", NULL
21976 };
21977
21978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) SWIG_fail;
21979 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21980 if (!SWIG_IsOK(res1)) {
21981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Flush" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21982 }
21983 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21984 if (obj1) {
21985 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21986 if (!SWIG_IsOK(ecode2)) {
21987 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_Flush" "', expected argument " "2"" of type '" "bool""'");
21988 }
21989 arg2 = static_cast< bool >(val2);
21990 }
21991 {
21992 PyThreadState* __tstate = wxPyBeginAllowThreads();
21993 result = (bool)(arg1)->Flush(arg2);
21994 wxPyEndAllowThreads(__tstate);
21995 if (PyErr_Occurred()) SWIG_fail;
21996 }
21997 {
21998 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21999 }
22000 return resultobj;
22001 fail:
22002 return NULL;
22003 }
22004
22005
22006 SWIGINTERN PyObject *_wrap_ConfigBase_RenameEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22007 PyObject *resultobj = 0;
22008 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22009 wxString *arg2 = 0 ;
22010 wxString *arg3 = 0 ;
22011 bool result;
22012 void *argp1 = 0 ;
22013 int res1 = 0 ;
22014 bool temp2 = false ;
22015 bool temp3 = false ;
22016 PyObject * obj0 = 0 ;
22017 PyObject * obj1 = 0 ;
22018 PyObject * obj2 = 0 ;
22019 char * kwnames[] = {
22020 (char *) "self",(char *) "oldName",(char *) "newName", NULL
22021 };
22022
22023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22025 if (!SWIG_IsOK(res1)) {
22026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22027 }
22028 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22029 {
22030 arg2 = wxString_in_helper(obj1);
22031 if (arg2 == NULL) SWIG_fail;
22032 temp2 = true;
22033 }
22034 {
22035 arg3 = wxString_in_helper(obj2);
22036 if (arg3 == NULL) SWIG_fail;
22037 temp3 = true;
22038 }
22039 {
22040 PyThreadState* __tstate = wxPyBeginAllowThreads();
22041 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
22042 wxPyEndAllowThreads(__tstate);
22043 if (PyErr_Occurred()) SWIG_fail;
22044 }
22045 {
22046 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22047 }
22048 {
22049 if (temp2)
22050 delete arg2;
22051 }
22052 {
22053 if (temp3)
22054 delete arg3;
22055 }
22056 return resultobj;
22057 fail:
22058 {
22059 if (temp2)
22060 delete arg2;
22061 }
22062 {
22063 if (temp3)
22064 delete arg3;
22065 }
22066 return NULL;
22067 }
22068
22069
22070 SWIGINTERN PyObject *_wrap_ConfigBase_RenameGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22071 PyObject *resultobj = 0;
22072 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22073 wxString *arg2 = 0 ;
22074 wxString *arg3 = 0 ;
22075 bool result;
22076 void *argp1 = 0 ;
22077 int res1 = 0 ;
22078 bool temp2 = false ;
22079 bool temp3 = false ;
22080 PyObject * obj0 = 0 ;
22081 PyObject * obj1 = 0 ;
22082 PyObject * obj2 = 0 ;
22083 char * kwnames[] = {
22084 (char *) "self",(char *) "oldName",(char *) "newName", NULL
22085 };
22086
22087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22088 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22089 if (!SWIG_IsOK(res1)) {
22090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22091 }
22092 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22093 {
22094 arg2 = wxString_in_helper(obj1);
22095 if (arg2 == NULL) SWIG_fail;
22096 temp2 = true;
22097 }
22098 {
22099 arg3 = wxString_in_helper(obj2);
22100 if (arg3 == NULL) SWIG_fail;
22101 temp3 = true;
22102 }
22103 {
22104 PyThreadState* __tstate = wxPyBeginAllowThreads();
22105 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
22106 wxPyEndAllowThreads(__tstate);
22107 if (PyErr_Occurred()) SWIG_fail;
22108 }
22109 {
22110 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22111 }
22112 {
22113 if (temp2)
22114 delete arg2;
22115 }
22116 {
22117 if (temp3)
22118 delete arg3;
22119 }
22120 return resultobj;
22121 fail:
22122 {
22123 if (temp2)
22124 delete arg2;
22125 }
22126 {
22127 if (temp3)
22128 delete arg3;
22129 }
22130 return NULL;
22131 }
22132
22133
22134 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22135 PyObject *resultobj = 0;
22136 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22137 wxString *arg2 = 0 ;
22138 bool arg3 = (bool) true ;
22139 bool result;
22140 void *argp1 = 0 ;
22141 int res1 = 0 ;
22142 bool temp2 = false ;
22143 bool val3 ;
22144 int ecode3 = 0 ;
22145 PyObject * obj0 = 0 ;
22146 PyObject * obj1 = 0 ;
22147 PyObject * obj2 = 0 ;
22148 char * kwnames[] = {
22149 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
22150 };
22151
22152 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22153 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22154 if (!SWIG_IsOK(res1)) {
22155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22156 }
22157 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22158 {
22159 arg2 = wxString_in_helper(obj1);
22160 if (arg2 == NULL) SWIG_fail;
22161 temp2 = true;
22162 }
22163 if (obj2) {
22164 ecode3 = SWIG_AsVal_bool(obj2, &val3);
22165 if (!SWIG_IsOK(ecode3)) {
22166 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "3"" of type '" "bool""'");
22167 }
22168 arg3 = static_cast< bool >(val3);
22169 }
22170 {
22171 PyThreadState* __tstate = wxPyBeginAllowThreads();
22172 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
22173 wxPyEndAllowThreads(__tstate);
22174 if (PyErr_Occurred()) SWIG_fail;
22175 }
22176 {
22177 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22178 }
22179 {
22180 if (temp2)
22181 delete arg2;
22182 }
22183 return resultobj;
22184 fail:
22185 {
22186 if (temp2)
22187 delete arg2;
22188 }
22189 return NULL;
22190 }
22191
22192
22193 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22194 PyObject *resultobj = 0;
22195 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22196 wxString *arg2 = 0 ;
22197 bool result;
22198 void *argp1 = 0 ;
22199 int res1 = 0 ;
22200 bool temp2 = false ;
22201 PyObject * obj0 = 0 ;
22202 PyObject * obj1 = 0 ;
22203 char * kwnames[] = {
22204 (char *) "self",(char *) "key", NULL
22205 };
22206
22207 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) SWIG_fail;
22208 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22209 if (!SWIG_IsOK(res1)) {
22210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22211 }
22212 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22213 {
22214 arg2 = wxString_in_helper(obj1);
22215 if (arg2 == NULL) SWIG_fail;
22216 temp2 = true;
22217 }
22218 {
22219 PyThreadState* __tstate = wxPyBeginAllowThreads();
22220 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
22221 wxPyEndAllowThreads(__tstate);
22222 if (PyErr_Occurred()) SWIG_fail;
22223 }
22224 {
22225 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22226 }
22227 {
22228 if (temp2)
22229 delete arg2;
22230 }
22231 return resultobj;
22232 fail:
22233 {
22234 if (temp2)
22235 delete arg2;
22236 }
22237 return NULL;
22238 }
22239
22240
22241 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22242 PyObject *resultobj = 0;
22243 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22244 bool result;
22245 void *argp1 = 0 ;
22246 int res1 = 0 ;
22247 PyObject *swig_obj[1] ;
22248
22249 if (!args) SWIG_fail;
22250 swig_obj[0] = args;
22251 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22252 if (!SWIG_IsOK(res1)) {
22253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteAll" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22254 }
22255 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22256 {
22257 PyThreadState* __tstate = wxPyBeginAllowThreads();
22258 result = (bool)(arg1)->DeleteAll();
22259 wxPyEndAllowThreads(__tstate);
22260 if (PyErr_Occurred()) SWIG_fail;
22261 }
22262 {
22263 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22264 }
22265 return resultobj;
22266 fail:
22267 return NULL;
22268 }
22269
22270
22271 SWIGINTERN PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22272 PyObject *resultobj = 0;
22273 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22274 bool arg2 = (bool) true ;
22275 void *argp1 = 0 ;
22276 int res1 = 0 ;
22277 bool val2 ;
22278 int ecode2 = 0 ;
22279 PyObject * obj0 = 0 ;
22280 PyObject * obj1 = 0 ;
22281 char * kwnames[] = {
22282 (char *) "self",(char *) "doIt", NULL
22283 };
22284
22285 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
22286 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22287 if (!SWIG_IsOK(res1)) {
22288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22289 }
22290 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22291 if (obj1) {
22292 ecode2 = SWIG_AsVal_bool(obj1, &val2);
22293 if (!SWIG_IsOK(ecode2)) {
22294 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "2"" of type '" "bool""'");
22295 }
22296 arg2 = static_cast< bool >(val2);
22297 }
22298 {
22299 PyThreadState* __tstate = wxPyBeginAllowThreads();
22300 (arg1)->SetExpandEnvVars(arg2);
22301 wxPyEndAllowThreads(__tstate);
22302 if (PyErr_Occurred()) SWIG_fail;
22303 }
22304 resultobj = SWIG_Py_Void();
22305 return resultobj;
22306 fail:
22307 return NULL;
22308 }
22309
22310
22311 SWIGINTERN PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22312 PyObject *resultobj = 0;
22313 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22314 bool result;
22315 void *argp1 = 0 ;
22316 int res1 = 0 ;
22317 PyObject *swig_obj[1] ;
22318
22319 if (!args) SWIG_fail;
22320 swig_obj[0] = args;
22321 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22322 if (!SWIG_IsOK(res1)) {
22323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsExpandingEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22324 }
22325 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22326 {
22327 PyThreadState* __tstate = wxPyBeginAllowThreads();
22328 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
22329 wxPyEndAllowThreads(__tstate);
22330 if (PyErr_Occurred()) SWIG_fail;
22331 }
22332 {
22333 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22334 }
22335 return resultobj;
22336 fail:
22337 return NULL;
22338 }
22339
22340
22341 SWIGINTERN PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22342 PyObject *resultobj = 0;
22343 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22344 bool arg2 = (bool) true ;
22345 void *argp1 = 0 ;
22346 int res1 = 0 ;
22347 bool val2 ;
22348 int ecode2 = 0 ;
22349 PyObject * obj0 = 0 ;
22350 PyObject * obj1 = 0 ;
22351 char * kwnames[] = {
22352 (char *) "self",(char *) "doIt", NULL
22353 };
22354
22355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
22356 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22357 if (!SWIG_IsOK(res1)) {
22358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22359 }
22360 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22361 if (obj1) {
22362 ecode2 = SWIG_AsVal_bool(obj1, &val2);
22363 if (!SWIG_IsOK(ecode2)) {
22364 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "2"" of type '" "bool""'");
22365 }
22366 arg2 = static_cast< bool >(val2);
22367 }
22368 {
22369 PyThreadState* __tstate = wxPyBeginAllowThreads();
22370 (arg1)->SetRecordDefaults(arg2);
22371 wxPyEndAllowThreads(__tstate);
22372 if (PyErr_Occurred()) SWIG_fail;
22373 }
22374 resultobj = SWIG_Py_Void();
22375 return resultobj;
22376 fail:
22377 return NULL;
22378 }
22379
22380
22381 SWIGINTERN PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22382 PyObject *resultobj = 0;
22383 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22384 bool result;
22385 void *argp1 = 0 ;
22386 int res1 = 0 ;
22387 PyObject *swig_obj[1] ;
22388
22389 if (!args) SWIG_fail;
22390 swig_obj[0] = args;
22391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22392 if (!SWIG_IsOK(res1)) {
22393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsRecordingDefaults" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22394 }
22395 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22396 {
22397 PyThreadState* __tstate = wxPyBeginAllowThreads();
22398 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
22399 wxPyEndAllowThreads(__tstate);
22400 if (PyErr_Occurred()) SWIG_fail;
22401 }
22402 {
22403 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22404 }
22405 return resultobj;
22406 fail:
22407 return NULL;
22408 }
22409
22410
22411 SWIGINTERN PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22412 PyObject *resultobj = 0;
22413 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22414 wxString *arg2 = 0 ;
22415 wxString result;
22416 void *argp1 = 0 ;
22417 int res1 = 0 ;
22418 bool temp2 = false ;
22419 PyObject * obj0 = 0 ;
22420 PyObject * obj1 = 0 ;
22421 char * kwnames[] = {
22422 (char *) "self",(char *) "str", NULL
22423 };
22424
22425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
22426 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22427 if (!SWIG_IsOK(res1)) {
22428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22429 }
22430 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22431 {
22432 arg2 = wxString_in_helper(obj1);
22433 if (arg2 == NULL) SWIG_fail;
22434 temp2 = true;
22435 }
22436 {
22437 PyThreadState* __tstate = wxPyBeginAllowThreads();
22438 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
22439 wxPyEndAllowThreads(__tstate);
22440 if (PyErr_Occurred()) SWIG_fail;
22441 }
22442 {
22443 #if wxUSE_UNICODE
22444 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22445 #else
22446 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22447 #endif
22448 }
22449 {
22450 if (temp2)
22451 delete arg2;
22452 }
22453 return resultobj;
22454 fail:
22455 {
22456 if (temp2)
22457 delete arg2;
22458 }
22459 return NULL;
22460 }
22461
22462
22463 SWIGINTERN PyObject *_wrap_ConfigBase_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22464 PyObject *resultobj = 0;
22465 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22466 wxString result;
22467 void *argp1 = 0 ;
22468 int res1 = 0 ;
22469 PyObject *swig_obj[1] ;
22470
22471 if (!args) SWIG_fail;
22472 swig_obj[0] = args;
22473 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22474 if (!SWIG_IsOK(res1)) {
22475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetAppName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22476 }
22477 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22478 {
22479 PyThreadState* __tstate = wxPyBeginAllowThreads();
22480 result = ((wxConfigBase const *)arg1)->GetAppName();
22481 wxPyEndAllowThreads(__tstate);
22482 if (PyErr_Occurred()) SWIG_fail;
22483 }
22484 {
22485 #if wxUSE_UNICODE
22486 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22487 #else
22488 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22489 #endif
22490 }
22491 return resultobj;
22492 fail:
22493 return NULL;
22494 }
22495
22496
22497 SWIGINTERN PyObject *_wrap_ConfigBase_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22498 PyObject *resultobj = 0;
22499 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22500 wxString result;
22501 void *argp1 = 0 ;
22502 int res1 = 0 ;
22503 PyObject *swig_obj[1] ;
22504
22505 if (!args) SWIG_fail;
22506 swig_obj[0] = args;
22507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22508 if (!SWIG_IsOK(res1)) {
22509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetVendorName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22510 }
22511 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22512 {
22513 PyThreadState* __tstate = wxPyBeginAllowThreads();
22514 result = ((wxConfigBase const *)arg1)->GetVendorName();
22515 wxPyEndAllowThreads(__tstate);
22516 if (PyErr_Occurred()) SWIG_fail;
22517 }
22518 {
22519 #if wxUSE_UNICODE
22520 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22521 #else
22522 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22523 #endif
22524 }
22525 return resultobj;
22526 fail:
22527 return NULL;
22528 }
22529
22530
22531 SWIGINTERN PyObject *_wrap_ConfigBase_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22532 PyObject *resultobj = 0;
22533 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22534 wxString *arg2 = 0 ;
22535 void *argp1 = 0 ;
22536 int res1 = 0 ;
22537 bool temp2 = false ;
22538 PyObject * obj0 = 0 ;
22539 PyObject * obj1 = 0 ;
22540 char * kwnames[] = {
22541 (char *) "self",(char *) "appName", NULL
22542 };
22543
22544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
22545 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22546 if (!SWIG_IsOK(res1)) {
22547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetAppName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22548 }
22549 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22550 {
22551 arg2 = wxString_in_helper(obj1);
22552 if (arg2 == NULL) SWIG_fail;
22553 temp2 = true;
22554 }
22555 {
22556 PyThreadState* __tstate = wxPyBeginAllowThreads();
22557 (arg1)->SetAppName((wxString const &)*arg2);
22558 wxPyEndAllowThreads(__tstate);
22559 if (PyErr_Occurred()) SWIG_fail;
22560 }
22561 resultobj = SWIG_Py_Void();
22562 {
22563 if (temp2)
22564 delete arg2;
22565 }
22566 return resultobj;
22567 fail:
22568 {
22569 if (temp2)
22570 delete arg2;
22571 }
22572 return NULL;
22573 }
22574
22575
22576 SWIGINTERN PyObject *_wrap_ConfigBase_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22577 PyObject *resultobj = 0;
22578 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22579 wxString *arg2 = 0 ;
22580 void *argp1 = 0 ;
22581 int res1 = 0 ;
22582 bool temp2 = false ;
22583 PyObject * obj0 = 0 ;
22584 PyObject * obj1 = 0 ;
22585 char * kwnames[] = {
22586 (char *) "self",(char *) "vendorName", NULL
22587 };
22588
22589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
22590 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22591 if (!SWIG_IsOK(res1)) {
22592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetVendorName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22593 }
22594 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22595 {
22596 arg2 = wxString_in_helper(obj1);
22597 if (arg2 == NULL) SWIG_fail;
22598 temp2 = true;
22599 }
22600 {
22601 PyThreadState* __tstate = wxPyBeginAllowThreads();
22602 (arg1)->SetVendorName((wxString const &)*arg2);
22603 wxPyEndAllowThreads(__tstate);
22604 if (PyErr_Occurred()) SWIG_fail;
22605 }
22606 resultobj = SWIG_Py_Void();
22607 {
22608 if (temp2)
22609 delete arg2;
22610 }
22611 return resultobj;
22612 fail:
22613 {
22614 if (temp2)
22615 delete arg2;
22616 }
22617 return NULL;
22618 }
22619
22620
22621 SWIGINTERN PyObject *_wrap_ConfigBase_SetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22622 PyObject *resultobj = 0;
22623 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22624 long arg2 ;
22625 void *argp1 = 0 ;
22626 int res1 = 0 ;
22627 long val2 ;
22628 int ecode2 = 0 ;
22629 PyObject * obj0 = 0 ;
22630 PyObject * obj1 = 0 ;
22631 char * kwnames[] = {
22632 (char *) "self",(char *) "style", NULL
22633 };
22634
22635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) SWIG_fail;
22636 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22637 if (!SWIG_IsOK(res1)) {
22638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetStyle" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22639 }
22640 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22641 ecode2 = SWIG_AsVal_long(obj1, &val2);
22642 if (!SWIG_IsOK(ecode2)) {
22643 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetStyle" "', expected argument " "2"" of type '" "long""'");
22644 }
22645 arg2 = static_cast< long >(val2);
22646 {
22647 PyThreadState* __tstate = wxPyBeginAllowThreads();
22648 (arg1)->SetStyle(arg2);
22649 wxPyEndAllowThreads(__tstate);
22650 if (PyErr_Occurred()) SWIG_fail;
22651 }
22652 resultobj = SWIG_Py_Void();
22653 return resultobj;
22654 fail:
22655 return NULL;
22656 }
22657
22658
22659 SWIGINTERN PyObject *_wrap_ConfigBase_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22660 PyObject *resultobj = 0;
22661 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22662 long result;
22663 void *argp1 = 0 ;
22664 int res1 = 0 ;
22665 PyObject *swig_obj[1] ;
22666
22667 if (!args) SWIG_fail;
22668 swig_obj[0] = args;
22669 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22670 if (!SWIG_IsOK(res1)) {
22671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetStyle" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22672 }
22673 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22674 {
22675 PyThreadState* __tstate = wxPyBeginAllowThreads();
22676 result = (long)((wxConfigBase const *)arg1)->GetStyle();
22677 wxPyEndAllowThreads(__tstate);
22678 if (PyErr_Occurred()) SWIG_fail;
22679 }
22680 resultobj = SWIG_From_long(static_cast< long >(result));
22681 return resultobj;
22682 fail:
22683 return NULL;
22684 }
22685
22686
22687 SWIGINTERN PyObject *ConfigBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22688 PyObject *obj;
22689 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22690 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigBase, SWIG_NewClientData(obj));
22691 return SWIG_Py_Void();
22692 }
22693
22694 SWIGINTERN PyObject *_wrap_new_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22695 PyObject *resultobj = 0;
22696 wxString const &arg1_defvalue = wxPyEmptyString ;
22697 wxString *arg1 = (wxString *) &arg1_defvalue ;
22698 wxString const &arg2_defvalue = wxPyEmptyString ;
22699 wxString *arg2 = (wxString *) &arg2_defvalue ;
22700 wxString const &arg3_defvalue = wxPyEmptyString ;
22701 wxString *arg3 = (wxString *) &arg3_defvalue ;
22702 wxString const &arg4_defvalue = wxPyEmptyString ;
22703 wxString *arg4 = (wxString *) &arg4_defvalue ;
22704 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
22705 wxConfig *result = 0 ;
22706 bool temp1 = false ;
22707 bool temp2 = false ;
22708 bool temp3 = false ;
22709 bool temp4 = false ;
22710 long val5 ;
22711 int ecode5 = 0 ;
22712 PyObject * obj0 = 0 ;
22713 PyObject * obj1 = 0 ;
22714 PyObject * obj2 = 0 ;
22715 PyObject * obj3 = 0 ;
22716 PyObject * obj4 = 0 ;
22717 char * kwnames[] = {
22718 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
22719 };
22720
22721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
22722 if (obj0) {
22723 {
22724 arg1 = wxString_in_helper(obj0);
22725 if (arg1 == NULL) SWIG_fail;
22726 temp1 = true;
22727 }
22728 }
22729 if (obj1) {
22730 {
22731 arg2 = wxString_in_helper(obj1);
22732 if (arg2 == NULL) SWIG_fail;
22733 temp2 = true;
22734 }
22735 }
22736 if (obj2) {
22737 {
22738 arg3 = wxString_in_helper(obj2);
22739 if (arg3 == NULL) SWIG_fail;
22740 temp3 = true;
22741 }
22742 }
22743 if (obj3) {
22744 {
22745 arg4 = wxString_in_helper(obj3);
22746 if (arg4 == NULL) SWIG_fail;
22747 temp4 = true;
22748 }
22749 }
22750 if (obj4) {
22751 ecode5 = SWIG_AsVal_long(obj4, &val5);
22752 if (!SWIG_IsOK(ecode5)) {
22753 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Config" "', expected argument " "5"" of type '" "long""'");
22754 }
22755 arg5 = static_cast< long >(val5);
22756 }
22757 {
22758 PyThreadState* __tstate = wxPyBeginAllowThreads();
22759 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
22760 wxPyEndAllowThreads(__tstate);
22761 if (PyErr_Occurred()) SWIG_fail;
22762 }
22763 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfig, SWIG_POINTER_NEW | 0 );
22764 {
22765 if (temp1)
22766 delete arg1;
22767 }
22768 {
22769 if (temp2)
22770 delete arg2;
22771 }
22772 {
22773 if (temp3)
22774 delete arg3;
22775 }
22776 {
22777 if (temp4)
22778 delete arg4;
22779 }
22780 return resultobj;
22781 fail:
22782 {
22783 if (temp1)
22784 delete arg1;
22785 }
22786 {
22787 if (temp2)
22788 delete arg2;
22789 }
22790 {
22791 if (temp3)
22792 delete arg3;
22793 }
22794 {
22795 if (temp4)
22796 delete arg4;
22797 }
22798 return NULL;
22799 }
22800
22801
22802 SWIGINTERN PyObject *_wrap_delete_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22803 PyObject *resultobj = 0;
22804 wxConfig *arg1 = (wxConfig *) 0 ;
22805 void *argp1 = 0 ;
22806 int res1 = 0 ;
22807 PyObject *swig_obj[1] ;
22808
22809 if (!args) SWIG_fail;
22810 swig_obj[0] = args;
22811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfig, SWIG_POINTER_DISOWN | 0 );
22812 if (!SWIG_IsOK(res1)) {
22813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Config" "', expected argument " "1"" of type '" "wxConfig *""'");
22814 }
22815 arg1 = reinterpret_cast< wxConfig * >(argp1);
22816 {
22817 PyThreadState* __tstate = wxPyBeginAllowThreads();
22818 delete arg1;
22819
22820 wxPyEndAllowThreads(__tstate);
22821 if (PyErr_Occurred()) SWIG_fail;
22822 }
22823 resultobj = SWIG_Py_Void();
22824 return resultobj;
22825 fail:
22826 return NULL;
22827 }
22828
22829
22830 SWIGINTERN PyObject *Config_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22831 PyObject *obj;
22832 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22833 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfig, SWIG_NewClientData(obj));
22834 return SWIG_Py_Void();
22835 }
22836
22837 SWIGINTERN PyObject *Config_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22838 return SWIG_Python_InitShadowInstance(args);
22839 }
22840
22841 SWIGINTERN PyObject *_wrap_new_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22842 PyObject *resultobj = 0;
22843 wxString const &arg1_defvalue = wxPyEmptyString ;
22844 wxString *arg1 = (wxString *) &arg1_defvalue ;
22845 wxString const &arg2_defvalue = wxPyEmptyString ;
22846 wxString *arg2 = (wxString *) &arg2_defvalue ;
22847 wxString const &arg3_defvalue = wxPyEmptyString ;
22848 wxString *arg3 = (wxString *) &arg3_defvalue ;
22849 wxString const &arg4_defvalue = wxPyEmptyString ;
22850 wxString *arg4 = (wxString *) &arg4_defvalue ;
22851 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
22852 wxFileConfig *result = 0 ;
22853 bool temp1 = false ;
22854 bool temp2 = false ;
22855 bool temp3 = false ;
22856 bool temp4 = false ;
22857 long val5 ;
22858 int ecode5 = 0 ;
22859 PyObject * obj0 = 0 ;
22860 PyObject * obj1 = 0 ;
22861 PyObject * obj2 = 0 ;
22862 PyObject * obj3 = 0 ;
22863 PyObject * obj4 = 0 ;
22864 char * kwnames[] = {
22865 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
22866 };
22867
22868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
22869 if (obj0) {
22870 {
22871 arg1 = wxString_in_helper(obj0);
22872 if (arg1 == NULL) SWIG_fail;
22873 temp1 = true;
22874 }
22875 }
22876 if (obj1) {
22877 {
22878 arg2 = wxString_in_helper(obj1);
22879 if (arg2 == NULL) SWIG_fail;
22880 temp2 = true;
22881 }
22882 }
22883 if (obj2) {
22884 {
22885 arg3 = wxString_in_helper(obj2);
22886 if (arg3 == NULL) SWIG_fail;
22887 temp3 = true;
22888 }
22889 }
22890 if (obj3) {
22891 {
22892 arg4 = wxString_in_helper(obj3);
22893 if (arg4 == NULL) SWIG_fail;
22894 temp4 = true;
22895 }
22896 }
22897 if (obj4) {
22898 ecode5 = SWIG_AsVal_long(obj4, &val5);
22899 if (!SWIG_IsOK(ecode5)) {
22900 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FileConfig" "', expected argument " "5"" of type '" "long""'");
22901 }
22902 arg5 = static_cast< long >(val5);
22903 }
22904 {
22905 PyThreadState* __tstate = wxPyBeginAllowThreads();
22906 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
22907 wxPyEndAllowThreads(__tstate);
22908 if (PyErr_Occurred()) SWIG_fail;
22909 }
22910 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileConfig, SWIG_POINTER_NEW | 0 );
22911 {
22912 if (temp1)
22913 delete arg1;
22914 }
22915 {
22916 if (temp2)
22917 delete arg2;
22918 }
22919 {
22920 if (temp3)
22921 delete arg3;
22922 }
22923 {
22924 if (temp4)
22925 delete arg4;
22926 }
22927 return resultobj;
22928 fail:
22929 {
22930 if (temp1)
22931 delete arg1;
22932 }
22933 {
22934 if (temp2)
22935 delete arg2;
22936 }
22937 {
22938 if (temp3)
22939 delete arg3;
22940 }
22941 {
22942 if (temp4)
22943 delete arg4;
22944 }
22945 return NULL;
22946 }
22947
22948
22949 SWIGINTERN PyObject *_wrap_delete_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22950 PyObject *resultobj = 0;
22951 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
22952 void *argp1 = 0 ;
22953 int res1 = 0 ;
22954 PyObject *swig_obj[1] ;
22955
22956 if (!args) SWIG_fail;
22957 swig_obj[0] = args;
22958 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileConfig, SWIG_POINTER_DISOWN | 0 );
22959 if (!SWIG_IsOK(res1)) {
22960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileConfig" "', expected argument " "1"" of type '" "wxFileConfig *""'");
22961 }
22962 arg1 = reinterpret_cast< wxFileConfig * >(argp1);
22963 {
22964 PyThreadState* __tstate = wxPyBeginAllowThreads();
22965 delete arg1;
22966
22967 wxPyEndAllowThreads(__tstate);
22968 if (PyErr_Occurred()) SWIG_fail;
22969 }
22970 resultobj = SWIG_Py_Void();
22971 return resultobj;
22972 fail:
22973 return NULL;
22974 }
22975
22976
22977 SWIGINTERN PyObject *FileConfig_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22978 PyObject *obj;
22979 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22980 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileConfig, SWIG_NewClientData(obj));
22981 return SWIG_Py_Void();
22982 }
22983
22984 SWIGINTERN PyObject *FileConfig_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22985 return SWIG_Python_InitShadowInstance(args);
22986 }
22987
22988 SWIGINTERN PyObject *_wrap_new_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22989 PyObject *resultobj = 0;
22990 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22991 wxString *arg2 = 0 ;
22992 wxConfigPathChanger *result = 0 ;
22993 void *argp1 = 0 ;
22994 int res1 = 0 ;
22995 bool temp2 = false ;
22996 PyObject * obj0 = 0 ;
22997 PyObject * obj1 = 0 ;
22998 char * kwnames[] = {
22999 (char *) "config",(char *) "entry", NULL
23000 };
23001
23002 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) SWIG_fail;
23003 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
23004 if (!SWIG_IsOK(res1)) {
23005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
23006 }
23007 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
23008 {
23009 arg2 = wxString_in_helper(obj1);
23010 if (arg2 == NULL) SWIG_fail;
23011 temp2 = true;
23012 }
23013 {
23014 PyThreadState* __tstate = wxPyBeginAllowThreads();
23015 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
23016 wxPyEndAllowThreads(__tstate);
23017 if (PyErr_Occurred()) SWIG_fail;
23018 }
23019 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_NEW | 0 );
23020 {
23021 if (temp2)
23022 delete arg2;
23023 }
23024 return resultobj;
23025 fail:
23026 {
23027 if (temp2)
23028 delete arg2;
23029 }
23030 return NULL;
23031 }
23032
23033
23034 SWIGINTERN PyObject *_wrap_delete_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23035 PyObject *resultobj = 0;
23036 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
23037 void *argp1 = 0 ;
23038 int res1 = 0 ;
23039 PyObject *swig_obj[1] ;
23040
23041 if (!args) SWIG_fail;
23042 swig_obj[0] = args;
23043 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_DISOWN | 0 );
23044 if (!SWIG_IsOK(res1)) {
23045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigPathChanger *""'");
23046 }
23047 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
23048 {
23049 PyThreadState* __tstate = wxPyBeginAllowThreads();
23050 delete arg1;
23051
23052 wxPyEndAllowThreads(__tstate);
23053 if (PyErr_Occurred()) SWIG_fail;
23054 }
23055 resultobj = SWIG_Py_Void();
23056 return resultobj;
23057 fail:
23058 return NULL;
23059 }
23060
23061
23062 SWIGINTERN PyObject *_wrap_ConfigPathChanger_Name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23063 PyObject *resultobj = 0;
23064 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
23065 wxString *result = 0 ;
23066 void *argp1 = 0 ;
23067 int res1 = 0 ;
23068 PyObject *swig_obj[1] ;
23069
23070 if (!args) SWIG_fail;
23071 swig_obj[0] = args;
23072 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, 0 | 0 );
23073 if (!SWIG_IsOK(res1)) {
23074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigPathChanger_Name" "', expected argument " "1"" of type '" "wxConfigPathChanger const *""'");
23075 }
23076 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
23077 {
23078 PyThreadState* __tstate = wxPyBeginAllowThreads();
23079 {
23080 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
23081 result = (wxString *) &_result_ref;
23082 }
23083 wxPyEndAllowThreads(__tstate);
23084 if (PyErr_Occurred()) SWIG_fail;
23085 }
23086 {
23087 #if wxUSE_UNICODE
23088 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
23089 #else
23090 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
23091 #endif
23092 }
23093 return resultobj;
23094 fail:
23095 return NULL;
23096 }
23097
23098
23099 SWIGINTERN PyObject *ConfigPathChanger_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23100 PyObject *obj;
23101 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23102 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigPathChanger, SWIG_NewClientData(obj));
23103 return SWIG_Py_Void();
23104 }
23105
23106 SWIGINTERN PyObject *ConfigPathChanger_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23107 return SWIG_Python_InitShadowInstance(args);
23108 }
23109
23110 SWIGINTERN PyObject *_wrap_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23111 PyObject *resultobj = 0;
23112 wxString *arg1 = 0 ;
23113 wxString result;
23114 bool temp1 = false ;
23115 PyObject * obj0 = 0 ;
23116 char * kwnames[] = {
23117 (char *) "sz", NULL
23118 };
23119
23120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) SWIG_fail;
23121 {
23122 arg1 = wxString_in_helper(obj0);
23123 if (arg1 == NULL) SWIG_fail;
23124 temp1 = true;
23125 }
23126 {
23127 PyThreadState* __tstate = wxPyBeginAllowThreads();
23128 result = wxExpandEnvVars((wxString const &)*arg1);
23129 wxPyEndAllowThreads(__tstate);
23130 if (PyErr_Occurred()) SWIG_fail;
23131 }
23132 {
23133 #if wxUSE_UNICODE
23134 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23135 #else
23136 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23137 #endif
23138 }
23139 {
23140 if (temp1)
23141 delete arg1;
23142 }
23143 return resultobj;
23144 fail:
23145 {
23146 if (temp1)
23147 delete arg1;
23148 }
23149 return NULL;
23150 }
23151
23152
23153 SWIGINTERN int DefaultDateTimeFormat_set(PyObject *) {
23154 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTimeFormat is read-only.");
23155 return 1;
23156 }
23157
23158
23159 SWIGINTERN PyObject *DefaultDateTimeFormat_get(void) {
23160 PyObject *pyobj = 0;
23161
23162 {
23163 #if wxUSE_UNICODE
23164 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
23165 #else
23166 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
23167 #endif
23168 }
23169 return pyobj;
23170 }
23171
23172
23173 SWIGINTERN int DefaultTimeSpanFormat_set(PyObject *) {
23174 SWIG_Error(SWIG_AttributeError,"Variable DefaultTimeSpanFormat is read-only.");
23175 return 1;
23176 }
23177
23178
23179 SWIGINTERN PyObject *DefaultTimeSpanFormat_get(void) {
23180 PyObject *pyobj = 0;
23181
23182 {
23183 #if wxUSE_UNICODE
23184 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
23185 #else
23186 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
23187 #endif
23188 }
23189 return pyobj;
23190 }
23191
23192
23193 SWIGINTERN PyObject *_wrap_DateTime_SetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23194 PyObject *resultobj = 0;
23195 wxDateTime::Country arg1 ;
23196 int val1 ;
23197 int ecode1 = 0 ;
23198 PyObject * obj0 = 0 ;
23199 char * kwnames[] = {
23200 (char *) "country", NULL
23201 };
23202
23203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) SWIG_fail;
23204 ecode1 = SWIG_AsVal_int(obj0, &val1);
23205 if (!SWIG_IsOK(ecode1)) {
23206 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
23207 }
23208 arg1 = static_cast< wxDateTime::Country >(val1);
23209 {
23210 PyThreadState* __tstate = wxPyBeginAllowThreads();
23211 wxDateTime::SetCountry(arg1);
23212 wxPyEndAllowThreads(__tstate);
23213 if (PyErr_Occurred()) SWIG_fail;
23214 }
23215 resultobj = SWIG_Py_Void();
23216 return resultobj;
23217 fail:
23218 return NULL;
23219 }
23220
23221
23222 SWIGINTERN PyObject *_wrap_DateTime_GetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23223 PyObject *resultobj = 0;
23224 wxDateTime::Country result;
23225
23226 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetCountry",0,0,0)) SWIG_fail;
23227 {
23228 PyThreadState* __tstate = wxPyBeginAllowThreads();
23229 result = (wxDateTime::Country)wxDateTime::GetCountry();
23230 wxPyEndAllowThreads(__tstate);
23231 if (PyErr_Occurred()) SWIG_fail;
23232 }
23233 resultobj = SWIG_From_int(static_cast< int >(result));
23234 return resultobj;
23235 fail:
23236 return NULL;
23237 }
23238
23239
23240 SWIGINTERN PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23241 PyObject *resultobj = 0;
23242 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
23243 bool result;
23244 int val1 ;
23245 int ecode1 = 0 ;
23246 PyObject * obj0 = 0 ;
23247 char * kwnames[] = {
23248 (char *) "country", NULL
23249 };
23250
23251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) SWIG_fail;
23252 if (obj0) {
23253 ecode1 = SWIG_AsVal_int(obj0, &val1);
23254 if (!SWIG_IsOK(ecode1)) {
23255 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsWestEuropeanCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
23256 }
23257 arg1 = static_cast< wxDateTime::Country >(val1);
23258 }
23259 {
23260 PyThreadState* __tstate = wxPyBeginAllowThreads();
23261 result = (bool)wxDateTime::IsWestEuropeanCountry(arg1);
23262 wxPyEndAllowThreads(__tstate);
23263 if (PyErr_Occurred()) SWIG_fail;
23264 }
23265 {
23266 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23267 }
23268 return resultobj;
23269 fail:
23270 return NULL;
23271 }
23272
23273
23274 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23275 PyObject *resultobj = 0;
23276 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23277 int result;
23278 int val1 ;
23279 int ecode1 = 0 ;
23280 PyObject * obj0 = 0 ;
23281 char * kwnames[] = {
23282 (char *) "cal", NULL
23283 };
23284
23285 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) SWIG_fail;
23286 if (obj0) {
23287 ecode1 = SWIG_AsVal_int(obj0, &val1);
23288 if (!SWIG_IsOK(ecode1)) {
23289 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentYear" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
23290 }
23291 arg1 = static_cast< wxDateTime::Calendar >(val1);
23292 }
23293 {
23294 PyThreadState* __tstate = wxPyBeginAllowThreads();
23295 result = (int)wxDateTime::GetCurrentYear(arg1);
23296 wxPyEndAllowThreads(__tstate);
23297 if (PyErr_Occurred()) SWIG_fail;
23298 }
23299 resultobj = SWIG_From_int(static_cast< int >(result));
23300 return resultobj;
23301 fail:
23302 return NULL;
23303 }
23304
23305
23306 SWIGINTERN PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23307 PyObject *resultobj = 0;
23308 int arg1 ;
23309 int result;
23310 int val1 ;
23311 int ecode1 = 0 ;
23312 PyObject * obj0 = 0 ;
23313 char * kwnames[] = {
23314 (char *) "year", NULL
23315 };
23316
23317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) SWIG_fail;
23318 ecode1 = SWIG_AsVal_int(obj0, &val1);
23319 if (!SWIG_IsOK(ecode1)) {
23320 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_ConvertYearToBC" "', expected argument " "1"" of type '" "int""'");
23321 }
23322 arg1 = static_cast< int >(val1);
23323 {
23324 PyThreadState* __tstate = wxPyBeginAllowThreads();
23325 result = (int)wxDateTime::ConvertYearToBC(arg1);
23326 wxPyEndAllowThreads(__tstate);
23327 if (PyErr_Occurred()) SWIG_fail;
23328 }
23329 resultobj = SWIG_From_int(static_cast< int >(result));
23330 return resultobj;
23331 fail:
23332 return NULL;
23333 }
23334
23335
23336 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23337 PyObject *resultobj = 0;
23338 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23339 wxDateTime::Month result;
23340 int val1 ;
23341 int ecode1 = 0 ;
23342 PyObject * obj0 = 0 ;
23343 char * kwnames[] = {
23344 (char *) "cal", NULL
23345 };
23346
23347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) SWIG_fail;
23348 if (obj0) {
23349 ecode1 = SWIG_AsVal_int(obj0, &val1);
23350 if (!SWIG_IsOK(ecode1)) {
23351 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentMonth" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
23352 }
23353 arg1 = static_cast< wxDateTime::Calendar >(val1);
23354 }
23355 {
23356 PyThreadState* __tstate = wxPyBeginAllowThreads();
23357 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth(arg1);
23358 wxPyEndAllowThreads(__tstate);
23359 if (PyErr_Occurred()) SWIG_fail;
23360 }
23361 resultobj = SWIG_From_int(static_cast< int >(result));
23362 return resultobj;
23363 fail:
23364 return NULL;
23365 }
23366
23367
23368 SWIGINTERN PyObject *_wrap_DateTime_IsLeapYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23369 PyObject *resultobj = 0;
23370 int arg1 = (int) wxDateTime::Inv_Year ;
23371 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23372 bool result;
23373 int val1 ;
23374 int ecode1 = 0 ;
23375 int val2 ;
23376 int ecode2 = 0 ;
23377 PyObject * obj0 = 0 ;
23378 PyObject * obj1 = 0 ;
23379 char * kwnames[] = {
23380 (char *) "year",(char *) "cal", NULL
23381 };
23382
23383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) SWIG_fail;
23384 if (obj0) {
23385 ecode1 = SWIG_AsVal_int(obj0, &val1);
23386 if (!SWIG_IsOK(ecode1)) {
23387 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsLeapYear" "', expected argument " "1"" of type '" "int""'");
23388 }
23389 arg1 = static_cast< int >(val1);
23390 }
23391 if (obj1) {
23392 ecode2 = SWIG_AsVal_int(obj1, &val2);
23393 if (!SWIG_IsOK(ecode2)) {
23394 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsLeapYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
23395 }
23396 arg2 = static_cast< wxDateTime::Calendar >(val2);
23397 }
23398 {
23399 PyThreadState* __tstate = wxPyBeginAllowThreads();
23400 result = (bool)wxDateTime::IsLeapYear(arg1,arg2);
23401 wxPyEndAllowThreads(__tstate);
23402 if (PyErr_Occurred()) SWIG_fail;
23403 }
23404 {
23405 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23406 }
23407 return resultobj;
23408 fail:
23409 return NULL;
23410 }
23411
23412
23413 SWIGINTERN PyObject *_wrap_DateTime_GetCentury(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23414 PyObject *resultobj = 0;
23415 int arg1 = (int) wxDateTime::Inv_Year ;
23416 int result;
23417 int val1 ;
23418 int ecode1 = 0 ;
23419 PyObject * obj0 = 0 ;
23420 char * kwnames[] = {
23421 (char *) "year", NULL
23422 };
23423
23424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) SWIG_fail;
23425 if (obj0) {
23426 ecode1 = SWIG_AsVal_int(obj0, &val1);
23427 if (!SWIG_IsOK(ecode1)) {
23428 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCentury" "', expected argument " "1"" of type '" "int""'");
23429 }
23430 arg1 = static_cast< int >(val1);
23431 }
23432 {
23433 PyThreadState* __tstate = wxPyBeginAllowThreads();
23434 result = (int)wxDateTime::GetCentury(arg1);
23435 wxPyEndAllowThreads(__tstate);
23436 if (PyErr_Occurred()) SWIG_fail;
23437 }
23438 resultobj = SWIG_From_int(static_cast< int >(result));
23439 return resultobj;
23440 fail:
23441 return NULL;
23442 }
23443
23444
23445 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23446 PyObject *resultobj = 0;
23447 int arg1 ;
23448 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23449 int result;
23450 int val1 ;
23451 int ecode1 = 0 ;
23452 int val2 ;
23453 int ecode2 = 0 ;
23454 PyObject * obj0 = 0 ;
23455 PyObject * obj1 = 0 ;
23456 char * kwnames[] = {
23457 (char *) "year",(char *) "cal", NULL
23458 };
23459
23460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) SWIG_fail;
23461 ecode1 = SWIG_AsVal_int(obj0, &val1);
23462 if (!SWIG_IsOK(ecode1)) {
23463 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "1"" of type '" "int""'");
23464 }
23465 arg1 = static_cast< int >(val1);
23466 if (obj1) {
23467 ecode2 = SWIG_AsVal_int(obj1, &val2);
23468 if (!SWIG_IsOK(ecode2)) {
23469 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
23470 }
23471 arg2 = static_cast< wxDateTime::Calendar >(val2);
23472 }
23473 {
23474 PyThreadState* __tstate = wxPyBeginAllowThreads();
23475 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2);
23476 wxPyEndAllowThreads(__tstate);
23477 if (PyErr_Occurred()) SWIG_fail;
23478 }
23479 resultobj = SWIG_From_int(static_cast< int >(result));
23480 return resultobj;
23481 fail:
23482 return NULL;
23483 }
23484
23485
23486 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23487 PyObject *resultobj = 0;
23488 wxDateTime::Month arg1 ;
23489 int arg2 = (int) wxDateTime::Inv_Year ;
23490 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23491 int result;
23492 int val1 ;
23493 int ecode1 = 0 ;
23494 int val2 ;
23495 int ecode2 = 0 ;
23496 int val3 ;
23497 int ecode3 = 0 ;
23498 PyObject * obj0 = 0 ;
23499 PyObject * obj1 = 0 ;
23500 PyObject * obj2 = 0 ;
23501 char * kwnames[] = {
23502 (char *) "month",(char *) "year",(char *) "cal", NULL
23503 };
23504
23505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23506 ecode1 = SWIG_AsVal_int(obj0, &val1);
23507 if (!SWIG_IsOK(ecode1)) {
23508 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
23509 }
23510 arg1 = static_cast< wxDateTime::Month >(val1);
23511 if (obj1) {
23512 ecode2 = SWIG_AsVal_int(obj1, &val2);
23513 if (!SWIG_IsOK(ecode2)) {
23514 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "2"" of type '" "int""'");
23515 }
23516 arg2 = static_cast< int >(val2);
23517 }
23518 if (obj2) {
23519 ecode3 = SWIG_AsVal_int(obj2, &val3);
23520 if (!SWIG_IsOK(ecode3)) {
23521 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "3"" of type '" "wxDateTime::Calendar""'");
23522 }
23523 arg3 = static_cast< wxDateTime::Calendar >(val3);
23524 }
23525 {
23526 PyThreadState* __tstate = wxPyBeginAllowThreads();
23527 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2,arg3);
23528 wxPyEndAllowThreads(__tstate);
23529 if (PyErr_Occurred()) SWIG_fail;
23530 }
23531 resultobj = SWIG_From_int(static_cast< int >(result));
23532 return resultobj;
23533 fail:
23534 return NULL;
23535 }
23536
23537
23538 SWIGINTERN PyObject *_wrap_DateTime_GetMonthName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23539 PyObject *resultobj = 0;
23540 wxDateTime::Month arg1 ;
23541 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
23542 wxString result;
23543 int val1 ;
23544 int ecode1 = 0 ;
23545 int val2 ;
23546 int ecode2 = 0 ;
23547 PyObject * obj0 = 0 ;
23548 PyObject * obj1 = 0 ;
23549 char * kwnames[] = {
23550 (char *) "month",(char *) "flags", NULL
23551 };
23552
23553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) SWIG_fail;
23554 ecode1 = SWIG_AsVal_int(obj0, &val1);
23555 if (!SWIG_IsOK(ecode1)) {
23556 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetMonthName" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
23557 }
23558 arg1 = static_cast< wxDateTime::Month >(val1);
23559 if (obj1) {
23560 ecode2 = SWIG_AsVal_int(obj1, &val2);
23561 if (!SWIG_IsOK(ecode2)) {
23562 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetMonthName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
23563 }
23564 arg2 = static_cast< wxDateTime::NameFlags >(val2);
23565 }
23566 {
23567 PyThreadState* __tstate = wxPyBeginAllowThreads();
23568 result = wxDateTime::GetMonthName(arg1,arg2);
23569 wxPyEndAllowThreads(__tstate);
23570 if (PyErr_Occurred()) SWIG_fail;
23571 }
23572 {
23573 #if wxUSE_UNICODE
23574 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23575 #else
23576 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23577 #endif
23578 }
23579 return resultobj;
23580 fail:
23581 return NULL;
23582 }
23583
23584
23585 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23586 PyObject *resultobj = 0;
23587 wxDateTime::WeekDay arg1 ;
23588 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
23589 wxString result;
23590 int val1 ;
23591 int ecode1 = 0 ;
23592 int val2 ;
23593 int ecode2 = 0 ;
23594 PyObject * obj0 = 0 ;
23595 PyObject * obj1 = 0 ;
23596 char * kwnames[] = {
23597 (char *) "weekday",(char *) "flags", NULL
23598 };
23599
23600 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) SWIG_fail;
23601 ecode1 = SWIG_AsVal_int(obj0, &val1);
23602 if (!SWIG_IsOK(ecode1)) {
23603 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetWeekDayName" "', expected argument " "1"" of type '" "wxDateTime::WeekDay""'");
23604 }
23605 arg1 = static_cast< wxDateTime::WeekDay >(val1);
23606 if (obj1) {
23607 ecode2 = SWIG_AsVal_int(obj1, &val2);
23608 if (!SWIG_IsOK(ecode2)) {
23609 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
23610 }
23611 arg2 = static_cast< wxDateTime::NameFlags >(val2);
23612 }
23613 {
23614 PyThreadState* __tstate = wxPyBeginAllowThreads();
23615 result = wxDateTime::GetWeekDayName(arg1,arg2);
23616 wxPyEndAllowThreads(__tstate);
23617 if (PyErr_Occurred()) SWIG_fail;
23618 }
23619 {
23620 #if wxUSE_UNICODE
23621 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23622 #else
23623 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23624 #endif
23625 }
23626 return resultobj;
23627 fail:
23628 return NULL;
23629 }
23630
23631
23632 SWIGINTERN PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23633 PyObject *resultobj = 0;
23634 PyObject *result = 0 ;
23635
23636 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetAmPmStrings",0,0,0)) SWIG_fail;
23637 {
23638 PyThreadState* __tstate = wxPyBeginAllowThreads();
23639 result = (PyObject *)wxDateTime_GetAmPmStrings();
23640 wxPyEndAllowThreads(__tstate);
23641 if (PyErr_Occurred()) SWIG_fail;
23642 }
23643 resultobj = result;
23644 return resultobj;
23645 fail:
23646 return NULL;
23647 }
23648
23649
23650 SWIGINTERN PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23651 PyObject *resultobj = 0;
23652 int arg1 = (int) wxDateTime::Inv_Year ;
23653 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23654 bool result;
23655 int val1 ;
23656 int ecode1 = 0 ;
23657 int val2 ;
23658 int ecode2 = 0 ;
23659 PyObject * obj0 = 0 ;
23660 PyObject * obj1 = 0 ;
23661 char * kwnames[] = {
23662 (char *) "year",(char *) "country", NULL
23663 };
23664
23665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) SWIG_fail;
23666 if (obj0) {
23667 ecode1 = SWIG_AsVal_int(obj0, &val1);
23668 if (!SWIG_IsOK(ecode1)) {
23669 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "1"" of type '" "int""'");
23670 }
23671 arg1 = static_cast< int >(val1);
23672 }
23673 if (obj1) {
23674 ecode2 = SWIG_AsVal_int(obj1, &val2);
23675 if (!SWIG_IsOK(ecode2)) {
23676 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23677 }
23678 arg2 = static_cast< wxDateTime::Country >(val2);
23679 }
23680 {
23681 PyThreadState* __tstate = wxPyBeginAllowThreads();
23682 result = (bool)wxDateTime::IsDSTApplicable(arg1,arg2);
23683 wxPyEndAllowThreads(__tstate);
23684 if (PyErr_Occurred()) SWIG_fail;
23685 }
23686 {
23687 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23688 }
23689 return resultobj;
23690 fail:
23691 return NULL;
23692 }
23693
23694
23695 SWIGINTERN PyObject *_wrap_DateTime_GetBeginDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23696 PyObject *resultobj = 0;
23697 int arg1 = (int) wxDateTime::Inv_Year ;
23698 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23699 wxDateTime result;
23700 int val1 ;
23701 int ecode1 = 0 ;
23702 int val2 ;
23703 int ecode2 = 0 ;
23704 PyObject * obj0 = 0 ;
23705 PyObject * obj1 = 0 ;
23706 char * kwnames[] = {
23707 (char *) "year",(char *) "country", NULL
23708 };
23709
23710 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) SWIG_fail;
23711 if (obj0) {
23712 ecode1 = SWIG_AsVal_int(obj0, &val1);
23713 if (!SWIG_IsOK(ecode1)) {
23714 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetBeginDST" "', expected argument " "1"" of type '" "int""'");
23715 }
23716 arg1 = static_cast< int >(val1);
23717 }
23718 if (obj1) {
23719 ecode2 = SWIG_AsVal_int(obj1, &val2);
23720 if (!SWIG_IsOK(ecode2)) {
23721 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetBeginDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23722 }
23723 arg2 = static_cast< wxDateTime::Country >(val2);
23724 }
23725 {
23726 PyThreadState* __tstate = wxPyBeginAllowThreads();
23727 result = wxDateTime::GetBeginDST(arg1,arg2);
23728 wxPyEndAllowThreads(__tstate);
23729 if (PyErr_Occurred()) SWIG_fail;
23730 }
23731 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23732 return resultobj;
23733 fail:
23734 return NULL;
23735 }
23736
23737
23738 SWIGINTERN PyObject *_wrap_DateTime_GetEndDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23739 PyObject *resultobj = 0;
23740 int arg1 = (int) wxDateTime::Inv_Year ;
23741 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23742 wxDateTime result;
23743 int val1 ;
23744 int ecode1 = 0 ;
23745 int val2 ;
23746 int ecode2 = 0 ;
23747 PyObject * obj0 = 0 ;
23748 PyObject * obj1 = 0 ;
23749 char * kwnames[] = {
23750 (char *) "year",(char *) "country", NULL
23751 };
23752
23753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) SWIG_fail;
23754 if (obj0) {
23755 ecode1 = SWIG_AsVal_int(obj0, &val1);
23756 if (!SWIG_IsOK(ecode1)) {
23757 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetEndDST" "', expected argument " "1"" of type '" "int""'");
23758 }
23759 arg1 = static_cast< int >(val1);
23760 }
23761 if (obj1) {
23762 ecode2 = SWIG_AsVal_int(obj1, &val2);
23763 if (!SWIG_IsOK(ecode2)) {
23764 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetEndDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23765 }
23766 arg2 = static_cast< wxDateTime::Country >(val2);
23767 }
23768 {
23769 PyThreadState* __tstate = wxPyBeginAllowThreads();
23770 result = wxDateTime::GetEndDST(arg1,arg2);
23771 wxPyEndAllowThreads(__tstate);
23772 if (PyErr_Occurred()) SWIG_fail;
23773 }
23774 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23775 return resultobj;
23776 fail:
23777 return NULL;
23778 }
23779
23780
23781 SWIGINTERN PyObject *_wrap_DateTime_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23782 PyObject *resultobj = 0;
23783 wxDateTime result;
23784
23785 if (!SWIG_Python_UnpackTuple(args,"DateTime_Now",0,0,0)) SWIG_fail;
23786 {
23787 PyThreadState* __tstate = wxPyBeginAllowThreads();
23788 result = wxDateTime::Now();
23789 wxPyEndAllowThreads(__tstate);
23790 if (PyErr_Occurred()) SWIG_fail;
23791 }
23792 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23793 return resultobj;
23794 fail:
23795 return NULL;
23796 }
23797
23798
23799 SWIGINTERN PyObject *_wrap_DateTime_UNow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23800 PyObject *resultobj = 0;
23801 wxDateTime result;
23802
23803 if (!SWIG_Python_UnpackTuple(args,"DateTime_UNow",0,0,0)) SWIG_fail;
23804 {
23805 PyThreadState* __tstate = wxPyBeginAllowThreads();
23806 result = wxDateTime::UNow();
23807 wxPyEndAllowThreads(__tstate);
23808 if (PyErr_Occurred()) SWIG_fail;
23809 }
23810 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23811 return resultobj;
23812 fail:
23813 return NULL;
23814 }
23815
23816
23817 SWIGINTERN PyObject *_wrap_DateTime_Today(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23818 PyObject *resultobj = 0;
23819 wxDateTime result;
23820
23821 if (!SWIG_Python_UnpackTuple(args,"DateTime_Today",0,0,0)) SWIG_fail;
23822 {
23823 PyThreadState* __tstate = wxPyBeginAllowThreads();
23824 result = wxDateTime::Today();
23825 wxPyEndAllowThreads(__tstate);
23826 if (PyErr_Occurred()) SWIG_fail;
23827 }
23828 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23829 return resultobj;
23830 fail:
23831 return NULL;
23832 }
23833
23834
23835 SWIGINTERN PyObject *_wrap_new_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23836 PyObject *resultobj = 0;
23837 wxDateTime *result = 0 ;
23838
23839 if (!SWIG_Python_UnpackTuple(args,"new_DateTime",0,0,0)) SWIG_fail;
23840 {
23841 PyThreadState* __tstate = wxPyBeginAllowThreads();
23842 result = (wxDateTime *)new wxDateTime();
23843 wxPyEndAllowThreads(__tstate);
23844 if (PyErr_Occurred()) SWIG_fail;
23845 }
23846 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_NEW | 0 );
23847 return resultobj;
23848 fail:
23849 return NULL;
23850 }
23851
23852
23853 SWIGINTERN PyObject *_wrap_new_DateTimeFromTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23854 PyObject *resultobj = 0;
23855 time_t arg1 ;
23856 wxDateTime *result = 0 ;
23857 unsigned int val1 ;
23858 int ecode1 = 0 ;
23859 PyObject * obj0 = 0 ;
23860 char * kwnames[] = {
23861 (char *) "timet", NULL
23862 };
23863
23864 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) SWIG_fail;
23865 ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
23866 if (!SWIG_IsOK(ecode1)) {
23867 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromTimeT" "', expected argument " "1"" of type '" "time_t""'");
23868 }
23869 arg1 = static_cast< time_t >(val1);
23870 {
23871 PyThreadState* __tstate = wxPyBeginAllowThreads();
23872 result = (wxDateTime *)new wxDateTime(arg1);
23873 wxPyEndAllowThreads(__tstate);
23874 if (PyErr_Occurred()) SWIG_fail;
23875 }
23876 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23877 return resultobj;
23878 fail:
23879 return NULL;
23880 }
23881
23882
23883 SWIGINTERN PyObject *_wrap_new_DateTimeFromJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23884 PyObject *resultobj = 0;
23885 double arg1 ;
23886 wxDateTime *result = 0 ;
23887 double val1 ;
23888 int ecode1 = 0 ;
23889 PyObject * obj0 = 0 ;
23890 char * kwnames[] = {
23891 (char *) "jdn", NULL
23892 };
23893
23894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) SWIG_fail;
23895 ecode1 = SWIG_AsVal_double(obj0, &val1);
23896 if (!SWIG_IsOK(ecode1)) {
23897 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromJDN" "', expected argument " "1"" of type '" "double""'");
23898 }
23899 arg1 = static_cast< double >(val1);
23900 {
23901 PyThreadState* __tstate = wxPyBeginAllowThreads();
23902 result = (wxDateTime *)new wxDateTime(arg1);
23903 wxPyEndAllowThreads(__tstate);
23904 if (PyErr_Occurred()) SWIG_fail;
23905 }
23906 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23907 return resultobj;
23908 fail:
23909 return NULL;
23910 }
23911
23912
23913 SWIGINTERN PyObject *_wrap_new_DateTimeFromHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23914 PyObject *resultobj = 0;
23915 int arg1 ;
23916 int arg2 = (int) 0 ;
23917 int arg3 = (int) 0 ;
23918 int arg4 = (int) 0 ;
23919 wxDateTime *result = 0 ;
23920 int val1 ;
23921 int ecode1 = 0 ;
23922 int val2 ;
23923 int ecode2 = 0 ;
23924 int val3 ;
23925 int ecode3 = 0 ;
23926 int val4 ;
23927 int ecode4 = 0 ;
23928 PyObject * obj0 = 0 ;
23929 PyObject * obj1 = 0 ;
23930 PyObject * obj2 = 0 ;
23931 PyObject * obj3 = 0 ;
23932 char * kwnames[] = {
23933 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
23934 };
23935
23936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23937 ecode1 = SWIG_AsVal_int(obj0, &val1);
23938 if (!SWIG_IsOK(ecode1)) {
23939 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromHMS" "', expected argument " "1"" of type '" "int""'");
23940 }
23941 arg1 = static_cast< int >(val1);
23942 if (obj1) {
23943 ecode2 = SWIG_AsVal_int(obj1, &val2);
23944 if (!SWIG_IsOK(ecode2)) {
23945 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromHMS" "', expected argument " "2"" of type '" "int""'");
23946 }
23947 arg2 = static_cast< int >(val2);
23948 }
23949 if (obj2) {
23950 ecode3 = SWIG_AsVal_int(obj2, &val3);
23951 if (!SWIG_IsOK(ecode3)) {
23952 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromHMS" "', expected argument " "3"" of type '" "int""'");
23953 }
23954 arg3 = static_cast< int >(val3);
23955 }
23956 if (obj3) {
23957 ecode4 = SWIG_AsVal_int(obj3, &val4);
23958 if (!SWIG_IsOK(ecode4)) {
23959 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromHMS" "', expected argument " "4"" of type '" "int""'");
23960 }
23961 arg4 = static_cast< int >(val4);
23962 }
23963 {
23964 PyThreadState* __tstate = wxPyBeginAllowThreads();
23965 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
23966 wxPyEndAllowThreads(__tstate);
23967 if (PyErr_Occurred()) SWIG_fail;
23968 }
23969 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23970 return resultobj;
23971 fail:
23972 return NULL;
23973 }
23974
23975
23976 SWIGINTERN PyObject *_wrap_new_DateTimeFromDMY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23977 PyObject *resultobj = 0;
23978 int arg1 ;
23979 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23980 int arg3 = (int) wxDateTime::Inv_Year ;
23981 int arg4 = (int) 0 ;
23982 int arg5 = (int) 0 ;
23983 int arg6 = (int) 0 ;
23984 int arg7 = (int) 0 ;
23985 wxDateTime *result = 0 ;
23986 int val1 ;
23987 int ecode1 = 0 ;
23988 int val2 ;
23989 int ecode2 = 0 ;
23990 int val3 ;
23991 int ecode3 = 0 ;
23992 int val4 ;
23993 int ecode4 = 0 ;
23994 int val5 ;
23995 int ecode5 = 0 ;
23996 int val6 ;
23997 int ecode6 = 0 ;
23998 int val7 ;
23999 int ecode7 = 0 ;
24000 PyObject * obj0 = 0 ;
24001 PyObject * obj1 = 0 ;
24002 PyObject * obj2 = 0 ;
24003 PyObject * obj3 = 0 ;
24004 PyObject * obj4 = 0 ;
24005 PyObject * obj5 = 0 ;
24006 PyObject * obj6 = 0 ;
24007 char * kwnames[] = {
24008 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
24009 };
24010
24011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
24012 ecode1 = SWIG_AsVal_int(obj0, &val1);
24013 if (!SWIG_IsOK(ecode1)) {
24014 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromDMY" "', expected argument " "1"" of type '" "int""'");
24015 }
24016 arg1 = static_cast< int >(val1);
24017 if (obj1) {
24018 ecode2 = SWIG_AsVal_int(obj1, &val2);
24019 if (!SWIG_IsOK(ecode2)) {
24020 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromDMY" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24021 }
24022 arg2 = static_cast< wxDateTime::Month >(val2);
24023 }
24024 if (obj2) {
24025 ecode3 = SWIG_AsVal_int(obj2, &val3);
24026 if (!SWIG_IsOK(ecode3)) {
24027 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromDMY" "', expected argument " "3"" of type '" "int""'");
24028 }
24029 arg3 = static_cast< int >(val3);
24030 }
24031 if (obj3) {
24032 ecode4 = SWIG_AsVal_int(obj3, &val4);
24033 if (!SWIG_IsOK(ecode4)) {
24034 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromDMY" "', expected argument " "4"" of type '" "int""'");
24035 }
24036 arg4 = static_cast< int >(val4);
24037 }
24038 if (obj4) {
24039 ecode5 = SWIG_AsVal_int(obj4, &val5);
24040 if (!SWIG_IsOK(ecode5)) {
24041 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DateTimeFromDMY" "', expected argument " "5"" of type '" "int""'");
24042 }
24043 arg5 = static_cast< int >(val5);
24044 }
24045 if (obj5) {
24046 ecode6 = SWIG_AsVal_int(obj5, &val6);
24047 if (!SWIG_IsOK(ecode6)) {
24048 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DateTimeFromDMY" "', expected argument " "6"" of type '" "int""'");
24049 }
24050 arg6 = static_cast< int >(val6);
24051 }
24052 if (obj6) {
24053 ecode7 = SWIG_AsVal_int(obj6, &val7);
24054 if (!SWIG_IsOK(ecode7)) {
24055 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_DateTimeFromDMY" "', expected argument " "7"" of type '" "int""'");
24056 }
24057 arg7 = static_cast< int >(val7);
24058 }
24059 {
24060 PyThreadState* __tstate = wxPyBeginAllowThreads();
24061 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
24062 wxPyEndAllowThreads(__tstate);
24063 if (PyErr_Occurred()) SWIG_fail;
24064 }
24065 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24066 return resultobj;
24067 fail:
24068 return NULL;
24069 }
24070
24071
24072 SWIGINTERN PyObject *_wrap_new_DateTimeFromDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24073 PyObject *resultobj = 0;
24074 wxDateTime *arg1 = 0 ;
24075 wxDateTime *result = 0 ;
24076 void *argp1 = 0 ;
24077 int res1 = 0 ;
24078 PyObject * obj0 = 0 ;
24079 char * kwnames[] = {
24080 (char *) "date", NULL
24081 };
24082
24083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromDateTime",kwnames,&obj0)) SWIG_fail;
24084 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDateTime, 0 | 0);
24085 if (!SWIG_IsOK(res1)) {
24086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
24087 }
24088 if (!argp1) {
24089 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
24090 }
24091 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24092 {
24093 PyThreadState* __tstate = wxPyBeginAllowThreads();
24094 result = (wxDateTime *)new wxDateTime((wxDateTime const &)*arg1);
24095 wxPyEndAllowThreads(__tstate);
24096 if (PyErr_Occurred()) SWIG_fail;
24097 }
24098 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24099 return resultobj;
24100 fail:
24101 return NULL;
24102 }
24103
24104
24105 SWIGINTERN PyObject *_wrap_delete_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24106 PyObject *resultobj = 0;
24107 wxDateTime *arg1 = (wxDateTime *) 0 ;
24108 void *argp1 = 0 ;
24109 int res1 = 0 ;
24110 PyObject *swig_obj[1] ;
24111
24112 if (!args) SWIG_fail;
24113 swig_obj[0] = args;
24114 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
24115 if (!SWIG_IsOK(res1)) {
24116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
24117 }
24118 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24119 {
24120 PyThreadState* __tstate = wxPyBeginAllowThreads();
24121 delete arg1;
24122
24123 wxPyEndAllowThreads(__tstate);
24124 if (PyErr_Occurred()) SWIG_fail;
24125 }
24126 resultobj = SWIG_Py_Void();
24127 return resultobj;
24128 fail:
24129 return NULL;
24130 }
24131
24132
24133 SWIGINTERN PyObject *_wrap_DateTime_SetToCurrent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24134 PyObject *resultobj = 0;
24135 wxDateTime *arg1 = (wxDateTime *) 0 ;
24136 wxDateTime *result = 0 ;
24137 void *argp1 = 0 ;
24138 int res1 = 0 ;
24139 PyObject *swig_obj[1] ;
24140
24141 if (!args) SWIG_fail;
24142 swig_obj[0] = args;
24143 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24144 if (!SWIG_IsOK(res1)) {
24145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToCurrent" "', expected argument " "1"" of type '" "wxDateTime *""'");
24146 }
24147 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24148 {
24149 PyThreadState* __tstate = wxPyBeginAllowThreads();
24150 {
24151 wxDateTime &_result_ref = (arg1)->SetToCurrent();
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_SetTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24165 PyObject *resultobj = 0;
24166 wxDateTime *arg1 = (wxDateTime *) 0 ;
24167 time_t arg2 ;
24168 wxDateTime *result = 0 ;
24169 void *argp1 = 0 ;
24170 int res1 = 0 ;
24171 unsigned int val2 ;
24172 int ecode2 = 0 ;
24173 PyObject * obj0 = 0 ;
24174 PyObject * obj1 = 0 ;
24175 char * kwnames[] = {
24176 (char *) "self",(char *) "timet", NULL
24177 };
24178
24179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) SWIG_fail;
24180 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24181 if (!SWIG_IsOK(res1)) {
24182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetTimeT" "', expected argument " "1"" of type '" "wxDateTime *""'");
24183 }
24184 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24185 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
24186 if (!SWIG_IsOK(ecode2)) {
24187 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetTimeT" "', expected argument " "2"" of type '" "time_t""'");
24188 }
24189 arg2 = static_cast< time_t >(val2);
24190 {
24191 PyThreadState* __tstate = wxPyBeginAllowThreads();
24192 {
24193 wxDateTime &_result_ref = (arg1)->Set(arg2);
24194 result = (wxDateTime *) &_result_ref;
24195 }
24196 wxPyEndAllowThreads(__tstate);
24197 if (PyErr_Occurred()) SWIG_fail;
24198 }
24199 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24200 return resultobj;
24201 fail:
24202 return NULL;
24203 }
24204
24205
24206 SWIGINTERN PyObject *_wrap_DateTime_SetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24207 PyObject *resultobj = 0;
24208 wxDateTime *arg1 = (wxDateTime *) 0 ;
24209 double arg2 ;
24210 wxDateTime *result = 0 ;
24211 void *argp1 = 0 ;
24212 int res1 = 0 ;
24213 double val2 ;
24214 int ecode2 = 0 ;
24215 PyObject * obj0 = 0 ;
24216 PyObject * obj1 = 0 ;
24217 char * kwnames[] = {
24218 (char *) "self",(char *) "jdn", NULL
24219 };
24220
24221 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) SWIG_fail;
24222 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24223 if (!SWIG_IsOK(res1)) {
24224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
24225 }
24226 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24227 ecode2 = SWIG_AsVal_double(obj1, &val2);
24228 if (!SWIG_IsOK(ecode2)) {
24229 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetJDN" "', expected argument " "2"" of type '" "double""'");
24230 }
24231 arg2 = static_cast< double >(val2);
24232 {
24233 PyThreadState* __tstate = wxPyBeginAllowThreads();
24234 {
24235 wxDateTime &_result_ref = (arg1)->Set(arg2);
24236 result = (wxDateTime *) &_result_ref;
24237 }
24238 wxPyEndAllowThreads(__tstate);
24239 if (PyErr_Occurred()) SWIG_fail;
24240 }
24241 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24242 return resultobj;
24243 fail:
24244 return NULL;
24245 }
24246
24247
24248 SWIGINTERN PyObject *_wrap_DateTime_SetHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24249 PyObject *resultobj = 0;
24250 wxDateTime *arg1 = (wxDateTime *) 0 ;
24251 int arg2 ;
24252 int arg3 = (int) 0 ;
24253 int arg4 = (int) 0 ;
24254 int arg5 = (int) 0 ;
24255 wxDateTime *result = 0 ;
24256 void *argp1 = 0 ;
24257 int res1 = 0 ;
24258 int val2 ;
24259 int ecode2 = 0 ;
24260 int val3 ;
24261 int ecode3 = 0 ;
24262 int val4 ;
24263 int ecode4 = 0 ;
24264 int val5 ;
24265 int ecode5 = 0 ;
24266 PyObject * obj0 = 0 ;
24267 PyObject * obj1 = 0 ;
24268 PyObject * obj2 = 0 ;
24269 PyObject * obj3 = 0 ;
24270 PyObject * obj4 = 0 ;
24271 char * kwnames[] = {
24272 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
24273 };
24274
24275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
24276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24277 if (!SWIG_IsOK(res1)) {
24278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHMS" "', expected argument " "1"" of type '" "wxDateTime *""'");
24279 }
24280 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24281 ecode2 = SWIG_AsVal_int(obj1, &val2);
24282 if (!SWIG_IsOK(ecode2)) {
24283 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHMS" "', expected argument " "2"" of type '" "int""'");
24284 }
24285 arg2 = static_cast< int >(val2);
24286 if (obj2) {
24287 ecode3 = SWIG_AsVal_int(obj2, &val3);
24288 if (!SWIG_IsOK(ecode3)) {
24289 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetHMS" "', expected argument " "3"" of type '" "int""'");
24290 }
24291 arg3 = static_cast< int >(val3);
24292 }
24293 if (obj3) {
24294 ecode4 = SWIG_AsVal_int(obj3, &val4);
24295 if (!SWIG_IsOK(ecode4)) {
24296 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetHMS" "', expected argument " "4"" of type '" "int""'");
24297 }
24298 arg4 = static_cast< int >(val4);
24299 }
24300 if (obj4) {
24301 ecode5 = SWIG_AsVal_int(obj4, &val5);
24302 if (!SWIG_IsOK(ecode5)) {
24303 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetHMS" "', expected argument " "5"" of type '" "int""'");
24304 }
24305 arg5 = static_cast< int >(val5);
24306 }
24307 {
24308 PyThreadState* __tstate = wxPyBeginAllowThreads();
24309 {
24310 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
24311 result = (wxDateTime *) &_result_ref;
24312 }
24313 wxPyEndAllowThreads(__tstate);
24314 if (PyErr_Occurred()) SWIG_fail;
24315 }
24316 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24317 return resultobj;
24318 fail:
24319 return NULL;
24320 }
24321
24322
24323 SWIGINTERN PyObject *_wrap_DateTime_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24324 PyObject *resultobj = 0;
24325 wxDateTime *arg1 = (wxDateTime *) 0 ;
24326 int arg2 ;
24327 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24328 int arg4 = (int) wxDateTime::Inv_Year ;
24329 int arg5 = (int) 0 ;
24330 int arg6 = (int) 0 ;
24331 int arg7 = (int) 0 ;
24332 int arg8 = (int) 0 ;
24333 wxDateTime *result = 0 ;
24334 void *argp1 = 0 ;
24335 int res1 = 0 ;
24336 int val2 ;
24337 int ecode2 = 0 ;
24338 int val3 ;
24339 int ecode3 = 0 ;
24340 int val4 ;
24341 int ecode4 = 0 ;
24342 int val5 ;
24343 int ecode5 = 0 ;
24344 int val6 ;
24345 int ecode6 = 0 ;
24346 int val7 ;
24347 int ecode7 = 0 ;
24348 int val8 ;
24349 int ecode8 = 0 ;
24350 PyObject * obj0 = 0 ;
24351 PyObject * obj1 = 0 ;
24352 PyObject * obj2 = 0 ;
24353 PyObject * obj3 = 0 ;
24354 PyObject * obj4 = 0 ;
24355 PyObject * obj5 = 0 ;
24356 PyObject * obj6 = 0 ;
24357 PyObject * obj7 = 0 ;
24358 char * kwnames[] = {
24359 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
24360 };
24361
24362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
24363 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24364 if (!SWIG_IsOK(res1)) {
24365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Set" "', expected argument " "1"" of type '" "wxDateTime *""'");
24366 }
24367 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24368 ecode2 = SWIG_AsVal_int(obj1, &val2);
24369 if (!SWIG_IsOK(ecode2)) {
24370 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_Set" "', expected argument " "2"" of type '" "int""'");
24371 }
24372 arg2 = static_cast< int >(val2);
24373 if (obj2) {
24374 ecode3 = SWIG_AsVal_int(obj2, &val3);
24375 if (!SWIG_IsOK(ecode3)) {
24376 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_Set" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
24377 }
24378 arg3 = static_cast< wxDateTime::Month >(val3);
24379 }
24380 if (obj3) {
24381 ecode4 = SWIG_AsVal_int(obj3, &val4);
24382 if (!SWIG_IsOK(ecode4)) {
24383 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_Set" "', expected argument " "4"" of type '" "int""'");
24384 }
24385 arg4 = static_cast< int >(val4);
24386 }
24387 if (obj4) {
24388 ecode5 = SWIG_AsVal_int(obj4, &val5);
24389 if (!SWIG_IsOK(ecode5)) {
24390 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_Set" "', expected argument " "5"" of type '" "int""'");
24391 }
24392 arg5 = static_cast< int >(val5);
24393 }
24394 if (obj5) {
24395 ecode6 = SWIG_AsVal_int(obj5, &val6);
24396 if (!SWIG_IsOK(ecode6)) {
24397 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DateTime_Set" "', expected argument " "6"" of type '" "int""'");
24398 }
24399 arg6 = static_cast< int >(val6);
24400 }
24401 if (obj6) {
24402 ecode7 = SWIG_AsVal_int(obj6, &val7);
24403 if (!SWIG_IsOK(ecode7)) {
24404 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "DateTime_Set" "', expected argument " "7"" of type '" "int""'");
24405 }
24406 arg7 = static_cast< int >(val7);
24407 }
24408 if (obj7) {
24409 ecode8 = SWIG_AsVal_int(obj7, &val8);
24410 if (!SWIG_IsOK(ecode8)) {
24411 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "DateTime_Set" "', expected argument " "8"" of type '" "int""'");
24412 }
24413 arg8 = static_cast< int >(val8);
24414 }
24415 {
24416 PyThreadState* __tstate = wxPyBeginAllowThreads();
24417 {
24418 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
24419 result = (wxDateTime *) &_result_ref;
24420 }
24421 wxPyEndAllowThreads(__tstate);
24422 if (PyErr_Occurred()) SWIG_fail;
24423 }
24424 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24425 return resultobj;
24426 fail:
24427 return NULL;
24428 }
24429
24430
24431 SWIGINTERN PyObject *_wrap_DateTime_ResetTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24432 PyObject *resultobj = 0;
24433 wxDateTime *arg1 = (wxDateTime *) 0 ;
24434 wxDateTime *result = 0 ;
24435 void *argp1 = 0 ;
24436 int res1 = 0 ;
24437 PyObject *swig_obj[1] ;
24438
24439 if (!args) SWIG_fail;
24440 swig_obj[0] = args;
24441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24442 if (!SWIG_IsOK(res1)) {
24443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ResetTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
24444 }
24445 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24446 {
24447 PyThreadState* __tstate = wxPyBeginAllowThreads();
24448 {
24449 wxDateTime &_result_ref = (arg1)->ResetTime();
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_GetDateOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24463 PyObject *resultobj = 0;
24464 wxDateTime *arg1 = (wxDateTime *) 0 ;
24465 wxDateTime result;
24466 void *argp1 = 0 ;
24467 int res1 = 0 ;
24468 PyObject *swig_obj[1] ;
24469
24470 if (!args) SWIG_fail;
24471 swig_obj[0] = args;
24472 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24473 if (!SWIG_IsOK(res1)) {
24474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDateOnly" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24475 }
24476 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24477 {
24478 PyThreadState* __tstate = wxPyBeginAllowThreads();
24479 result = ((wxDateTime const *)arg1)->GetDateOnly();
24480 wxPyEndAllowThreads(__tstate);
24481 if (PyErr_Occurred()) SWIG_fail;
24482 }
24483 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24484 return resultobj;
24485 fail:
24486 return NULL;
24487 }
24488
24489
24490 SWIGINTERN PyObject *_wrap_DateTime_SetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24491 PyObject *resultobj = 0;
24492 wxDateTime *arg1 = (wxDateTime *) 0 ;
24493 int arg2 ;
24494 wxDateTime *result = 0 ;
24495 void *argp1 = 0 ;
24496 int res1 = 0 ;
24497 int val2 ;
24498 int ecode2 = 0 ;
24499 PyObject * obj0 = 0 ;
24500 PyObject * obj1 = 0 ;
24501 char * kwnames[] = {
24502 (char *) "self",(char *) "year", NULL
24503 };
24504
24505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) SWIG_fail;
24506 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24507 if (!SWIG_IsOK(res1)) {
24508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetYear" "', expected argument " "1"" of type '" "wxDateTime *""'");
24509 }
24510 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24511 ecode2 = SWIG_AsVal_int(obj1, &val2);
24512 if (!SWIG_IsOK(ecode2)) {
24513 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetYear" "', expected argument " "2"" of type '" "int""'");
24514 }
24515 arg2 = static_cast< int >(val2);
24516 {
24517 PyThreadState* __tstate = wxPyBeginAllowThreads();
24518 {
24519 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
24520 result = (wxDateTime *) &_result_ref;
24521 }
24522 wxPyEndAllowThreads(__tstate);
24523 if (PyErr_Occurred()) SWIG_fail;
24524 }
24525 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24526 return resultobj;
24527 fail:
24528 return NULL;
24529 }
24530
24531
24532 SWIGINTERN PyObject *_wrap_DateTime_SetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24533 PyObject *resultobj = 0;
24534 wxDateTime *arg1 = (wxDateTime *) 0 ;
24535 wxDateTime::Month arg2 ;
24536 wxDateTime *result = 0 ;
24537 void *argp1 = 0 ;
24538 int res1 = 0 ;
24539 int val2 ;
24540 int ecode2 = 0 ;
24541 PyObject * obj0 = 0 ;
24542 PyObject * obj1 = 0 ;
24543 char * kwnames[] = {
24544 (char *) "self",(char *) "month", NULL
24545 };
24546
24547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
24548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24549 if (!SWIG_IsOK(res1)) {
24550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMonth" "', expected argument " "1"" of type '" "wxDateTime *""'");
24551 }
24552 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24553 ecode2 = SWIG_AsVal_int(obj1, &val2);
24554 if (!SWIG_IsOK(ecode2)) {
24555 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMonth" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24556 }
24557 arg2 = static_cast< wxDateTime::Month >(val2);
24558 {
24559 PyThreadState* __tstate = wxPyBeginAllowThreads();
24560 {
24561 wxDateTime &_result_ref = (arg1)->SetMonth(arg2);
24562 result = (wxDateTime *) &_result_ref;
24563 }
24564 wxPyEndAllowThreads(__tstate);
24565 if (PyErr_Occurred()) SWIG_fail;
24566 }
24567 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24568 return resultobj;
24569 fail:
24570 return NULL;
24571 }
24572
24573
24574 SWIGINTERN PyObject *_wrap_DateTime_SetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24575 PyObject *resultobj = 0;
24576 wxDateTime *arg1 = (wxDateTime *) 0 ;
24577 int arg2 ;
24578 wxDateTime *result = 0 ;
24579 void *argp1 = 0 ;
24580 int res1 = 0 ;
24581 int val2 ;
24582 int ecode2 = 0 ;
24583 PyObject * obj0 = 0 ;
24584 PyObject * obj1 = 0 ;
24585 char * kwnames[] = {
24586 (char *) "self",(char *) "day", NULL
24587 };
24588
24589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) SWIG_fail;
24590 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24591 if (!SWIG_IsOK(res1)) {
24592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24593 }
24594 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24595 ecode2 = SWIG_AsVal_int(obj1, &val2);
24596 if (!SWIG_IsOK(ecode2)) {
24597 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetDay" "', expected argument " "2"" of type '" "int""'");
24598 }
24599 arg2 = static_cast< int >(val2);
24600 {
24601 PyThreadState* __tstate = wxPyBeginAllowThreads();
24602 {
24603 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
24604 result = (wxDateTime *) &_result_ref;
24605 }
24606 wxPyEndAllowThreads(__tstate);
24607 if (PyErr_Occurred()) SWIG_fail;
24608 }
24609 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24610 return resultobj;
24611 fail:
24612 return NULL;
24613 }
24614
24615
24616 SWIGINTERN PyObject *_wrap_DateTime_SetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24617 PyObject *resultobj = 0;
24618 wxDateTime *arg1 = (wxDateTime *) 0 ;
24619 int arg2 ;
24620 wxDateTime *result = 0 ;
24621 void *argp1 = 0 ;
24622 int res1 = 0 ;
24623 int val2 ;
24624 int ecode2 = 0 ;
24625 PyObject * obj0 = 0 ;
24626 PyObject * obj1 = 0 ;
24627 char * kwnames[] = {
24628 (char *) "self",(char *) "hour", NULL
24629 };
24630
24631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) SWIG_fail;
24632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24633 if (!SWIG_IsOK(res1)) {
24634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHour" "', expected argument " "1"" of type '" "wxDateTime *""'");
24635 }
24636 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24637 ecode2 = SWIG_AsVal_int(obj1, &val2);
24638 if (!SWIG_IsOK(ecode2)) {
24639 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHour" "', expected argument " "2"" of type '" "int""'");
24640 }
24641 arg2 = static_cast< int >(val2);
24642 {
24643 PyThreadState* __tstate = wxPyBeginAllowThreads();
24644 {
24645 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
24646 result = (wxDateTime *) &_result_ref;
24647 }
24648 wxPyEndAllowThreads(__tstate);
24649 if (PyErr_Occurred()) SWIG_fail;
24650 }
24651 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24652 return resultobj;
24653 fail:
24654 return NULL;
24655 }
24656
24657
24658 SWIGINTERN PyObject *_wrap_DateTime_SetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24659 PyObject *resultobj = 0;
24660 wxDateTime *arg1 = (wxDateTime *) 0 ;
24661 int arg2 ;
24662 wxDateTime *result = 0 ;
24663 void *argp1 = 0 ;
24664 int res1 = 0 ;
24665 int val2 ;
24666 int ecode2 = 0 ;
24667 PyObject * obj0 = 0 ;
24668 PyObject * obj1 = 0 ;
24669 char * kwnames[] = {
24670 (char *) "self",(char *) "minute", NULL
24671 };
24672
24673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
24674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24675 if (!SWIG_IsOK(res1)) {
24676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMinute" "', expected argument " "1"" of type '" "wxDateTime *""'");
24677 }
24678 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24679 ecode2 = SWIG_AsVal_int(obj1, &val2);
24680 if (!SWIG_IsOK(ecode2)) {
24681 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMinute" "', expected argument " "2"" of type '" "int""'");
24682 }
24683 arg2 = static_cast< int >(val2);
24684 {
24685 PyThreadState* __tstate = wxPyBeginAllowThreads();
24686 {
24687 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
24688 result = (wxDateTime *) &_result_ref;
24689 }
24690 wxPyEndAllowThreads(__tstate);
24691 if (PyErr_Occurred()) SWIG_fail;
24692 }
24693 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24694 return resultobj;
24695 fail:
24696 return NULL;
24697 }
24698
24699
24700 SWIGINTERN PyObject *_wrap_DateTime_SetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24701 PyObject *resultobj = 0;
24702 wxDateTime *arg1 = (wxDateTime *) 0 ;
24703 int arg2 ;
24704 wxDateTime *result = 0 ;
24705 void *argp1 = 0 ;
24706 int res1 = 0 ;
24707 int val2 ;
24708 int ecode2 = 0 ;
24709 PyObject * obj0 = 0 ;
24710 PyObject * obj1 = 0 ;
24711 char * kwnames[] = {
24712 (char *) "self",(char *) "second", NULL
24713 };
24714
24715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
24716 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24717 if (!SWIG_IsOK(res1)) {
24718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetSecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
24719 }
24720 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24721 ecode2 = SWIG_AsVal_int(obj1, &val2);
24722 if (!SWIG_IsOK(ecode2)) {
24723 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetSecond" "', expected argument " "2"" of type '" "int""'");
24724 }
24725 arg2 = static_cast< int >(val2);
24726 {
24727 PyThreadState* __tstate = wxPyBeginAllowThreads();
24728 {
24729 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
24730 result = (wxDateTime *) &_result_ref;
24731 }
24732 wxPyEndAllowThreads(__tstate);
24733 if (PyErr_Occurred()) SWIG_fail;
24734 }
24735 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24736 return resultobj;
24737 fail:
24738 return NULL;
24739 }
24740
24741
24742 SWIGINTERN PyObject *_wrap_DateTime_SetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24743 PyObject *resultobj = 0;
24744 wxDateTime *arg1 = (wxDateTime *) 0 ;
24745 int arg2 ;
24746 wxDateTime *result = 0 ;
24747 void *argp1 = 0 ;
24748 int res1 = 0 ;
24749 int val2 ;
24750 int ecode2 = 0 ;
24751 PyObject * obj0 = 0 ;
24752 PyObject * obj1 = 0 ;
24753 char * kwnames[] = {
24754 (char *) "self",(char *) "millisecond", NULL
24755 };
24756
24757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
24758 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24759 if (!SWIG_IsOK(res1)) {
24760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMillisecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
24761 }
24762 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24763 ecode2 = SWIG_AsVal_int(obj1, &val2);
24764 if (!SWIG_IsOK(ecode2)) {
24765 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMillisecond" "', expected argument " "2"" of type '" "int""'");
24766 }
24767 arg2 = static_cast< int >(val2);
24768 {
24769 PyThreadState* __tstate = wxPyBeginAllowThreads();
24770 {
24771 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
24772 result = (wxDateTime *) &_result_ref;
24773 }
24774 wxPyEndAllowThreads(__tstate);
24775 if (PyErr_Occurred()) SWIG_fail;
24776 }
24777 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24778 return resultobj;
24779 fail:
24780 return NULL;
24781 }
24782
24783
24784 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24785 PyObject *resultobj = 0;
24786 wxDateTime *arg1 = (wxDateTime *) 0 ;
24787 wxDateTime::WeekDay arg2 ;
24788 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
24789 wxDateTime *result = 0 ;
24790 void *argp1 = 0 ;
24791 int res1 = 0 ;
24792 int val2 ;
24793 int ecode2 = 0 ;
24794 int val3 ;
24795 int ecode3 = 0 ;
24796 PyObject * obj0 = 0 ;
24797 PyObject * obj1 = 0 ;
24798 PyObject * obj2 = 0 ;
24799 char * kwnames[] = {
24800 (char *) "self",(char *) "weekday",(char *) "flags", NULL
24801 };
24802
24803 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24804 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24805 if (!SWIG_IsOK(res1)) {
24806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
24807 }
24808 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24809 ecode2 = SWIG_AsVal_int(obj1, &val2);
24810 if (!SWIG_IsOK(ecode2)) {
24811 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24812 }
24813 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24814 if (obj2) {
24815 ecode3 = SWIG_AsVal_int(obj2, &val3);
24816 if (!SWIG_IsOK(ecode3)) {
24817 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
24818 }
24819 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
24820 }
24821 {
24822 PyThreadState* __tstate = wxPyBeginAllowThreads();
24823 {
24824 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek(arg2,arg3);
24825 result = (wxDateTime *) &_result_ref;
24826 }
24827 wxPyEndAllowThreads(__tstate);
24828 if (PyErr_Occurred()) SWIG_fail;
24829 }
24830 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24831 return resultobj;
24832 fail:
24833 return NULL;
24834 }
24835
24836
24837 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24838 PyObject *resultobj = 0;
24839 wxDateTime *arg1 = (wxDateTime *) 0 ;
24840 wxDateTime::WeekDay arg2 ;
24841 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
24842 wxDateTime result;
24843 void *argp1 = 0 ;
24844 int res1 = 0 ;
24845 int val2 ;
24846 int ecode2 = 0 ;
24847 int val3 ;
24848 int ecode3 = 0 ;
24849 PyObject * obj0 = 0 ;
24850 PyObject * obj1 = 0 ;
24851 PyObject * obj2 = 0 ;
24852 char * kwnames[] = {
24853 (char *) "self",(char *) "weekday",(char *) "flags", NULL
24854 };
24855
24856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24857 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24858 if (!SWIG_IsOK(res1)) {
24859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
24860 }
24861 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24862 ecode2 = SWIG_AsVal_int(obj1, &val2);
24863 if (!SWIG_IsOK(ecode2)) {
24864 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24865 }
24866 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24867 if (obj2) {
24868 ecode3 = SWIG_AsVal_int(obj2, &val3);
24869 if (!SWIG_IsOK(ecode3)) {
24870 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
24871 }
24872 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
24873 }
24874 {
24875 PyThreadState* __tstate = wxPyBeginAllowThreads();
24876 result = (arg1)->GetWeekDayInSameWeek(arg2,arg3);
24877 wxPyEndAllowThreads(__tstate);
24878 if (PyErr_Occurred()) SWIG_fail;
24879 }
24880 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24881 return resultobj;
24882 fail:
24883 return NULL;
24884 }
24885
24886
24887 SWIGINTERN PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24888 PyObject *resultobj = 0;
24889 wxDateTime *arg1 = (wxDateTime *) 0 ;
24890 wxDateTime::WeekDay arg2 ;
24891 wxDateTime *result = 0 ;
24892 void *argp1 = 0 ;
24893 int res1 = 0 ;
24894 int val2 ;
24895 int ecode2 = 0 ;
24896 PyObject * obj0 = 0 ;
24897 PyObject * obj1 = 0 ;
24898 char * kwnames[] = {
24899 (char *) "self",(char *) "weekday", NULL
24900 };
24901
24902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24903 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24904 if (!SWIG_IsOK(res1)) {
24905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24906 }
24907 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24908 ecode2 = SWIG_AsVal_int(obj1, &val2);
24909 if (!SWIG_IsOK(ecode2)) {
24910 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24911 }
24912 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24913 {
24914 PyThreadState* __tstate = wxPyBeginAllowThreads();
24915 {
24916 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay(arg2);
24917 result = (wxDateTime *) &_result_ref;
24918 }
24919 wxPyEndAllowThreads(__tstate);
24920 if (PyErr_Occurred()) SWIG_fail;
24921 }
24922 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24923 return resultobj;
24924 fail:
24925 return NULL;
24926 }
24927
24928
24929 SWIGINTERN PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24930 PyObject *resultobj = 0;
24931 wxDateTime *arg1 = (wxDateTime *) 0 ;
24932 wxDateTime::WeekDay arg2 ;
24933 wxDateTime result;
24934 void *argp1 = 0 ;
24935 int res1 = 0 ;
24936 int val2 ;
24937 int ecode2 = 0 ;
24938 PyObject * obj0 = 0 ;
24939 PyObject * obj1 = 0 ;
24940 char * kwnames[] = {
24941 (char *) "self",(char *) "weekday", NULL
24942 };
24943
24944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24945 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24946 if (!SWIG_IsOK(res1)) {
24947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24948 }
24949 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24950 ecode2 = SWIG_AsVal_int(obj1, &val2);
24951 if (!SWIG_IsOK(ecode2)) {
24952 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24953 }
24954 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24955 {
24956 PyThreadState* __tstate = wxPyBeginAllowThreads();
24957 result = (arg1)->GetNextWeekDay(arg2);
24958 wxPyEndAllowThreads(__tstate);
24959 if (PyErr_Occurred()) SWIG_fail;
24960 }
24961 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24962 return resultobj;
24963 fail:
24964 return NULL;
24965 }
24966
24967
24968 SWIGINTERN PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24969 PyObject *resultobj = 0;
24970 wxDateTime *arg1 = (wxDateTime *) 0 ;
24971 wxDateTime::WeekDay arg2 ;
24972 wxDateTime *result = 0 ;
24973 void *argp1 = 0 ;
24974 int res1 = 0 ;
24975 int val2 ;
24976 int ecode2 = 0 ;
24977 PyObject * obj0 = 0 ;
24978 PyObject * obj1 = 0 ;
24979 char * kwnames[] = {
24980 (char *) "self",(char *) "weekday", NULL
24981 };
24982
24983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24985 if (!SWIG_IsOK(res1)) {
24986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24987 }
24988 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24989 ecode2 = SWIG_AsVal_int(obj1, &val2);
24990 if (!SWIG_IsOK(ecode2)) {
24991 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24992 }
24993 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24994 {
24995 PyThreadState* __tstate = wxPyBeginAllowThreads();
24996 {
24997 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay(arg2);
24998 result = (wxDateTime *) &_result_ref;
24999 }
25000 wxPyEndAllowThreads(__tstate);
25001 if (PyErr_Occurred()) SWIG_fail;
25002 }
25003 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25004 return resultobj;
25005 fail:
25006 return NULL;
25007 }
25008
25009
25010 SWIGINTERN PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25011 PyObject *resultobj = 0;
25012 wxDateTime *arg1 = (wxDateTime *) 0 ;
25013 wxDateTime::WeekDay arg2 ;
25014 wxDateTime result;
25015 void *argp1 = 0 ;
25016 int res1 = 0 ;
25017 int val2 ;
25018 int ecode2 = 0 ;
25019 PyObject * obj0 = 0 ;
25020 PyObject * obj1 = 0 ;
25021 char * kwnames[] = {
25022 (char *) "self",(char *) "weekday", NULL
25023 };
25024
25025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
25026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25027 if (!SWIG_IsOK(res1)) {
25028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25029 }
25030 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25031 ecode2 = SWIG_AsVal_int(obj1, &val2);
25032 if (!SWIG_IsOK(ecode2)) {
25033 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25034 }
25035 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25036 {
25037 PyThreadState* __tstate = wxPyBeginAllowThreads();
25038 result = (arg1)->GetPrevWeekDay(arg2);
25039 wxPyEndAllowThreads(__tstate);
25040 if (PyErr_Occurred()) SWIG_fail;
25041 }
25042 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25043 return resultobj;
25044 fail:
25045 return NULL;
25046 }
25047
25048
25049 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25050 PyObject *resultobj = 0;
25051 wxDateTime *arg1 = (wxDateTime *) 0 ;
25052 wxDateTime::WeekDay arg2 ;
25053 int arg3 = (int) 1 ;
25054 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25055 int arg5 = (int) wxDateTime::Inv_Year ;
25056 bool result;
25057 void *argp1 = 0 ;
25058 int res1 = 0 ;
25059 int val2 ;
25060 int ecode2 = 0 ;
25061 int val3 ;
25062 int ecode3 = 0 ;
25063 int val4 ;
25064 int ecode4 = 0 ;
25065 int val5 ;
25066 int ecode5 = 0 ;
25067 PyObject * obj0 = 0 ;
25068 PyObject * obj1 = 0 ;
25069 PyObject * obj2 = 0 ;
25070 PyObject * obj3 = 0 ;
25071 PyObject * obj4 = 0 ;
25072 char * kwnames[] = {
25073 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
25074 };
25075
25076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
25077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25078 if (!SWIG_IsOK(res1)) {
25079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25080 }
25081 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25082 ecode2 = SWIG_AsVal_int(obj1, &val2);
25083 if (!SWIG_IsOK(ecode2)) {
25084 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25085 }
25086 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25087 if (obj2) {
25088 ecode3 = SWIG_AsVal_int(obj2, &val3);
25089 if (!SWIG_IsOK(ecode3)) {
25090 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDay" "', expected argument " "3"" of type '" "int""'");
25091 }
25092 arg3 = static_cast< int >(val3);
25093 }
25094 if (obj3) {
25095 ecode4 = SWIG_AsVal_int(obj3, &val4);
25096 if (!SWIG_IsOK(ecode4)) {
25097 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToWeekDay" "', expected argument " "4"" of type '" "wxDateTime::Month""'");
25098 }
25099 arg4 = static_cast< wxDateTime::Month >(val4);
25100 }
25101 if (obj4) {
25102 ecode5 = SWIG_AsVal_int(obj4, &val5);
25103 if (!SWIG_IsOK(ecode5)) {
25104 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetToWeekDay" "', expected argument " "5"" of type '" "int""'");
25105 }
25106 arg5 = static_cast< int >(val5);
25107 }
25108 {
25109 PyThreadState* __tstate = wxPyBeginAllowThreads();
25110 result = (bool)(arg1)->SetToWeekDay(arg2,arg3,arg4,arg5);
25111 wxPyEndAllowThreads(__tstate);
25112 if (PyErr_Occurred()) SWIG_fail;
25113 }
25114 {
25115 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25116 }
25117 return resultobj;
25118 fail:
25119 return NULL;
25120 }
25121
25122
25123 SWIGINTERN PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25124 PyObject *resultobj = 0;
25125 wxDateTime *arg1 = (wxDateTime *) 0 ;
25126 wxDateTime::WeekDay arg2 ;
25127 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25128 int arg4 = (int) wxDateTime::Inv_Year ;
25129 bool result;
25130 void *argp1 = 0 ;
25131 int res1 = 0 ;
25132 int val2 ;
25133 int ecode2 = 0 ;
25134 int val3 ;
25135 int ecode3 = 0 ;
25136 int val4 ;
25137 int ecode4 = 0 ;
25138 PyObject * obj0 = 0 ;
25139 PyObject * obj1 = 0 ;
25140 PyObject * obj2 = 0 ;
25141 PyObject * obj3 = 0 ;
25142 char * kwnames[] = {
25143 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
25144 };
25145
25146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25147 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25148 if (!SWIG_IsOK(res1)) {
25149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25150 }
25151 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25152 ecode2 = SWIG_AsVal_int(obj1, &val2);
25153 if (!SWIG_IsOK(ecode2)) {
25154 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25155 }
25156 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25157 if (obj2) {
25158 ecode3 = SWIG_AsVal_int(obj2, &val3);
25159 if (!SWIG_IsOK(ecode3)) {
25160 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
25161 }
25162 arg3 = static_cast< wxDateTime::Month >(val3);
25163 }
25164 if (obj3) {
25165 ecode4 = SWIG_AsVal_int(obj3, &val4);
25166 if (!SWIG_IsOK(ecode4)) {
25167 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "4"" of type '" "int""'");
25168 }
25169 arg4 = static_cast< int >(val4);
25170 }
25171 {
25172 PyThreadState* __tstate = wxPyBeginAllowThreads();
25173 result = (bool)(arg1)->SetToLastWeekDay(arg2,arg3,arg4);
25174 wxPyEndAllowThreads(__tstate);
25175 if (PyErr_Occurred()) SWIG_fail;
25176 }
25177 {
25178 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25179 }
25180 return resultobj;
25181 fail:
25182 return NULL;
25183 }
25184
25185
25186 SWIGINTERN PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25187 PyObject *resultobj = 0;
25188 wxDateTime *arg1 = (wxDateTime *) 0 ;
25189 wxDateTime::WeekDay arg2 ;
25190 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25191 int arg4 = (int) wxDateTime::Inv_Year ;
25192 wxDateTime result;
25193 void *argp1 = 0 ;
25194 int res1 = 0 ;
25195 int val2 ;
25196 int ecode2 = 0 ;
25197 int val3 ;
25198 int ecode3 = 0 ;
25199 int val4 ;
25200 int ecode4 = 0 ;
25201 PyObject * obj0 = 0 ;
25202 PyObject * obj1 = 0 ;
25203 PyObject * obj2 = 0 ;
25204 PyObject * obj3 = 0 ;
25205 char * kwnames[] = {
25206 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
25207 };
25208
25209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25211 if (!SWIG_IsOK(res1)) {
25212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25213 }
25214 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25215 ecode2 = SWIG_AsVal_int(obj1, &val2);
25216 if (!SWIG_IsOK(ecode2)) {
25217 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25218 }
25219 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25220 if (obj2) {
25221 ecode3 = SWIG_AsVal_int(obj2, &val3);
25222 if (!SWIG_IsOK(ecode3)) {
25223 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
25224 }
25225 arg3 = static_cast< wxDateTime::Month >(val3);
25226 }
25227 if (obj3) {
25228 ecode4 = SWIG_AsVal_int(obj3, &val4);
25229 if (!SWIG_IsOK(ecode4)) {
25230 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "4"" of type '" "int""'");
25231 }
25232 arg4 = static_cast< int >(val4);
25233 }
25234 {
25235 PyThreadState* __tstate = wxPyBeginAllowThreads();
25236 result = (arg1)->GetLastWeekDay(arg2,arg3,arg4);
25237 wxPyEndAllowThreads(__tstate);
25238 if (PyErr_Occurred()) SWIG_fail;
25239 }
25240 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25241 return resultobj;
25242 fail:
25243 return NULL;
25244 }
25245
25246
25247 SWIGINTERN PyObject *_wrap_DateTime_SetToTheWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25248 PyObject *resultobj = 0;
25249 wxDateTime *arg1 = (wxDateTime *) 0 ;
25250 int arg2 ;
25251 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
25252 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25253 bool result;
25254 void *argp1 = 0 ;
25255 int res1 = 0 ;
25256 int val2 ;
25257 int ecode2 = 0 ;
25258 int val3 ;
25259 int ecode3 = 0 ;
25260 int val4 ;
25261 int ecode4 = 0 ;
25262 PyObject * obj0 = 0 ;
25263 PyObject * obj1 = 0 ;
25264 PyObject * obj2 = 0 ;
25265 PyObject * obj3 = 0 ;
25266 char * kwnames[] = {
25267 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
25268 };
25269
25270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25272 if (!SWIG_IsOK(res1)) {
25273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToTheWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
25274 }
25275 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25276 ecode2 = SWIG_AsVal_int(obj1, &val2);
25277 if (!SWIG_IsOK(ecode2)) {
25278 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToTheWeek" "', expected argument " "2"" of type '" "int""'");
25279 }
25280 arg2 = static_cast< int >(val2);
25281 if (obj2) {
25282 ecode3 = SWIG_AsVal_int(obj2, &val3);
25283 if (!SWIG_IsOK(ecode3)) {
25284 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToTheWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
25285 }
25286 arg3 = static_cast< wxDateTime::WeekDay >(val3);
25287 }
25288 if (obj3) {
25289 ecode4 = SWIG_AsVal_int(obj3, &val4);
25290 if (!SWIG_IsOK(ecode4)) {
25291 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToTheWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
25292 }
25293 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
25294 }
25295 {
25296 PyThreadState* __tstate = wxPyBeginAllowThreads();
25297 result = (bool)(arg1)->SetToTheWeek(arg2,arg3,arg4);
25298 wxPyEndAllowThreads(__tstate);
25299 if (PyErr_Occurred()) SWIG_fail;
25300 }
25301 {
25302 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25303 }
25304 return resultobj;
25305 fail:
25306 return NULL;
25307 }
25308
25309
25310 SWIGINTERN PyObject *_wrap_DateTime_GetWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25311 PyObject *resultobj = 0;
25312 wxDateTime *arg1 = (wxDateTime *) 0 ;
25313 int arg2 ;
25314 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
25315 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25316 wxDateTime result;
25317 void *argp1 = 0 ;
25318 int res1 = 0 ;
25319 int val2 ;
25320 int ecode2 = 0 ;
25321 int val3 ;
25322 int ecode3 = 0 ;
25323 int val4 ;
25324 int ecode4 = 0 ;
25325 PyObject * obj0 = 0 ;
25326 PyObject * obj1 = 0 ;
25327 PyObject * obj2 = 0 ;
25328 PyObject * obj3 = 0 ;
25329 char * kwnames[] = {
25330 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
25331 };
25332
25333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25334 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25335 if (!SWIG_IsOK(res1)) {
25336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
25337 }
25338 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25339 ecode2 = SWIG_AsVal_int(obj1, &val2);
25340 if (!SWIG_IsOK(ecode2)) {
25341 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeek" "', expected argument " "2"" of type '" "int""'");
25342 }
25343 arg2 = static_cast< int >(val2);
25344 if (obj2) {
25345 ecode3 = SWIG_AsVal_int(obj2, &val3);
25346 if (!SWIG_IsOK(ecode3)) {
25347 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
25348 }
25349 arg3 = static_cast< wxDateTime::WeekDay >(val3);
25350 }
25351 if (obj3) {
25352 ecode4 = SWIG_AsVal_int(obj3, &val4);
25353 if (!SWIG_IsOK(ecode4)) {
25354 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
25355 }
25356 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
25357 }
25358 {
25359 PyThreadState* __tstate = wxPyBeginAllowThreads();
25360 result = (arg1)->GetWeek(arg2,arg3,arg4);
25361 wxPyEndAllowThreads(__tstate);
25362 if (PyErr_Occurred()) SWIG_fail;
25363 }
25364 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25365 return resultobj;
25366 fail:
25367 return NULL;
25368 }
25369
25370
25371 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25372 PyObject *resultobj = 0;
25373 int arg1 ;
25374 int arg2 ;
25375 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
25376 wxDateTime result;
25377 int val1 ;
25378 int ecode1 = 0 ;
25379 int val2 ;
25380 int ecode2 = 0 ;
25381 int val3 ;
25382 int ecode3 = 0 ;
25383 PyObject * obj0 = 0 ;
25384 PyObject * obj1 = 0 ;
25385 PyObject * obj2 = 0 ;
25386 char * kwnames[] = {
25387 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
25388 };
25389
25390 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25391 ecode1 = SWIG_AsVal_int(obj0, &val1);
25392 if (!SWIG_IsOK(ecode1)) {
25393 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "1"" of type '" "int""'");
25394 }
25395 arg1 = static_cast< int >(val1);
25396 ecode2 = SWIG_AsVal_int(obj1, &val2);
25397 if (!SWIG_IsOK(ecode2)) {
25398 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "2"" of type '" "int""'");
25399 }
25400 arg2 = static_cast< int >(val2);
25401 if (obj2) {
25402 ecode3 = SWIG_AsVal_int(obj2, &val3);
25403 if (!SWIG_IsOK(ecode3)) {
25404 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
25405 }
25406 arg3 = static_cast< wxDateTime::WeekDay >(val3);
25407 }
25408 {
25409 PyThreadState* __tstate = wxPyBeginAllowThreads();
25410 result = wxDateTime::SetToWeekOfYear(arg1,arg2,arg3);
25411 wxPyEndAllowThreads(__tstate);
25412 if (PyErr_Occurred()) SWIG_fail;
25413 }
25414 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25415 return resultobj;
25416 fail:
25417 return NULL;
25418 }
25419
25420
25421 SWIGINTERN PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25422 PyObject *resultobj = 0;
25423 wxDateTime *arg1 = (wxDateTime *) 0 ;
25424 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25425 int arg3 = (int) wxDateTime::Inv_Year ;
25426 wxDateTime *result = 0 ;
25427 void *argp1 = 0 ;
25428 int res1 = 0 ;
25429 int val2 ;
25430 int ecode2 = 0 ;
25431 int val3 ;
25432 int ecode3 = 0 ;
25433 PyObject * obj0 = 0 ;
25434 PyObject * obj1 = 0 ;
25435 PyObject * obj2 = 0 ;
25436 char * kwnames[] = {
25437 (char *) "self",(char *) "month",(char *) "year", NULL
25438 };
25439
25440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25441 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25442 if (!SWIG_IsOK(res1)) {
25443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25444 }
25445 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25446 if (obj1) {
25447 ecode2 = SWIG_AsVal_int(obj1, &val2);
25448 if (!SWIG_IsOK(ecode2)) {
25449 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
25450 }
25451 arg2 = static_cast< wxDateTime::Month >(val2);
25452 }
25453 if (obj2) {
25454 ecode3 = SWIG_AsVal_int(obj2, &val3);
25455 if (!SWIG_IsOK(ecode3)) {
25456 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "3"" of type '" "int""'");
25457 }
25458 arg3 = static_cast< int >(val3);
25459 }
25460 {
25461 PyThreadState* __tstate = wxPyBeginAllowThreads();
25462 {
25463 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay(arg2,arg3);
25464 result = (wxDateTime *) &_result_ref;
25465 }
25466 wxPyEndAllowThreads(__tstate);
25467 if (PyErr_Occurred()) SWIG_fail;
25468 }
25469 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25470 return resultobj;
25471 fail:
25472 return NULL;
25473 }
25474
25475
25476 SWIGINTERN PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25477 PyObject *resultobj = 0;
25478 wxDateTime *arg1 = (wxDateTime *) 0 ;
25479 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25480 int arg3 = (int) wxDateTime::Inv_Year ;
25481 wxDateTime result;
25482 void *argp1 = 0 ;
25483 int res1 = 0 ;
25484 int val2 ;
25485 int ecode2 = 0 ;
25486 int val3 ;
25487 int ecode3 = 0 ;
25488 PyObject * obj0 = 0 ;
25489 PyObject * obj1 = 0 ;
25490 PyObject * obj2 = 0 ;
25491 char * kwnames[] = {
25492 (char *) "self",(char *) "month",(char *) "year", NULL
25493 };
25494
25495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25496 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25497 if (!SWIG_IsOK(res1)) {
25498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25499 }
25500 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25501 if (obj1) {
25502 ecode2 = SWIG_AsVal_int(obj1, &val2);
25503 if (!SWIG_IsOK(ecode2)) {
25504 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
25505 }
25506 arg2 = static_cast< wxDateTime::Month >(val2);
25507 }
25508 if (obj2) {
25509 ecode3 = SWIG_AsVal_int(obj2, &val3);
25510 if (!SWIG_IsOK(ecode3)) {
25511 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "3"" of type '" "int""'");
25512 }
25513 arg3 = static_cast< int >(val3);
25514 }
25515 {
25516 PyThreadState* __tstate = wxPyBeginAllowThreads();
25517 result = (arg1)->GetLastMonthDay(arg2,arg3);
25518 wxPyEndAllowThreads(__tstate);
25519 if (PyErr_Occurred()) SWIG_fail;
25520 }
25521 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25522 return resultobj;
25523 fail:
25524 return NULL;
25525 }
25526
25527
25528 SWIGINTERN PyObject *_wrap_DateTime_SetToYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25529 PyObject *resultobj = 0;
25530 wxDateTime *arg1 = (wxDateTime *) 0 ;
25531 int arg2 ;
25532 wxDateTime *result = 0 ;
25533 void *argp1 = 0 ;
25534 int res1 = 0 ;
25535 int val2 ;
25536 int ecode2 = 0 ;
25537 PyObject * obj0 = 0 ;
25538 PyObject * obj1 = 0 ;
25539 char * kwnames[] = {
25540 (char *) "self",(char *) "yday", NULL
25541 };
25542
25543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
25544 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25545 if (!SWIG_IsOK(res1)) {
25546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25547 }
25548 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25549 ecode2 = SWIG_AsVal_int(obj1, &val2);
25550 if (!SWIG_IsOK(ecode2)) {
25551 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToYearDay" "', expected argument " "2"" of type '" "int""'");
25552 }
25553 arg2 = static_cast< int >(val2);
25554 {
25555 PyThreadState* __tstate = wxPyBeginAllowThreads();
25556 {
25557 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
25558 result = (wxDateTime *) &_result_ref;
25559 }
25560 wxPyEndAllowThreads(__tstate);
25561 if (PyErr_Occurred()) SWIG_fail;
25562 }
25563 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25564 return resultobj;
25565 fail:
25566 return NULL;
25567 }
25568
25569
25570 SWIGINTERN PyObject *_wrap_DateTime_GetYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25571 PyObject *resultobj = 0;
25572 wxDateTime *arg1 = (wxDateTime *) 0 ;
25573 int arg2 ;
25574 wxDateTime result;
25575 void *argp1 = 0 ;
25576 int res1 = 0 ;
25577 int val2 ;
25578 int ecode2 = 0 ;
25579 PyObject * obj0 = 0 ;
25580 PyObject * obj1 = 0 ;
25581 char * kwnames[] = {
25582 (char *) "self",(char *) "yday", NULL
25583 };
25584
25585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
25586 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25587 if (!SWIG_IsOK(res1)) {
25588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25589 }
25590 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25591 ecode2 = SWIG_AsVal_int(obj1, &val2);
25592 if (!SWIG_IsOK(ecode2)) {
25593 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetYearDay" "', expected argument " "2"" of type '" "int""'");
25594 }
25595 arg2 = static_cast< int >(val2);
25596 {
25597 PyThreadState* __tstate = wxPyBeginAllowThreads();
25598 result = (arg1)->GetYearDay(arg2);
25599 wxPyEndAllowThreads(__tstate);
25600 if (PyErr_Occurred()) SWIG_fail;
25601 }
25602 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25603 return resultobj;
25604 fail:
25605 return NULL;
25606 }
25607
25608
25609 SWIGINTERN PyObject *_wrap_DateTime_GetJulianDayNumber(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_GetJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime *""'");
25622 }
25623 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25624 {
25625 PyThreadState* __tstate = wxPyBeginAllowThreads();
25626 result = (double)(arg1)->GetJulianDayNumber();
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_GetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25638 PyObject *resultobj = 0;
25639 wxDateTime *arg1 = (wxDateTime *) 0 ;
25640 double result;
25641 void *argp1 = 0 ;
25642 int res1 = 0 ;
25643 PyObject *swig_obj[1] ;
25644
25645 if (!args) SWIG_fail;
25646 swig_obj[0] = args;
25647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25648 if (!SWIG_IsOK(res1)) {
25649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
25650 }
25651 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25652 {
25653 PyThreadState* __tstate = wxPyBeginAllowThreads();
25654 result = (double)(arg1)->GetJDN();
25655 wxPyEndAllowThreads(__tstate);
25656 if (PyErr_Occurred()) SWIG_fail;
25657 }
25658 resultobj = SWIG_From_double(static_cast< double >(result));
25659 return resultobj;
25660 fail:
25661 return NULL;
25662 }
25663
25664
25665 SWIGINTERN PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25666 PyObject *resultobj = 0;
25667 wxDateTime *arg1 = (wxDateTime *) 0 ;
25668 double result;
25669 void *argp1 = 0 ;
25670 int res1 = 0 ;
25671 PyObject *swig_obj[1] ;
25672
25673 if (!args) SWIG_fail;
25674 swig_obj[0] = args;
25675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25676 if (!SWIG_IsOK(res1)) {
25677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetModifiedJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25678 }
25679 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25680 {
25681 PyThreadState* __tstate = wxPyBeginAllowThreads();
25682 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
25683 wxPyEndAllowThreads(__tstate);
25684 if (PyErr_Occurred()) SWIG_fail;
25685 }
25686 resultobj = SWIG_From_double(static_cast< double >(result));
25687 return resultobj;
25688 fail:
25689 return NULL;
25690 }
25691
25692
25693 SWIGINTERN PyObject *_wrap_DateTime_GetMJD(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25694 PyObject *resultobj = 0;
25695 wxDateTime *arg1 = (wxDateTime *) 0 ;
25696 double result;
25697 void *argp1 = 0 ;
25698 int res1 = 0 ;
25699 PyObject *swig_obj[1] ;
25700
25701 if (!args) SWIG_fail;
25702 swig_obj[0] = args;
25703 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25704 if (!SWIG_IsOK(res1)) {
25705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMJD" "', expected argument " "1"" of type '" "wxDateTime *""'");
25706 }
25707 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25708 {
25709 PyThreadState* __tstate = wxPyBeginAllowThreads();
25710 result = (double)(arg1)->GetMJD();
25711 wxPyEndAllowThreads(__tstate);
25712 if (PyErr_Occurred()) SWIG_fail;
25713 }
25714 resultobj = SWIG_From_double(static_cast< double >(result));
25715 return resultobj;
25716 fail:
25717 return NULL;
25718 }
25719
25720
25721 SWIGINTERN PyObject *_wrap_DateTime_GetRataDie(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25722 PyObject *resultobj = 0;
25723 wxDateTime *arg1 = (wxDateTime *) 0 ;
25724 double result;
25725 void *argp1 = 0 ;
25726 int res1 = 0 ;
25727 PyObject *swig_obj[1] ;
25728
25729 if (!args) SWIG_fail;
25730 swig_obj[0] = args;
25731 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25732 if (!SWIG_IsOK(res1)) {
25733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetRataDie" "', expected argument " "1"" of type '" "wxDateTime *""'");
25734 }
25735 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25736 {
25737 PyThreadState* __tstate = wxPyBeginAllowThreads();
25738 result = (double)(arg1)->GetRataDie();
25739 wxPyEndAllowThreads(__tstate);
25740 if (PyErr_Occurred()) SWIG_fail;
25741 }
25742 resultobj = SWIG_From_double(static_cast< double >(result));
25743 return resultobj;
25744 fail:
25745 return NULL;
25746 }
25747
25748
25749 SWIGINTERN PyObject *_wrap_DateTime_ToTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25750 PyObject *resultobj = 0;
25751 wxDateTime *arg1 = (wxDateTime *) 0 ;
25752 wxDateTime::TimeZone *arg2 = 0 ;
25753 bool arg3 = (bool) false ;
25754 wxDateTime result;
25755 void *argp1 = 0 ;
25756 int res1 = 0 ;
25757 bool temp2 = false ;
25758 bool val3 ;
25759 int ecode3 = 0 ;
25760 PyObject * obj0 = 0 ;
25761 PyObject * obj1 = 0 ;
25762 PyObject * obj2 = 0 ;
25763 char * kwnames[] = {
25764 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25765 };
25766
25767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25769 if (!SWIG_IsOK(res1)) {
25770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25771 }
25772 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25773 {
25774 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25775 temp2 = true;
25776 }
25777 if (obj2) {
25778 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25779 if (!SWIG_IsOK(ecode3)) {
25780 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_ToTimezone" "', expected argument " "3"" of type '" "bool""'");
25781 }
25782 arg3 = static_cast< bool >(val3);
25783 }
25784 {
25785 PyThreadState* __tstate = wxPyBeginAllowThreads();
25786 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25787 wxPyEndAllowThreads(__tstate);
25788 if (PyErr_Occurred()) SWIG_fail;
25789 }
25790 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25791 {
25792 if (temp2) delete arg2;
25793 }
25794 return resultobj;
25795 fail:
25796 {
25797 if (temp2) delete arg2;
25798 }
25799 return NULL;
25800 }
25801
25802
25803 SWIGINTERN PyObject *_wrap_DateTime_MakeTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25804 PyObject *resultobj = 0;
25805 wxDateTime *arg1 = (wxDateTime *) 0 ;
25806 wxDateTime::TimeZone *arg2 = 0 ;
25807 bool arg3 = (bool) false ;
25808 wxDateTime *result = 0 ;
25809 void *argp1 = 0 ;
25810 int res1 = 0 ;
25811 bool temp2 = false ;
25812 bool val3 ;
25813 int ecode3 = 0 ;
25814 PyObject * obj0 = 0 ;
25815 PyObject * obj1 = 0 ;
25816 PyObject * obj2 = 0 ;
25817 char * kwnames[] = {
25818 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25819 };
25820
25821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25823 if (!SWIG_IsOK(res1)) {
25824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25825 }
25826 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25827 {
25828 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25829 temp2 = true;
25830 }
25831 if (obj2) {
25832 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25833 if (!SWIG_IsOK(ecode3)) {
25834 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeTimezone" "', expected argument " "3"" of type '" "bool""'");
25835 }
25836 arg3 = static_cast< bool >(val3);
25837 }
25838 {
25839 PyThreadState* __tstate = wxPyBeginAllowThreads();
25840 {
25841 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25842 result = (wxDateTime *) &_result_ref;
25843 }
25844 wxPyEndAllowThreads(__tstate);
25845 if (PyErr_Occurred()) SWIG_fail;
25846 }
25847 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25848 {
25849 if (temp2) delete arg2;
25850 }
25851 return resultobj;
25852 fail:
25853 {
25854 if (temp2) delete arg2;
25855 }
25856 return NULL;
25857 }
25858
25859
25860 SWIGINTERN PyObject *_wrap_DateTime_FromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25861 PyObject *resultobj = 0;
25862 wxDateTime *arg1 = (wxDateTime *) 0 ;
25863 wxDateTime::TimeZone *arg2 = 0 ;
25864 bool arg3 = (bool) false ;
25865 wxDateTime result;
25866 void *argp1 = 0 ;
25867 int res1 = 0 ;
25868 bool temp2 = false ;
25869 bool val3 ;
25870 int ecode3 = 0 ;
25871 PyObject * obj0 = 0 ;
25872 PyObject * obj1 = 0 ;
25873 PyObject * obj2 = 0 ;
25874 char * kwnames[] = {
25875 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25876 };
25877
25878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_FromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25879 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25880 if (!SWIG_IsOK(res1)) {
25881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromTimezone" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25882 }
25883 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25884 {
25885 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25886 temp2 = true;
25887 }
25888 if (obj2) {
25889 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25890 if (!SWIG_IsOK(ecode3)) {
25891 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_FromTimezone" "', expected argument " "3"" of type '" "bool""'");
25892 }
25893 arg3 = static_cast< bool >(val3);
25894 }
25895 {
25896 PyThreadState* __tstate = wxPyBeginAllowThreads();
25897 result = ((wxDateTime const *)arg1)->FromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25898 wxPyEndAllowThreads(__tstate);
25899 if (PyErr_Occurred()) SWIG_fail;
25900 }
25901 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25902 {
25903 if (temp2) delete arg2;
25904 }
25905 return resultobj;
25906 fail:
25907 {
25908 if (temp2) delete arg2;
25909 }
25910 return NULL;
25911 }
25912
25913
25914 SWIGINTERN PyObject *_wrap_DateTime_MakeFromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25915 PyObject *resultobj = 0;
25916 wxDateTime *arg1 = (wxDateTime *) 0 ;
25917 wxDateTime::TimeZone *arg2 = 0 ;
25918 bool arg3 = (bool) false ;
25919 wxDateTime *result = 0 ;
25920 void *argp1 = 0 ;
25921 int res1 = 0 ;
25922 bool temp2 = false ;
25923 bool val3 ;
25924 int ecode3 = 0 ;
25925 PyObject * obj0 = 0 ;
25926 PyObject * obj1 = 0 ;
25927 PyObject * obj2 = 0 ;
25928 char * kwnames[] = {
25929 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25930 };
25931
25932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeFromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25934 if (!SWIG_IsOK(res1)) {
25935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25936 }
25937 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25938 {
25939 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25940 temp2 = true;
25941 }
25942 if (obj2) {
25943 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25944 if (!SWIG_IsOK(ecode3)) {
25945 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "3"" of type '" "bool""'");
25946 }
25947 arg3 = static_cast< bool >(val3);
25948 }
25949 {
25950 PyThreadState* __tstate = wxPyBeginAllowThreads();
25951 {
25952 wxDateTime &_result_ref = (arg1)->MakeFromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25953 result = (wxDateTime *) &_result_ref;
25954 }
25955 wxPyEndAllowThreads(__tstate);
25956 if (PyErr_Occurred()) SWIG_fail;
25957 }
25958 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25959 {
25960 if (temp2) delete arg2;
25961 }
25962 return resultobj;
25963 fail:
25964 {
25965 if (temp2) delete arg2;
25966 }
25967 return NULL;
25968 }
25969
25970
25971 SWIGINTERN PyObject *_wrap_DateTime_ToUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25972 PyObject *resultobj = 0;
25973 wxDateTime *arg1 = (wxDateTime *) 0 ;
25974 bool arg2 = (bool) false ;
25975 wxDateTime result;
25976 void *argp1 = 0 ;
25977 int res1 = 0 ;
25978 bool val2 ;
25979 int ecode2 = 0 ;
25980 PyObject * obj0 = 0 ;
25981 PyObject * obj1 = 0 ;
25982 char * kwnames[] = {
25983 (char *) "self",(char *) "noDST", NULL
25984 };
25985
25986 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToUTC",kwnames,&obj0,&obj1)) SWIG_fail;
25987 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25988 if (!SWIG_IsOK(res1)) {
25989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25990 }
25991 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25992 if (obj1) {
25993 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25994 if (!SWIG_IsOK(ecode2)) {
25995 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToUTC" "', expected argument " "2"" of type '" "bool""'");
25996 }
25997 arg2 = static_cast< bool >(val2);
25998 }
25999 {
26000 PyThreadState* __tstate = wxPyBeginAllowThreads();
26001 result = ((wxDateTime const *)arg1)->ToUTC(arg2);
26002 wxPyEndAllowThreads(__tstate);
26003 if (PyErr_Occurred()) SWIG_fail;
26004 }
26005 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26006 return resultobj;
26007 fail:
26008 return NULL;
26009 }
26010
26011
26012 SWIGINTERN PyObject *_wrap_DateTime_MakeUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26013 PyObject *resultobj = 0;
26014 wxDateTime *arg1 = (wxDateTime *) 0 ;
26015 bool arg2 = (bool) false ;
26016 wxDateTime *result = 0 ;
26017 void *argp1 = 0 ;
26018 int res1 = 0 ;
26019 bool val2 ;
26020 int ecode2 = 0 ;
26021 PyObject * obj0 = 0 ;
26022 PyObject * obj1 = 0 ;
26023 char * kwnames[] = {
26024 (char *) "self",(char *) "noDST", NULL
26025 };
26026
26027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeUTC",kwnames,&obj0,&obj1)) SWIG_fail;
26028 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26029 if (!SWIG_IsOK(res1)) {
26030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
26031 }
26032 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26033 if (obj1) {
26034 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26035 if (!SWIG_IsOK(ecode2)) {
26036 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeUTC" "', expected argument " "2"" of type '" "bool""'");
26037 }
26038 arg2 = static_cast< bool >(val2);
26039 }
26040 {
26041 PyThreadState* __tstate = wxPyBeginAllowThreads();
26042 {
26043 wxDateTime &_result_ref = (arg1)->MakeUTC(arg2);
26044 result = (wxDateTime *) &_result_ref;
26045 }
26046 wxPyEndAllowThreads(__tstate);
26047 if (PyErr_Occurred()) SWIG_fail;
26048 }
26049 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26050 return resultobj;
26051 fail:
26052 return NULL;
26053 }
26054
26055
26056 SWIGINTERN PyObject *_wrap_DateTime_ToGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26057 PyObject *resultobj = 0;
26058 wxDateTime *arg1 = (wxDateTime *) 0 ;
26059 bool arg2 = (bool) false ;
26060 wxDateTime result;
26061 void *argp1 = 0 ;
26062 int res1 = 0 ;
26063 bool val2 ;
26064 int ecode2 = 0 ;
26065 PyObject * obj0 = 0 ;
26066 PyObject * obj1 = 0 ;
26067 char * kwnames[] = {
26068 (char *) "self",(char *) "noDST", NULL
26069 };
26070
26071 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) SWIG_fail;
26072 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26073 if (!SWIG_IsOK(res1)) {
26074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToGMT" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26075 }
26076 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26077 if (obj1) {
26078 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26079 if (!SWIG_IsOK(ecode2)) {
26080 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToGMT" "', expected argument " "2"" of type '" "bool""'");
26081 }
26082 arg2 = static_cast< bool >(val2);
26083 }
26084 {
26085 PyThreadState* __tstate = wxPyBeginAllowThreads();
26086 result = ((wxDateTime const *)arg1)->ToGMT(arg2);
26087 wxPyEndAllowThreads(__tstate);
26088 if (PyErr_Occurred()) SWIG_fail;
26089 }
26090 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26091 return resultobj;
26092 fail:
26093 return NULL;
26094 }
26095
26096
26097 SWIGINTERN PyObject *_wrap_DateTime_MakeGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26098 PyObject *resultobj = 0;
26099 wxDateTime *arg1 = (wxDateTime *) 0 ;
26100 bool arg2 = (bool) false ;
26101 wxDateTime *result = 0 ;
26102 void *argp1 = 0 ;
26103 int res1 = 0 ;
26104 bool val2 ;
26105 int ecode2 = 0 ;
26106 PyObject * obj0 = 0 ;
26107 PyObject * obj1 = 0 ;
26108 char * kwnames[] = {
26109 (char *) "self",(char *) "noDST", NULL
26110 };
26111
26112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) SWIG_fail;
26113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26114 if (!SWIG_IsOK(res1)) {
26115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeGMT" "', expected argument " "1"" of type '" "wxDateTime *""'");
26116 }
26117 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26118 if (obj1) {
26119 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26120 if (!SWIG_IsOK(ecode2)) {
26121 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeGMT" "', expected argument " "2"" of type '" "bool""'");
26122 }
26123 arg2 = static_cast< bool >(val2);
26124 }
26125 {
26126 PyThreadState* __tstate = wxPyBeginAllowThreads();
26127 {
26128 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
26129 result = (wxDateTime *) &_result_ref;
26130 }
26131 wxPyEndAllowThreads(__tstate);
26132 if (PyErr_Occurred()) SWIG_fail;
26133 }
26134 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26135 return resultobj;
26136 fail:
26137 return NULL;
26138 }
26139
26140
26141 SWIGINTERN PyObject *_wrap_DateTime_FromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26142 PyObject *resultobj = 0;
26143 wxDateTime *arg1 = (wxDateTime *) 0 ;
26144 bool arg2 = (bool) false ;
26145 wxDateTime result;
26146 void *argp1 = 0 ;
26147 int res1 = 0 ;
26148 bool val2 ;
26149 int ecode2 = 0 ;
26150 PyObject * obj0 = 0 ;
26151 PyObject * obj1 = 0 ;
26152 char * kwnames[] = {
26153 (char *) "self",(char *) "noDST", NULL
26154 };
26155
26156 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_FromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
26157 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26158 if (!SWIG_IsOK(res1)) {
26159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26160 }
26161 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26162 if (obj1) {
26163 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26164 if (!SWIG_IsOK(ecode2)) {
26165 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_FromUTC" "', expected argument " "2"" of type '" "bool""'");
26166 }
26167 arg2 = static_cast< bool >(val2);
26168 }
26169 {
26170 PyThreadState* __tstate = wxPyBeginAllowThreads();
26171 result = ((wxDateTime const *)arg1)->FromUTC(arg2);
26172 wxPyEndAllowThreads(__tstate);
26173 if (PyErr_Occurred()) SWIG_fail;
26174 }
26175 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26176 return resultobj;
26177 fail:
26178 return NULL;
26179 }
26180
26181
26182 SWIGINTERN PyObject *_wrap_DateTime_MakeFromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26183 PyObject *resultobj = 0;
26184 wxDateTime *arg1 = (wxDateTime *) 0 ;
26185 bool arg2 = (bool) false ;
26186 wxDateTime *result = 0 ;
26187 void *argp1 = 0 ;
26188 int res1 = 0 ;
26189 bool val2 ;
26190 int ecode2 = 0 ;
26191 PyObject * obj0 = 0 ;
26192 PyObject * obj1 = 0 ;
26193 char * kwnames[] = {
26194 (char *) "self",(char *) "noDST", NULL
26195 };
26196
26197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeFromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
26198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26199 if (!SWIG_IsOK(res1)) {
26200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
26201 }
26202 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26203 if (obj1) {
26204 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26205 if (!SWIG_IsOK(ecode2)) {
26206 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeFromUTC" "', expected argument " "2"" of type '" "bool""'");
26207 }
26208 arg2 = static_cast< bool >(val2);
26209 }
26210 {
26211 PyThreadState* __tstate = wxPyBeginAllowThreads();
26212 {
26213 wxDateTime &_result_ref = (arg1)->MakeFromUTC(arg2);
26214 result = (wxDateTime *) &_result_ref;
26215 }
26216 wxPyEndAllowThreads(__tstate);
26217 if (PyErr_Occurred()) SWIG_fail;
26218 }
26219 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26220 return resultobj;
26221 fail:
26222 return NULL;
26223 }
26224
26225
26226 SWIGINTERN PyObject *_wrap_DateTime_IsDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26227 PyObject *resultobj = 0;
26228 wxDateTime *arg1 = (wxDateTime *) 0 ;
26229 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
26230 int result;
26231 void *argp1 = 0 ;
26232 int res1 = 0 ;
26233 int val2 ;
26234 int ecode2 = 0 ;
26235 PyObject * obj0 = 0 ;
26236 PyObject * obj1 = 0 ;
26237 char * kwnames[] = {
26238 (char *) "self",(char *) "country", NULL
26239 };
26240
26241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) SWIG_fail;
26242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26243 if (!SWIG_IsOK(res1)) {
26244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsDST" "', expected argument " "1"" of type '" "wxDateTime *""'");
26245 }
26246 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26247 if (obj1) {
26248 ecode2 = SWIG_AsVal_int(obj1, &val2);
26249 if (!SWIG_IsOK(ecode2)) {
26250 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
26251 }
26252 arg2 = static_cast< wxDateTime::Country >(val2);
26253 }
26254 {
26255 PyThreadState* __tstate = wxPyBeginAllowThreads();
26256 result = (int)(arg1)->IsDST(arg2);
26257 wxPyEndAllowThreads(__tstate);
26258 if (PyErr_Occurred()) SWIG_fail;
26259 }
26260 resultobj = SWIG_From_int(static_cast< int >(result));
26261 return resultobj;
26262 fail:
26263 return NULL;
26264 }
26265
26266
26267 SWIGINTERN PyObject *_wrap_DateTime_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26268 PyObject *resultobj = 0;
26269 wxDateTime *arg1 = (wxDateTime *) 0 ;
26270 bool result;
26271 void *argp1 = 0 ;
26272 int res1 = 0 ;
26273 PyObject *swig_obj[1] ;
26274
26275 if (!args) SWIG_fail;
26276 swig_obj[0] = args;
26277 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26278 if (!SWIG_IsOK(res1)) {
26279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsValid" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26280 }
26281 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26282 {
26283 PyThreadState* __tstate = wxPyBeginAllowThreads();
26284 result = (bool)((wxDateTime const *)arg1)->IsValid();
26285 wxPyEndAllowThreads(__tstate);
26286 if (PyErr_Occurred()) SWIG_fail;
26287 }
26288 {
26289 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26290 }
26291 return resultobj;
26292 fail:
26293 return NULL;
26294 }
26295
26296
26297 SWIGINTERN PyObject *_wrap_DateTime_GetTicks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26298 PyObject *resultobj = 0;
26299 wxDateTime *arg1 = (wxDateTime *) 0 ;
26300 time_t result;
26301 void *argp1 = 0 ;
26302 int res1 = 0 ;
26303 PyObject *swig_obj[1] ;
26304
26305 if (!args) SWIG_fail;
26306 swig_obj[0] = args;
26307 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26308 if (!SWIG_IsOK(res1)) {
26309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetTicks" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26310 }
26311 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26312 {
26313 PyThreadState* __tstate = wxPyBeginAllowThreads();
26314 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
26315 wxPyEndAllowThreads(__tstate);
26316 if (PyErr_Occurred()) SWIG_fail;
26317 }
26318 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
26319 return resultobj;
26320 fail:
26321 return NULL;
26322 }
26323
26324
26325 SWIGINTERN PyObject *_wrap_DateTime_GetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26326 PyObject *resultobj = 0;
26327 wxDateTime *arg1 = (wxDateTime *) 0 ;
26328 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26329 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26330 int result;
26331 void *argp1 = 0 ;
26332 int res1 = 0 ;
26333 bool temp2 = false ;
26334 PyObject * obj0 = 0 ;
26335 PyObject * obj1 = 0 ;
26336 char * kwnames[] = {
26337 (char *) "self",(char *) "tz", NULL
26338 };
26339
26340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) SWIG_fail;
26341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26342 if (!SWIG_IsOK(res1)) {
26343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26344 }
26345 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26346 if (obj1) {
26347 {
26348 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26349 temp2 = true;
26350 }
26351 }
26352 {
26353 PyThreadState* __tstate = wxPyBeginAllowThreads();
26354 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
26355 wxPyEndAllowThreads(__tstate);
26356 if (PyErr_Occurred()) SWIG_fail;
26357 }
26358 resultobj = SWIG_From_int(static_cast< int >(result));
26359 {
26360 if (temp2) delete arg2;
26361 }
26362 return resultobj;
26363 fail:
26364 {
26365 if (temp2) delete arg2;
26366 }
26367 return NULL;
26368 }
26369
26370
26371 SWIGINTERN PyObject *_wrap_DateTime_GetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26372 PyObject *resultobj = 0;
26373 wxDateTime *arg1 = (wxDateTime *) 0 ;
26374 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26375 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26376 wxDateTime::Month result;
26377 void *argp1 = 0 ;
26378 int res1 = 0 ;
26379 bool temp2 = false ;
26380 PyObject * obj0 = 0 ;
26381 PyObject * obj1 = 0 ;
26382 char * kwnames[] = {
26383 (char *) "self",(char *) "tz", NULL
26384 };
26385
26386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
26387 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26388 if (!SWIG_IsOK(res1)) {
26389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26390 }
26391 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26392 if (obj1) {
26393 {
26394 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26395 temp2 = true;
26396 }
26397 }
26398 {
26399 PyThreadState* __tstate = wxPyBeginAllowThreads();
26400 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
26401 wxPyEndAllowThreads(__tstate);
26402 if (PyErr_Occurred()) SWIG_fail;
26403 }
26404 resultobj = SWIG_From_int(static_cast< int >(result));
26405 {
26406 if (temp2) delete arg2;
26407 }
26408 return resultobj;
26409 fail:
26410 {
26411 if (temp2) delete arg2;
26412 }
26413 return NULL;
26414 }
26415
26416
26417 SWIGINTERN PyObject *_wrap_DateTime_GetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26418 PyObject *resultobj = 0;
26419 wxDateTime *arg1 = (wxDateTime *) 0 ;
26420 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26421 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26422 int result;
26423 void *argp1 = 0 ;
26424 int res1 = 0 ;
26425 bool temp2 = false ;
26426 PyObject * obj0 = 0 ;
26427 PyObject * obj1 = 0 ;
26428 char * kwnames[] = {
26429 (char *) "self",(char *) "tz", NULL
26430 };
26431
26432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) SWIG_fail;
26433 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26434 if (!SWIG_IsOK(res1)) {
26435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26436 }
26437 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26438 if (obj1) {
26439 {
26440 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26441 temp2 = true;
26442 }
26443 }
26444 {
26445 PyThreadState* __tstate = wxPyBeginAllowThreads();
26446 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
26447 wxPyEndAllowThreads(__tstate);
26448 if (PyErr_Occurred()) SWIG_fail;
26449 }
26450 resultobj = SWIG_From_int(static_cast< int >(result));
26451 {
26452 if (temp2) delete arg2;
26453 }
26454 return resultobj;
26455 fail:
26456 {
26457 if (temp2) delete arg2;
26458 }
26459 return NULL;
26460 }
26461
26462
26463 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26464 PyObject *resultobj = 0;
26465 wxDateTime *arg1 = (wxDateTime *) 0 ;
26466 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26467 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26468 wxDateTime::WeekDay result;
26469 void *argp1 = 0 ;
26470 int res1 = 0 ;
26471 bool temp2 = false ;
26472 PyObject * obj0 = 0 ;
26473 PyObject * obj1 = 0 ;
26474 char * kwnames[] = {
26475 (char *) "self",(char *) "tz", NULL
26476 };
26477
26478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
26479 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26480 if (!SWIG_IsOK(res1)) {
26481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26482 }
26483 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26484 if (obj1) {
26485 {
26486 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26487 temp2 = true;
26488 }
26489 }
26490 {
26491 PyThreadState* __tstate = wxPyBeginAllowThreads();
26492 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
26493 wxPyEndAllowThreads(__tstate);
26494 if (PyErr_Occurred()) SWIG_fail;
26495 }
26496 resultobj = SWIG_From_int(static_cast< int >(result));
26497 {
26498 if (temp2) delete arg2;
26499 }
26500 return resultobj;
26501 fail:
26502 {
26503 if (temp2) delete arg2;
26504 }
26505 return NULL;
26506 }
26507
26508
26509 SWIGINTERN PyObject *_wrap_DateTime_GetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26510 PyObject *resultobj = 0;
26511 wxDateTime *arg1 = (wxDateTime *) 0 ;
26512 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26513 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26514 int result;
26515 void *argp1 = 0 ;
26516 int res1 = 0 ;
26517 bool temp2 = false ;
26518 PyObject * obj0 = 0 ;
26519 PyObject * obj1 = 0 ;
26520 char * kwnames[] = {
26521 (char *) "self",(char *) "tz", NULL
26522 };
26523
26524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) SWIG_fail;
26525 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26526 if (!SWIG_IsOK(res1)) {
26527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetHour" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26528 }
26529 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26530 if (obj1) {
26531 {
26532 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26533 temp2 = true;
26534 }
26535 }
26536 {
26537 PyThreadState* __tstate = wxPyBeginAllowThreads();
26538 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
26539 wxPyEndAllowThreads(__tstate);
26540 if (PyErr_Occurred()) SWIG_fail;
26541 }
26542 resultobj = SWIG_From_int(static_cast< int >(result));
26543 {
26544 if (temp2) delete arg2;
26545 }
26546 return resultobj;
26547 fail:
26548 {
26549 if (temp2) delete arg2;
26550 }
26551 return NULL;
26552 }
26553
26554
26555 SWIGINTERN PyObject *_wrap_DateTime_GetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26556 PyObject *resultobj = 0;
26557 wxDateTime *arg1 = (wxDateTime *) 0 ;
26558 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26559 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26560 int result;
26561 void *argp1 = 0 ;
26562 int res1 = 0 ;
26563 bool temp2 = false ;
26564 PyObject * obj0 = 0 ;
26565 PyObject * obj1 = 0 ;
26566 char * kwnames[] = {
26567 (char *) "self",(char *) "tz", NULL
26568 };
26569
26570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
26571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26572 if (!SWIG_IsOK(res1)) {
26573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMinute" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26574 }
26575 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26576 if (obj1) {
26577 {
26578 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26579 temp2 = true;
26580 }
26581 }
26582 {
26583 PyThreadState* __tstate = wxPyBeginAllowThreads();
26584 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
26585 wxPyEndAllowThreads(__tstate);
26586 if (PyErr_Occurred()) SWIG_fail;
26587 }
26588 resultobj = SWIG_From_int(static_cast< int >(result));
26589 {
26590 if (temp2) delete arg2;
26591 }
26592 return resultobj;
26593 fail:
26594 {
26595 if (temp2) delete arg2;
26596 }
26597 return NULL;
26598 }
26599
26600
26601 SWIGINTERN PyObject *_wrap_DateTime_GetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26602 PyObject *resultobj = 0;
26603 wxDateTime *arg1 = (wxDateTime *) 0 ;
26604 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26605 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26606 int result;
26607 void *argp1 = 0 ;
26608 int res1 = 0 ;
26609 bool temp2 = false ;
26610 PyObject * obj0 = 0 ;
26611 PyObject * obj1 = 0 ;
26612 char * kwnames[] = {
26613 (char *) "self",(char *) "tz", NULL
26614 };
26615
26616 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
26617 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26618 if (!SWIG_IsOK(res1)) {
26619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetSecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26620 }
26621 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26622 if (obj1) {
26623 {
26624 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26625 temp2 = true;
26626 }
26627 }
26628 {
26629 PyThreadState* __tstate = wxPyBeginAllowThreads();
26630 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
26631 wxPyEndAllowThreads(__tstate);
26632 if (PyErr_Occurred()) SWIG_fail;
26633 }
26634 resultobj = SWIG_From_int(static_cast< int >(result));
26635 {
26636 if (temp2) delete arg2;
26637 }
26638 return resultobj;
26639 fail:
26640 {
26641 if (temp2) delete arg2;
26642 }
26643 return NULL;
26644 }
26645
26646
26647 SWIGINTERN PyObject *_wrap_DateTime_GetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26648 PyObject *resultobj = 0;
26649 wxDateTime *arg1 = (wxDateTime *) 0 ;
26650 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26651 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26652 int result;
26653 void *argp1 = 0 ;
26654 int res1 = 0 ;
26655 bool temp2 = false ;
26656 PyObject * obj0 = 0 ;
26657 PyObject * obj1 = 0 ;
26658 char * kwnames[] = {
26659 (char *) "self",(char *) "tz", NULL
26660 };
26661
26662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
26663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26664 if (!SWIG_IsOK(res1)) {
26665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMillisecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26666 }
26667 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26668 if (obj1) {
26669 {
26670 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26671 temp2 = true;
26672 }
26673 }
26674 {
26675 PyThreadState* __tstate = wxPyBeginAllowThreads();
26676 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
26677 wxPyEndAllowThreads(__tstate);
26678 if (PyErr_Occurred()) SWIG_fail;
26679 }
26680 resultobj = SWIG_From_int(static_cast< int >(result));
26681 {
26682 if (temp2) delete arg2;
26683 }
26684 return resultobj;
26685 fail:
26686 {
26687 if (temp2) delete arg2;
26688 }
26689 return NULL;
26690 }
26691
26692
26693 SWIGINTERN PyObject *_wrap_DateTime_GetDayOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26694 PyObject *resultobj = 0;
26695 wxDateTime *arg1 = (wxDateTime *) 0 ;
26696 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26697 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26698 int result;
26699 void *argp1 = 0 ;
26700 int res1 = 0 ;
26701 bool temp2 = false ;
26702 PyObject * obj0 = 0 ;
26703 PyObject * obj1 = 0 ;
26704 char * kwnames[] = {
26705 (char *) "self",(char *) "tz", NULL
26706 };
26707
26708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) SWIG_fail;
26709 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26710 if (!SWIG_IsOK(res1)) {
26711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDayOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26712 }
26713 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26714 if (obj1) {
26715 {
26716 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26717 temp2 = true;
26718 }
26719 }
26720 {
26721 PyThreadState* __tstate = wxPyBeginAllowThreads();
26722 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
26723 wxPyEndAllowThreads(__tstate);
26724 if (PyErr_Occurred()) SWIG_fail;
26725 }
26726 resultobj = SWIG_From_int(static_cast< int >(result));
26727 {
26728 if (temp2) delete arg2;
26729 }
26730 return resultobj;
26731 fail:
26732 {
26733 if (temp2) delete arg2;
26734 }
26735 return NULL;
26736 }
26737
26738
26739 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26740 PyObject *resultobj = 0;
26741 wxDateTime *arg1 = (wxDateTime *) 0 ;
26742 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
26743 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
26744 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
26745 int result;
26746 void *argp1 = 0 ;
26747 int res1 = 0 ;
26748 int val2 ;
26749 int ecode2 = 0 ;
26750 bool temp3 = false ;
26751 PyObject * obj0 = 0 ;
26752 PyObject * obj1 = 0 ;
26753 PyObject * obj2 = 0 ;
26754 char * kwnames[] = {
26755 (char *) "self",(char *) "flags",(char *) "tz", NULL
26756 };
26757
26758 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26759 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26760 if (!SWIG_IsOK(res1)) {
26761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26762 }
26763 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26764 if (obj1) {
26765 ecode2 = SWIG_AsVal_int(obj1, &val2);
26766 if (!SWIG_IsOK(ecode2)) {
26767 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
26768 }
26769 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
26770 }
26771 if (obj2) {
26772 {
26773 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
26774 temp3 = true;
26775 }
26776 }
26777 {
26778 PyThreadState* __tstate = wxPyBeginAllowThreads();
26779 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear(arg2,(wxDateTime::TimeZone const &)*arg3);
26780 wxPyEndAllowThreads(__tstate);
26781 if (PyErr_Occurred()) SWIG_fail;
26782 }
26783 resultobj = SWIG_From_int(static_cast< int >(result));
26784 {
26785 if (temp3) delete arg3;
26786 }
26787 return resultobj;
26788 fail:
26789 {
26790 if (temp3) delete arg3;
26791 }
26792 return NULL;
26793 }
26794
26795
26796 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26797 PyObject *resultobj = 0;
26798 wxDateTime *arg1 = (wxDateTime *) 0 ;
26799 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
26800 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
26801 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
26802 int result;
26803 void *argp1 = 0 ;
26804 int res1 = 0 ;
26805 int val2 ;
26806 int ecode2 = 0 ;
26807 bool temp3 = false ;
26808 PyObject * obj0 = 0 ;
26809 PyObject * obj1 = 0 ;
26810 PyObject * obj2 = 0 ;
26811 char * kwnames[] = {
26812 (char *) "self",(char *) "flags",(char *) "tz", NULL
26813 };
26814
26815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26816 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26817 if (!SWIG_IsOK(res1)) {
26818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26819 }
26820 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26821 if (obj1) {
26822 ecode2 = SWIG_AsVal_int(obj1, &val2);
26823 if (!SWIG_IsOK(ecode2)) {
26824 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
26825 }
26826 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
26827 }
26828 if (obj2) {
26829 {
26830 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
26831 temp3 = true;
26832 }
26833 }
26834 {
26835 PyThreadState* __tstate = wxPyBeginAllowThreads();
26836 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth(arg2,(wxDateTime::TimeZone const &)*arg3);
26837 wxPyEndAllowThreads(__tstate);
26838 if (PyErr_Occurred()) SWIG_fail;
26839 }
26840 resultobj = SWIG_From_int(static_cast< int >(result));
26841 {
26842 if (temp3) delete arg3;
26843 }
26844 return resultobj;
26845 fail:
26846 {
26847 if (temp3) delete arg3;
26848 }
26849 return NULL;
26850 }
26851
26852
26853 SWIGINTERN PyObject *_wrap_DateTime_IsWorkDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26854 PyObject *resultobj = 0;
26855 wxDateTime *arg1 = (wxDateTime *) 0 ;
26856 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
26857 bool result;
26858 void *argp1 = 0 ;
26859 int res1 = 0 ;
26860 int val2 ;
26861 int ecode2 = 0 ;
26862 PyObject * obj0 = 0 ;
26863 PyObject * obj1 = 0 ;
26864 char * kwnames[] = {
26865 (char *) "self",(char *) "country", NULL
26866 };
26867
26868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) SWIG_fail;
26869 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26870 if (!SWIG_IsOK(res1)) {
26871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsWorkDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26872 }
26873 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26874 if (obj1) {
26875 ecode2 = SWIG_AsVal_int(obj1, &val2);
26876 if (!SWIG_IsOK(ecode2)) {
26877 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsWorkDay" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
26878 }
26879 arg2 = static_cast< wxDateTime::Country >(val2);
26880 }
26881 {
26882 PyThreadState* __tstate = wxPyBeginAllowThreads();
26883 result = (bool)((wxDateTime const *)arg1)->IsWorkDay(arg2);
26884 wxPyEndAllowThreads(__tstate);
26885 if (PyErr_Occurred()) SWIG_fail;
26886 }
26887 {
26888 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26889 }
26890 return resultobj;
26891 fail:
26892 return NULL;
26893 }
26894
26895
26896 SWIGINTERN PyObject *_wrap_DateTime_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26897 PyObject *resultobj = 0;
26898 wxDateTime *arg1 = (wxDateTime *) 0 ;
26899 wxDateTime *arg2 = 0 ;
26900 bool result;
26901 void *argp1 = 0 ;
26902 int res1 = 0 ;
26903 void *argp2 = 0 ;
26904 int res2 = 0 ;
26905 PyObject * obj0 = 0 ;
26906 PyObject * obj1 = 0 ;
26907 char * kwnames[] = {
26908 (char *) "self",(char *) "datetime", NULL
26909 };
26910
26911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
26912 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26913 if (!SWIG_IsOK(res1)) {
26914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26915 }
26916 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26917 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26918 if (!SWIG_IsOK(res2)) {
26919 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26920 }
26921 if (!argp2) {
26922 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26923 }
26924 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26925 {
26926 PyThreadState* __tstate = wxPyBeginAllowThreads();
26927 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
26928 wxPyEndAllowThreads(__tstate);
26929 if (PyErr_Occurred()) SWIG_fail;
26930 }
26931 {
26932 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26933 }
26934 return resultobj;
26935 fail:
26936 return NULL;
26937 }
26938
26939
26940 SWIGINTERN PyObject *_wrap_DateTime_IsEarlierThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26941 PyObject *resultobj = 0;
26942 wxDateTime *arg1 = (wxDateTime *) 0 ;
26943 wxDateTime *arg2 = 0 ;
26944 bool result;
26945 void *argp1 = 0 ;
26946 int res1 = 0 ;
26947 void *argp2 = 0 ;
26948 int res2 = 0 ;
26949 PyObject * obj0 = 0 ;
26950 PyObject * obj1 = 0 ;
26951 char * kwnames[] = {
26952 (char *) "self",(char *) "datetime", NULL
26953 };
26954
26955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) SWIG_fail;
26956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26957 if (!SWIG_IsOK(res1)) {
26958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEarlierThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26959 }
26960 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26961 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26962 if (!SWIG_IsOK(res2)) {
26963 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26964 }
26965 if (!argp2) {
26966 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26967 }
26968 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26969 {
26970 PyThreadState* __tstate = wxPyBeginAllowThreads();
26971 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
26972 wxPyEndAllowThreads(__tstate);
26973 if (PyErr_Occurred()) SWIG_fail;
26974 }
26975 {
26976 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26977 }
26978 return resultobj;
26979 fail:
26980 return NULL;
26981 }
26982
26983
26984 SWIGINTERN PyObject *_wrap_DateTime_IsLaterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26985 PyObject *resultobj = 0;
26986 wxDateTime *arg1 = (wxDateTime *) 0 ;
26987 wxDateTime *arg2 = 0 ;
26988 bool result;
26989 void *argp1 = 0 ;
26990 int res1 = 0 ;
26991 void *argp2 = 0 ;
26992 int res2 = 0 ;
26993 PyObject * obj0 = 0 ;
26994 PyObject * obj1 = 0 ;
26995 char * kwnames[] = {
26996 (char *) "self",(char *) "datetime", NULL
26997 };
26998
26999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) SWIG_fail;
27000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27001 if (!SWIG_IsOK(res1)) {
27002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsLaterThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27003 }
27004 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27005 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27006 if (!SWIG_IsOK(res2)) {
27007 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27008 }
27009 if (!argp2) {
27010 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27011 }
27012 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27013 {
27014 PyThreadState* __tstate = wxPyBeginAllowThreads();
27015 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
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_IsStrictlyBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27029 PyObject *resultobj = 0;
27030 wxDateTime *arg1 = (wxDateTime *) 0 ;
27031 wxDateTime *arg2 = 0 ;
27032 wxDateTime *arg3 = 0 ;
27033 bool result;
27034 void *argp1 = 0 ;
27035 int res1 = 0 ;
27036 void *argp2 = 0 ;
27037 int res2 = 0 ;
27038 void *argp3 = 0 ;
27039 int res3 = 0 ;
27040 PyObject * obj0 = 0 ;
27041 PyObject * obj1 = 0 ;
27042 PyObject * obj2 = 0 ;
27043 char * kwnames[] = {
27044 (char *) "self",(char *) "t1",(char *) "t2", NULL
27045 };
27046
27047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27049 if (!SWIG_IsOK(res1)) {
27050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27051 }
27052 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27053 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27054 if (!SWIG_IsOK(res2)) {
27055 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27056 }
27057 if (!argp2) {
27058 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27059 }
27060 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27061 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
27062 if (!SWIG_IsOK(res3)) {
27063 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
27064 }
27065 if (!argp3) {
27066 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
27067 }
27068 arg3 = reinterpret_cast< wxDateTime * >(argp3);
27069 {
27070 PyThreadState* __tstate = wxPyBeginAllowThreads();
27071 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
27072 wxPyEndAllowThreads(__tstate);
27073 if (PyErr_Occurred()) SWIG_fail;
27074 }
27075 {
27076 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27077 }
27078 return resultobj;
27079 fail:
27080 return NULL;
27081 }
27082
27083
27084 SWIGINTERN PyObject *_wrap_DateTime_IsBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27085 PyObject *resultobj = 0;
27086 wxDateTime *arg1 = (wxDateTime *) 0 ;
27087 wxDateTime *arg2 = 0 ;
27088 wxDateTime *arg3 = 0 ;
27089 bool result;
27090 void *argp1 = 0 ;
27091 int res1 = 0 ;
27092 void *argp2 = 0 ;
27093 int res2 = 0 ;
27094 void *argp3 = 0 ;
27095 int res3 = 0 ;
27096 PyObject * obj0 = 0 ;
27097 PyObject * obj1 = 0 ;
27098 PyObject * obj2 = 0 ;
27099 char * kwnames[] = {
27100 (char *) "self",(char *) "t1",(char *) "t2", NULL
27101 };
27102
27103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27104 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27105 if (!SWIG_IsOK(res1)) {
27106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27107 }
27108 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27109 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27110 if (!SWIG_IsOK(res2)) {
27111 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27112 }
27113 if (!argp2) {
27114 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27115 }
27116 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27117 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
27118 if (!SWIG_IsOK(res3)) {
27119 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
27120 }
27121 if (!argp3) {
27122 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
27123 }
27124 arg3 = reinterpret_cast< wxDateTime * >(argp3);
27125 {
27126 PyThreadState* __tstate = wxPyBeginAllowThreads();
27127 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
27128 wxPyEndAllowThreads(__tstate);
27129 if (PyErr_Occurred()) SWIG_fail;
27130 }
27131 {
27132 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27133 }
27134 return resultobj;
27135 fail:
27136 return NULL;
27137 }
27138
27139
27140 SWIGINTERN PyObject *_wrap_DateTime_IsSameDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27141 PyObject *resultobj = 0;
27142 wxDateTime *arg1 = (wxDateTime *) 0 ;
27143 wxDateTime *arg2 = 0 ;
27144 bool result;
27145 void *argp1 = 0 ;
27146 int res1 = 0 ;
27147 void *argp2 = 0 ;
27148 int res2 = 0 ;
27149 PyObject * obj0 = 0 ;
27150 PyObject * obj1 = 0 ;
27151 char * kwnames[] = {
27152 (char *) "self",(char *) "dt", NULL
27153 };
27154
27155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) SWIG_fail;
27156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27157 if (!SWIG_IsOK(res1)) {
27158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27159 }
27160 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27161 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27162 if (!SWIG_IsOK(res2)) {
27163 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27164 }
27165 if (!argp2) {
27166 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27167 }
27168 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27169 {
27170 PyThreadState* __tstate = wxPyBeginAllowThreads();
27171 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
27172 wxPyEndAllowThreads(__tstate);
27173 if (PyErr_Occurred()) SWIG_fail;
27174 }
27175 {
27176 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27177 }
27178 return resultobj;
27179 fail:
27180 return NULL;
27181 }
27182
27183
27184 SWIGINTERN PyObject *_wrap_DateTime_IsSameTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27185 PyObject *resultobj = 0;
27186 wxDateTime *arg1 = (wxDateTime *) 0 ;
27187 wxDateTime *arg2 = 0 ;
27188 bool result;
27189 void *argp1 = 0 ;
27190 int res1 = 0 ;
27191 void *argp2 = 0 ;
27192 int res2 = 0 ;
27193 PyObject * obj0 = 0 ;
27194 PyObject * obj1 = 0 ;
27195 char * kwnames[] = {
27196 (char *) "self",(char *) "dt", NULL
27197 };
27198
27199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) SWIG_fail;
27200 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27201 if (!SWIG_IsOK(res1)) {
27202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27203 }
27204 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27205 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27206 if (!SWIG_IsOK(res2)) {
27207 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27208 }
27209 if (!argp2) {
27210 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27211 }
27212 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27213 {
27214 PyThreadState* __tstate = wxPyBeginAllowThreads();
27215 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
27216 wxPyEndAllowThreads(__tstate);
27217 if (PyErr_Occurred()) SWIG_fail;
27218 }
27219 {
27220 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27221 }
27222 return resultobj;
27223 fail:
27224 return NULL;
27225 }
27226
27227
27228 SWIGINTERN PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27229 PyObject *resultobj = 0;
27230 wxDateTime *arg1 = (wxDateTime *) 0 ;
27231 wxDateTime *arg2 = 0 ;
27232 wxTimeSpan *arg3 = 0 ;
27233 bool result;
27234 void *argp1 = 0 ;
27235 int res1 = 0 ;
27236 void *argp2 = 0 ;
27237 int res2 = 0 ;
27238 void *argp3 = 0 ;
27239 int res3 = 0 ;
27240 PyObject * obj0 = 0 ;
27241 PyObject * obj1 = 0 ;
27242 PyObject * obj2 = 0 ;
27243 char * kwnames[] = {
27244 (char *) "self",(char *) "dt",(char *) "ts", NULL
27245 };
27246
27247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27249 if (!SWIG_IsOK(res1)) {
27250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27251 }
27252 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27253 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27254 if (!SWIG_IsOK(res2)) {
27255 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27256 }
27257 if (!argp2) {
27258 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27259 }
27260 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27261 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27262 if (!SWIG_IsOK(res3)) {
27263 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
27264 }
27265 if (!argp3) {
27266 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
27267 }
27268 arg3 = reinterpret_cast< wxTimeSpan * >(argp3);
27269 {
27270 PyThreadState* __tstate = wxPyBeginAllowThreads();
27271 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
27272 wxPyEndAllowThreads(__tstate);
27273 if (PyErr_Occurred()) SWIG_fail;
27274 }
27275 {
27276 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27277 }
27278 return resultobj;
27279 fail:
27280 return NULL;
27281 }
27282
27283
27284 SWIGINTERN PyObject *_wrap_DateTime_AddTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27285 PyObject *resultobj = 0;
27286 wxDateTime *arg1 = (wxDateTime *) 0 ;
27287 wxTimeSpan *arg2 = 0 ;
27288 wxDateTime *result = 0 ;
27289 void *argp1 = 0 ;
27290 int res1 = 0 ;
27291 void *argp2 = 0 ;
27292 int res2 = 0 ;
27293 PyObject * obj0 = 0 ;
27294 PyObject * obj1 = 0 ;
27295 char * kwnames[] = {
27296 (char *) "self",(char *) "diff", NULL
27297 };
27298
27299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) SWIG_fail;
27300 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27301 if (!SWIG_IsOK(res1)) {
27302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27303 }
27304 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27305 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27306 if (!SWIG_IsOK(res2)) {
27307 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27308 }
27309 if (!argp2) {
27310 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27311 }
27312 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27313 {
27314 PyThreadState* __tstate = wxPyBeginAllowThreads();
27315 {
27316 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
27317 result = (wxDateTime *) &_result_ref;
27318 }
27319 wxPyEndAllowThreads(__tstate);
27320 if (PyErr_Occurred()) SWIG_fail;
27321 }
27322 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27323 return resultobj;
27324 fail:
27325 return NULL;
27326 }
27327
27328
27329 SWIGINTERN PyObject *_wrap_DateTime_AddDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27330 PyObject *resultobj = 0;
27331 wxDateTime *arg1 = (wxDateTime *) 0 ;
27332 wxDateSpan *arg2 = 0 ;
27333 wxDateTime *result = 0 ;
27334 void *argp1 = 0 ;
27335 int res1 = 0 ;
27336 void *argp2 = 0 ;
27337 int res2 = 0 ;
27338 PyObject * obj0 = 0 ;
27339 PyObject * obj1 = 0 ;
27340 char * kwnames[] = {
27341 (char *) "self",(char *) "diff", NULL
27342 };
27343
27344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) SWIG_fail;
27345 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27346 if (!SWIG_IsOK(res1)) {
27347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27348 }
27349 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27350 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27351 if (!SWIG_IsOK(res2)) {
27352 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27353 }
27354 if (!argp2) {
27355 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27356 }
27357 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27358 {
27359 PyThreadState* __tstate = wxPyBeginAllowThreads();
27360 {
27361 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
27362 result = (wxDateTime *) &_result_ref;
27363 }
27364 wxPyEndAllowThreads(__tstate);
27365 if (PyErr_Occurred()) SWIG_fail;
27366 }
27367 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27368 return resultobj;
27369 fail:
27370 return NULL;
27371 }
27372
27373
27374 SWIGINTERN PyObject *_wrap_DateTime_SubtractTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27375 PyObject *resultobj = 0;
27376 wxDateTime *arg1 = (wxDateTime *) 0 ;
27377 wxTimeSpan *arg2 = 0 ;
27378 wxDateTime *result = 0 ;
27379 void *argp1 = 0 ;
27380 int res1 = 0 ;
27381 void *argp2 = 0 ;
27382 int res2 = 0 ;
27383 PyObject * obj0 = 0 ;
27384 PyObject * obj1 = 0 ;
27385 char * kwnames[] = {
27386 (char *) "self",(char *) "diff", NULL
27387 };
27388
27389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) SWIG_fail;
27390 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27391 if (!SWIG_IsOK(res1)) {
27392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27393 }
27394 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27395 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27396 if (!SWIG_IsOK(res2)) {
27397 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27398 }
27399 if (!argp2) {
27400 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27401 }
27402 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27403 {
27404 PyThreadState* __tstate = wxPyBeginAllowThreads();
27405 {
27406 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
27407 result = (wxDateTime *) &_result_ref;
27408 }
27409 wxPyEndAllowThreads(__tstate);
27410 if (PyErr_Occurred()) SWIG_fail;
27411 }
27412 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27413 return resultobj;
27414 fail:
27415 return NULL;
27416 }
27417
27418
27419 SWIGINTERN PyObject *_wrap_DateTime_SubtractDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27420 PyObject *resultobj = 0;
27421 wxDateTime *arg1 = (wxDateTime *) 0 ;
27422 wxDateSpan *arg2 = 0 ;
27423 wxDateTime *result = 0 ;
27424 void *argp1 = 0 ;
27425 int res1 = 0 ;
27426 void *argp2 = 0 ;
27427 int res2 = 0 ;
27428 PyObject * obj0 = 0 ;
27429 PyObject * obj1 = 0 ;
27430 char * kwnames[] = {
27431 (char *) "self",(char *) "diff", NULL
27432 };
27433
27434 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) SWIG_fail;
27435 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27436 if (!SWIG_IsOK(res1)) {
27437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27438 }
27439 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27440 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27441 if (!SWIG_IsOK(res2)) {
27442 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27443 }
27444 if (!argp2) {
27445 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27446 }
27447 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27448 {
27449 PyThreadState* __tstate = wxPyBeginAllowThreads();
27450 {
27451 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
27452 result = (wxDateTime *) &_result_ref;
27453 }
27454 wxPyEndAllowThreads(__tstate);
27455 if (PyErr_Occurred()) SWIG_fail;
27456 }
27457 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27458 return resultobj;
27459 fail:
27460 return NULL;
27461 }
27462
27463
27464 SWIGINTERN PyObject *_wrap_DateTime_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27465 PyObject *resultobj = 0;
27466 wxDateTime *arg1 = (wxDateTime *) 0 ;
27467 wxDateTime *arg2 = 0 ;
27468 wxTimeSpan result;
27469 void *argp1 = 0 ;
27470 int res1 = 0 ;
27471 void *argp2 = 0 ;
27472 int res2 = 0 ;
27473 PyObject * obj0 = 0 ;
27474 PyObject * obj1 = 0 ;
27475 char * kwnames[] = {
27476 (char *) "self",(char *) "dt", NULL
27477 };
27478
27479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
27480 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27481 if (!SWIG_IsOK(res1)) {
27482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Subtract" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27483 }
27484 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27485 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27486 if (!SWIG_IsOK(res2)) {
27487 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27488 }
27489 if (!argp2) {
27490 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27491 }
27492 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27493 {
27494 PyThreadState* __tstate = wxPyBeginAllowThreads();
27495 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
27496 wxPyEndAllowThreads(__tstate);
27497 if (PyErr_Occurred()) SWIG_fail;
27498 }
27499 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27500 return resultobj;
27501 fail:
27502 return NULL;
27503 }
27504
27505
27506 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27507 PyObject *resultobj = 0;
27508 wxDateTime *arg1 = (wxDateTime *) 0 ;
27509 wxTimeSpan *arg2 = 0 ;
27510 wxDateTime *result = 0 ;
27511 void *argp1 = 0 ;
27512 int res1 = 0 ;
27513 void *argp2 = 0 ;
27514 int res2 = 0 ;
27515
27516 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27517 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27518 if (!SWIG_IsOK(res1)) {
27519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27520 }
27521 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27522 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27523 if (!SWIG_IsOK(res2)) {
27524 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27525 }
27526 if (!argp2) {
27527 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27528 }
27529 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27530 {
27531 PyThreadState* __tstate = wxPyBeginAllowThreads();
27532 {
27533 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
27534 result = (wxDateTime *) &_result_ref;
27535 }
27536 wxPyEndAllowThreads(__tstate);
27537 if (PyErr_Occurred()) SWIG_fail;
27538 }
27539 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27540 return resultobj;
27541 fail:
27542 return NULL;
27543 }
27544
27545
27546 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27547 PyObject *resultobj = 0;
27548 wxDateTime *arg1 = (wxDateTime *) 0 ;
27549 wxDateSpan *arg2 = 0 ;
27550 wxDateTime *result = 0 ;
27551 void *argp1 = 0 ;
27552 int res1 = 0 ;
27553 void *argp2 = 0 ;
27554 int res2 = 0 ;
27555
27556 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27557 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27558 if (!SWIG_IsOK(res1)) {
27559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27560 }
27561 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27562 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27563 if (!SWIG_IsOK(res2)) {
27564 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27565 }
27566 if (!argp2) {
27567 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27568 }
27569 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27570 {
27571 PyThreadState* __tstate = wxPyBeginAllowThreads();
27572 {
27573 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
27574 result = (wxDateTime *) &_result_ref;
27575 }
27576 wxPyEndAllowThreads(__tstate);
27577 if (PyErr_Occurred()) SWIG_fail;
27578 }
27579 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27580 return resultobj;
27581 fail:
27582 return NULL;
27583 }
27584
27585
27586 SWIGINTERN PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
27587 int argc;
27588 PyObject *argv[3];
27589
27590 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___iadd__",0,2,argv))) SWIG_fail;
27591 --argc;
27592 if (argc == 2) {
27593 int _v = 0;
27594 {
27595 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27596 _v = SWIG_CheckState(res);
27597 }
27598 if (!_v) goto check_1;
27599 return _wrap_DateTime___iadd____SWIG_0(self, argc, argv);
27600 }
27601 check_1:
27602
27603 if (argc == 2) {
27604 return _wrap_DateTime___iadd____SWIG_1(self, argc, argv);
27605 }
27606
27607 fail:
27608 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
27609 return NULL;
27610 }
27611
27612
27613 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27614 PyObject *resultobj = 0;
27615 wxDateTime *arg1 = (wxDateTime *) 0 ;
27616 wxTimeSpan *arg2 = 0 ;
27617 wxDateTime *result = 0 ;
27618 void *argp1 = 0 ;
27619 int res1 = 0 ;
27620 void *argp2 = 0 ;
27621 int res2 = 0 ;
27622
27623 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27624 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27625 if (!SWIG_IsOK(res1)) {
27626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27627 }
27628 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27629 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27630 if (!SWIG_IsOK(res2)) {
27631 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27632 }
27633 if (!argp2) {
27634 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27635 }
27636 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27637 {
27638 PyThreadState* __tstate = wxPyBeginAllowThreads();
27639 {
27640 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
27641 result = (wxDateTime *) &_result_ref;
27642 }
27643 wxPyEndAllowThreads(__tstate);
27644 if (PyErr_Occurred()) SWIG_fail;
27645 }
27646 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27647 return resultobj;
27648 fail:
27649 return NULL;
27650 }
27651
27652
27653 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27654 PyObject *resultobj = 0;
27655 wxDateTime *arg1 = (wxDateTime *) 0 ;
27656 wxDateSpan *arg2 = 0 ;
27657 wxDateTime *result = 0 ;
27658 void *argp1 = 0 ;
27659 int res1 = 0 ;
27660 void *argp2 = 0 ;
27661 int res2 = 0 ;
27662
27663 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27664 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27665 if (!SWIG_IsOK(res1)) {
27666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27667 }
27668 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27669 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27670 if (!SWIG_IsOK(res2)) {
27671 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27672 }
27673 if (!argp2) {
27674 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27675 }
27676 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27677 {
27678 PyThreadState* __tstate = wxPyBeginAllowThreads();
27679 {
27680 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
27681 result = (wxDateTime *) &_result_ref;
27682 }
27683 wxPyEndAllowThreads(__tstate);
27684 if (PyErr_Occurred()) SWIG_fail;
27685 }
27686 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27687 return resultobj;
27688 fail:
27689 return NULL;
27690 }
27691
27692
27693 SWIGINTERN PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
27694 int argc;
27695 PyObject *argv[3];
27696
27697 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___isub__",0,2,argv))) SWIG_fail;
27698 --argc;
27699 if (argc == 2) {
27700 int _v = 0;
27701 {
27702 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27703 _v = SWIG_CheckState(res);
27704 }
27705 if (!_v) goto check_1;
27706 return _wrap_DateTime___isub____SWIG_0(self, argc, argv);
27707 }
27708 check_1:
27709
27710 if (argc == 2) {
27711 return _wrap_DateTime___isub____SWIG_1(self, argc, argv);
27712 }
27713
27714 fail:
27715 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
27716 return NULL;
27717 }
27718
27719
27720 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27721 PyObject *resultobj = 0;
27722 wxDateTime *arg1 = (wxDateTime *) 0 ;
27723 wxTimeSpan *arg2 = 0 ;
27724 wxDateTime result;
27725 void *argp1 = 0 ;
27726 int res1 = 0 ;
27727 void *argp2 = 0 ;
27728 int res2 = 0 ;
27729
27730 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27731 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27732 if (!SWIG_IsOK(res1)) {
27733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27734 }
27735 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27736 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27737 if (!SWIG_IsOK(res2)) {
27738 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27739 }
27740 if (!argp2) {
27741 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27742 }
27743 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27744 {
27745 PyThreadState* __tstate = wxPyBeginAllowThreads();
27746 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
27747 wxPyEndAllowThreads(__tstate);
27748 if (PyErr_Occurred()) SWIG_fail;
27749 }
27750 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27751 return resultobj;
27752 fail:
27753 return NULL;
27754 }
27755
27756
27757 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27758 PyObject *resultobj = 0;
27759 wxDateTime *arg1 = (wxDateTime *) 0 ;
27760 wxDateSpan *arg2 = 0 ;
27761 wxDateTime result;
27762 void *argp1 = 0 ;
27763 int res1 = 0 ;
27764 void *argp2 = 0 ;
27765 int res2 = 0 ;
27766
27767 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27769 if (!SWIG_IsOK(res1)) {
27770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27771 }
27772 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27773 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27774 if (!SWIG_IsOK(res2)) {
27775 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27776 }
27777 if (!argp2) {
27778 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27779 }
27780 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27781 {
27782 PyThreadState* __tstate = wxPyBeginAllowThreads();
27783 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
27784 wxPyEndAllowThreads(__tstate);
27785 if (PyErr_Occurred()) SWIG_fail;
27786 }
27787 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27788 return resultobj;
27789 fail:
27790 return NULL;
27791 }
27792
27793
27794 SWIGINTERN PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
27795 int argc;
27796 PyObject *argv[3];
27797
27798 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___add__",0,2,argv))) SWIG_fail;
27799 --argc;
27800 if (argc == 2) {
27801 int _v = 0;
27802 {
27803 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27804 _v = SWIG_CheckState(res);
27805 }
27806 if (!_v) goto check_1;
27807 return _wrap_DateTime___add____SWIG_0(self, argc, argv);
27808 }
27809 check_1:
27810
27811 if (argc == 2) {
27812 return _wrap_DateTime___add____SWIG_1(self, argc, argv);
27813 }
27814
27815 fail:
27816 Py_INCREF(Py_NotImplemented);
27817 return Py_NotImplemented;
27818 }
27819
27820
27821 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27822 PyObject *resultobj = 0;
27823 wxDateTime *arg1 = (wxDateTime *) 0 ;
27824 wxDateTime *arg2 = 0 ;
27825 wxTimeSpan result;
27826 void *argp1 = 0 ;
27827 int res1 = 0 ;
27828 void *argp2 = 0 ;
27829 int res2 = 0 ;
27830
27831 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27832 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27833 if (!SWIG_IsOK(res1)) {
27834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27835 }
27836 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27837 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27838 if (!SWIG_IsOK(res2)) {
27839 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27840 }
27841 if (!argp2) {
27842 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27843 }
27844 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27845 {
27846 PyThreadState* __tstate = wxPyBeginAllowThreads();
27847 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
27848 wxPyEndAllowThreads(__tstate);
27849 if (PyErr_Occurred()) SWIG_fail;
27850 }
27851 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27852 return resultobj;
27853 fail:
27854 return NULL;
27855 }
27856
27857
27858 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27859 PyObject *resultobj = 0;
27860 wxDateTime *arg1 = (wxDateTime *) 0 ;
27861 wxTimeSpan *arg2 = 0 ;
27862 wxDateTime result;
27863 void *argp1 = 0 ;
27864 int res1 = 0 ;
27865 void *argp2 = 0 ;
27866 int res2 = 0 ;
27867
27868 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27869 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27870 if (!SWIG_IsOK(res1)) {
27871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27872 }
27873 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27874 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27875 if (!SWIG_IsOK(res2)) {
27876 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27877 }
27878 if (!argp2) {
27879 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27880 }
27881 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27882 {
27883 PyThreadState* __tstate = wxPyBeginAllowThreads();
27884 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
27885 wxPyEndAllowThreads(__tstate);
27886 if (PyErr_Occurred()) SWIG_fail;
27887 }
27888 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27889 return resultobj;
27890 fail:
27891 return NULL;
27892 }
27893
27894
27895 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27896 PyObject *resultobj = 0;
27897 wxDateTime *arg1 = (wxDateTime *) 0 ;
27898 wxDateSpan *arg2 = 0 ;
27899 wxDateTime result;
27900 void *argp1 = 0 ;
27901 int res1 = 0 ;
27902 void *argp2 = 0 ;
27903 int res2 = 0 ;
27904
27905 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27906 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27907 if (!SWIG_IsOK(res1)) {
27908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27909 }
27910 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27911 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27912 if (!SWIG_IsOK(res2)) {
27913 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27914 }
27915 if (!argp2) {
27916 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27917 }
27918 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27919 {
27920 PyThreadState* __tstate = wxPyBeginAllowThreads();
27921 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
27922 wxPyEndAllowThreads(__tstate);
27923 if (PyErr_Occurred()) SWIG_fail;
27924 }
27925 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27926 return resultobj;
27927 fail:
27928 return NULL;
27929 }
27930
27931
27932 SWIGINTERN PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
27933 int argc;
27934 PyObject *argv[3];
27935
27936 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___sub__",0,2,argv))) SWIG_fail;
27937 --argc;
27938 if (argc == 2) {
27939 int _v = 0;
27940 {
27941 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDateTime, 0);
27942 _v = SWIG_CheckState(res);
27943 }
27944 if (!_v) goto check_1;
27945 return _wrap_DateTime___sub____SWIG_0(self, argc, argv);
27946 }
27947 check_1:
27948
27949 if (argc == 2) {
27950 int _v = 0;
27951 {
27952 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27953 _v = SWIG_CheckState(res);
27954 }
27955 if (!_v) goto check_2;
27956 return _wrap_DateTime___sub____SWIG_1(self, argc, argv);
27957 }
27958 check_2:
27959
27960 if (argc == 2) {
27961 return _wrap_DateTime___sub____SWIG_2(self, argc, argv);
27962 }
27963
27964 fail:
27965 Py_INCREF(Py_NotImplemented);
27966 return Py_NotImplemented;
27967 }
27968
27969
27970 SWIGINTERN PyObject *_wrap_DateTime___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27971 PyObject *resultobj = 0;
27972 wxDateTime *arg1 = (wxDateTime *) 0 ;
27973 wxDateTime *arg2 = (wxDateTime *) 0 ;
27974 bool result;
27975 void *argp1 = 0 ;
27976 int res1 = 0 ;
27977 void *argp2 = 0 ;
27978 int res2 = 0 ;
27979 PyObject * obj0 = 0 ;
27980 PyObject * obj1 = 0 ;
27981 char * kwnames[] = {
27982 (char *) "self",(char *) "other", NULL
27983 };
27984
27985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
27986 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27987 if (!SWIG_IsOK(res1)) {
27988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___lt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27989 }
27990 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27991 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27992 if (!SWIG_IsOK(res2)) {
27993 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___lt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
27994 }
27995 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27996 {
27997 PyThreadState* __tstate = wxPyBeginAllowThreads();
27998 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
27999 wxPyEndAllowThreads(__tstate);
28000 if (PyErr_Occurred()) SWIG_fail;
28001 }
28002 {
28003 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28004 }
28005 return resultobj;
28006 fail:
28007 return NULL;
28008 }
28009
28010
28011 SWIGINTERN PyObject *_wrap_DateTime___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28012 PyObject *resultobj = 0;
28013 wxDateTime *arg1 = (wxDateTime *) 0 ;
28014 wxDateTime *arg2 = (wxDateTime *) 0 ;
28015 bool result;
28016 void *argp1 = 0 ;
28017 int res1 = 0 ;
28018 void *argp2 = 0 ;
28019 int res2 = 0 ;
28020 PyObject * obj0 = 0 ;
28021 PyObject * obj1 = 0 ;
28022 char * kwnames[] = {
28023 (char *) "self",(char *) "other", NULL
28024 };
28025
28026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) SWIG_fail;
28027 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28028 if (!SWIG_IsOK(res1)) {
28029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___le__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28030 }
28031 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28032 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28033 if (!SWIG_IsOK(res2)) {
28034 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___le__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28035 }
28036 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28037 {
28038 PyThreadState* __tstate = wxPyBeginAllowThreads();
28039 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
28040 wxPyEndAllowThreads(__tstate);
28041 if (PyErr_Occurred()) SWIG_fail;
28042 }
28043 {
28044 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28045 }
28046 return resultobj;
28047 fail:
28048 return NULL;
28049 }
28050
28051
28052 SWIGINTERN PyObject *_wrap_DateTime___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28053 PyObject *resultobj = 0;
28054 wxDateTime *arg1 = (wxDateTime *) 0 ;
28055 wxDateTime *arg2 = (wxDateTime *) 0 ;
28056 bool result;
28057 void *argp1 = 0 ;
28058 int res1 = 0 ;
28059 void *argp2 = 0 ;
28060 int res2 = 0 ;
28061 PyObject * obj0 = 0 ;
28062 PyObject * obj1 = 0 ;
28063 char * kwnames[] = {
28064 (char *) "self",(char *) "other", NULL
28065 };
28066
28067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
28068 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28069 if (!SWIG_IsOK(res1)) {
28070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___gt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28071 }
28072 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28073 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28074 if (!SWIG_IsOK(res2)) {
28075 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___gt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28076 }
28077 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28078 {
28079 PyThreadState* __tstate = wxPyBeginAllowThreads();
28080 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
28081 wxPyEndAllowThreads(__tstate);
28082 if (PyErr_Occurred()) SWIG_fail;
28083 }
28084 {
28085 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28086 }
28087 return resultobj;
28088 fail:
28089 return NULL;
28090 }
28091
28092
28093 SWIGINTERN PyObject *_wrap_DateTime___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28094 PyObject *resultobj = 0;
28095 wxDateTime *arg1 = (wxDateTime *) 0 ;
28096 wxDateTime *arg2 = (wxDateTime *) 0 ;
28097 bool result;
28098 void *argp1 = 0 ;
28099 int res1 = 0 ;
28100 void *argp2 = 0 ;
28101 int res2 = 0 ;
28102 PyObject * obj0 = 0 ;
28103 PyObject * obj1 = 0 ;
28104 char * kwnames[] = {
28105 (char *) "self",(char *) "other", NULL
28106 };
28107
28108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
28109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28110 if (!SWIG_IsOK(res1)) {
28111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ge__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28112 }
28113 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28114 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28115 if (!SWIG_IsOK(res2)) {
28116 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ge__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28117 }
28118 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28119 {
28120 PyThreadState* __tstate = wxPyBeginAllowThreads();
28121 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
28122 wxPyEndAllowThreads(__tstate);
28123 if (PyErr_Occurred()) SWIG_fail;
28124 }
28125 {
28126 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28127 }
28128 return resultobj;
28129 fail:
28130 return NULL;
28131 }
28132
28133
28134 SWIGINTERN PyObject *_wrap_DateTime___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28135 PyObject *resultobj = 0;
28136 wxDateTime *arg1 = (wxDateTime *) 0 ;
28137 wxDateTime *arg2 = (wxDateTime *) 0 ;
28138 bool result;
28139 void *argp1 = 0 ;
28140 int res1 = 0 ;
28141 void *argp2 = 0 ;
28142 int res2 = 0 ;
28143 PyObject * obj0 = 0 ;
28144 PyObject * obj1 = 0 ;
28145 char * kwnames[] = {
28146 (char *) "self",(char *) "other", NULL
28147 };
28148
28149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
28150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28151 if (!SWIG_IsOK(res1)) {
28152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___eq__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28153 }
28154 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28155 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28156 if (!SWIG_IsOK(res2)) {
28157 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___eq__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28158 }
28159 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28160 {
28161 PyThreadState* __tstate = wxPyBeginAllowThreads();
28162 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
28163 wxPyEndAllowThreads(__tstate);
28164 if (PyErr_Occurred()) SWIG_fail;
28165 }
28166 {
28167 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28168 }
28169 return resultobj;
28170 fail:
28171 return NULL;
28172 }
28173
28174
28175 SWIGINTERN PyObject *_wrap_DateTime___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28176 PyObject *resultobj = 0;
28177 wxDateTime *arg1 = (wxDateTime *) 0 ;
28178 wxDateTime *arg2 = (wxDateTime *) 0 ;
28179 bool result;
28180 void *argp1 = 0 ;
28181 int res1 = 0 ;
28182 void *argp2 = 0 ;
28183 int res2 = 0 ;
28184 PyObject * obj0 = 0 ;
28185 PyObject * obj1 = 0 ;
28186 char * kwnames[] = {
28187 (char *) "self",(char *) "other", NULL
28188 };
28189
28190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
28191 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28192 if (!SWIG_IsOK(res1)) {
28193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ne__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28194 }
28195 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28196 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28197 if (!SWIG_IsOK(res2)) {
28198 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ne__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28199 }
28200 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28201 {
28202 PyThreadState* __tstate = wxPyBeginAllowThreads();
28203 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
28204 wxPyEndAllowThreads(__tstate);
28205 if (PyErr_Occurred()) SWIG_fail;
28206 }
28207 {
28208 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28209 }
28210 return resultobj;
28211 fail:
28212 return NULL;
28213 }
28214
28215
28216 SWIGINTERN PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28217 PyObject *resultobj = 0;
28218 wxDateTime *arg1 = (wxDateTime *) 0 ;
28219 wxString *arg2 = 0 ;
28220 int result;
28221 void *argp1 = 0 ;
28222 int res1 = 0 ;
28223 bool temp2 = false ;
28224 PyObject * obj0 = 0 ;
28225 PyObject * obj1 = 0 ;
28226 char * kwnames[] = {
28227 (char *) "self",(char *) "date", NULL
28228 };
28229
28230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) SWIG_fail;
28231 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28232 if (!SWIG_IsOK(res1)) {
28233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseRfc822Date" "', expected argument " "1"" of type '" "wxDateTime *""'");
28234 }
28235 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28236 {
28237 arg2 = wxString_in_helper(obj1);
28238 if (arg2 == NULL) SWIG_fail;
28239 temp2 = true;
28240 }
28241 {
28242 PyThreadState* __tstate = wxPyBeginAllowThreads();
28243 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
28244 wxPyEndAllowThreads(__tstate);
28245 if (PyErr_Occurred()) SWIG_fail;
28246 }
28247 resultobj = SWIG_From_int(static_cast< int >(result));
28248 {
28249 if (temp2)
28250 delete arg2;
28251 }
28252 return resultobj;
28253 fail:
28254 {
28255 if (temp2)
28256 delete arg2;
28257 }
28258 return NULL;
28259 }
28260
28261
28262 SWIGINTERN PyObject *_wrap_DateTime_ParseFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28263 PyObject *resultobj = 0;
28264 wxDateTime *arg1 = (wxDateTime *) 0 ;
28265 wxString *arg2 = 0 ;
28266 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
28267 wxString *arg3 = (wxString *) &arg3_defvalue ;
28268 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
28269 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
28270 int result;
28271 void *argp1 = 0 ;
28272 int res1 = 0 ;
28273 bool temp2 = false ;
28274 bool temp3 = false ;
28275 void *argp4 = 0 ;
28276 int res4 = 0 ;
28277 PyObject * obj0 = 0 ;
28278 PyObject * obj1 = 0 ;
28279 PyObject * obj2 = 0 ;
28280 PyObject * obj3 = 0 ;
28281 char * kwnames[] = {
28282 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
28283 };
28284
28285 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28286 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28287 if (!SWIG_IsOK(res1)) {
28288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseFormat" "', expected argument " "1"" of type '" "wxDateTime *""'");
28289 }
28290 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28291 {
28292 arg2 = wxString_in_helper(obj1);
28293 if (arg2 == NULL) SWIG_fail;
28294 temp2 = true;
28295 }
28296 if (obj2) {
28297 {
28298 arg3 = wxString_in_helper(obj2);
28299 if (arg3 == NULL) SWIG_fail;
28300 temp3 = true;
28301 }
28302 }
28303 if (obj3) {
28304 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDateTime, 0 | 0);
28305 if (!SWIG_IsOK(res4)) {
28306 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
28307 }
28308 if (!argp4) {
28309 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
28310 }
28311 arg4 = reinterpret_cast< wxDateTime * >(argp4);
28312 }
28313 {
28314 PyThreadState* __tstate = wxPyBeginAllowThreads();
28315 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
28316 wxPyEndAllowThreads(__tstate);
28317 if (PyErr_Occurred()) SWIG_fail;
28318 }
28319 resultobj = SWIG_From_int(static_cast< int >(result));
28320 {
28321 if (temp2)
28322 delete arg2;
28323 }
28324 {
28325 if (temp3)
28326 delete arg3;
28327 }
28328 return resultobj;
28329 fail:
28330 {
28331 if (temp2)
28332 delete arg2;
28333 }
28334 {
28335 if (temp3)
28336 delete arg3;
28337 }
28338 return NULL;
28339 }
28340
28341
28342 SWIGINTERN PyObject *_wrap_DateTime_ParseDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28343 PyObject *resultobj = 0;
28344 wxDateTime *arg1 = (wxDateTime *) 0 ;
28345 wxString *arg2 = 0 ;
28346 int result;
28347 void *argp1 = 0 ;
28348 int res1 = 0 ;
28349 bool temp2 = false ;
28350 PyObject * obj0 = 0 ;
28351 PyObject * obj1 = 0 ;
28352 char * kwnames[] = {
28353 (char *) "self",(char *) "datetime", NULL
28354 };
28355
28356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) SWIG_fail;
28357 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28358 if (!SWIG_IsOK(res1)) {
28359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
28360 }
28361 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28362 {
28363 arg2 = wxString_in_helper(obj1);
28364 if (arg2 == NULL) SWIG_fail;
28365 temp2 = true;
28366 }
28367 {
28368 PyThreadState* __tstate = wxPyBeginAllowThreads();
28369 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
28370 wxPyEndAllowThreads(__tstate);
28371 if (PyErr_Occurred()) SWIG_fail;
28372 }
28373 resultobj = SWIG_From_int(static_cast< int >(result));
28374 {
28375 if (temp2)
28376 delete arg2;
28377 }
28378 return resultobj;
28379 fail:
28380 {
28381 if (temp2)
28382 delete arg2;
28383 }
28384 return NULL;
28385 }
28386
28387
28388 SWIGINTERN PyObject *_wrap_DateTime_ParseDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28389 PyObject *resultobj = 0;
28390 wxDateTime *arg1 = (wxDateTime *) 0 ;
28391 wxString *arg2 = 0 ;
28392 int result;
28393 void *argp1 = 0 ;
28394 int res1 = 0 ;
28395 bool temp2 = false ;
28396 PyObject * obj0 = 0 ;
28397 PyObject * obj1 = 0 ;
28398 char * kwnames[] = {
28399 (char *) "self",(char *) "date", NULL
28400 };
28401
28402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) SWIG_fail;
28403 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28404 if (!SWIG_IsOK(res1)) {
28405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDate" "', expected argument " "1"" of type '" "wxDateTime *""'");
28406 }
28407 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28408 {
28409 arg2 = wxString_in_helper(obj1);
28410 if (arg2 == NULL) SWIG_fail;
28411 temp2 = true;
28412 }
28413 {
28414 PyThreadState* __tstate = wxPyBeginAllowThreads();
28415 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
28416 wxPyEndAllowThreads(__tstate);
28417 if (PyErr_Occurred()) SWIG_fail;
28418 }
28419 resultobj = SWIG_From_int(static_cast< int >(result));
28420 {
28421 if (temp2)
28422 delete arg2;
28423 }
28424 return resultobj;
28425 fail:
28426 {
28427 if (temp2)
28428 delete arg2;
28429 }
28430 return NULL;
28431 }
28432
28433
28434 SWIGINTERN PyObject *_wrap_DateTime_ParseTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28435 PyObject *resultobj = 0;
28436 wxDateTime *arg1 = (wxDateTime *) 0 ;
28437 wxString *arg2 = 0 ;
28438 int result;
28439 void *argp1 = 0 ;
28440 int res1 = 0 ;
28441 bool temp2 = false ;
28442 PyObject * obj0 = 0 ;
28443 PyObject * obj1 = 0 ;
28444 char * kwnames[] = {
28445 (char *) "self",(char *) "time", NULL
28446 };
28447
28448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) SWIG_fail;
28449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28450 if (!SWIG_IsOK(res1)) {
28451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
28452 }
28453 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28454 {
28455 arg2 = wxString_in_helper(obj1);
28456 if (arg2 == NULL) SWIG_fail;
28457 temp2 = true;
28458 }
28459 {
28460 PyThreadState* __tstate = wxPyBeginAllowThreads();
28461 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
28462 wxPyEndAllowThreads(__tstate);
28463 if (PyErr_Occurred()) SWIG_fail;
28464 }
28465 resultobj = SWIG_From_int(static_cast< int >(result));
28466 {
28467 if (temp2)
28468 delete arg2;
28469 }
28470 return resultobj;
28471 fail:
28472 {
28473 if (temp2)
28474 delete arg2;
28475 }
28476 return NULL;
28477 }
28478
28479
28480 SWIGINTERN PyObject *_wrap_DateTime_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28481 PyObject *resultobj = 0;
28482 wxDateTime *arg1 = (wxDateTime *) 0 ;
28483 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
28484 wxString *arg2 = (wxString *) &arg2_defvalue ;
28485 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
28486 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
28487 wxString result;
28488 void *argp1 = 0 ;
28489 int res1 = 0 ;
28490 bool temp2 = false ;
28491 bool temp3 = false ;
28492 PyObject * obj0 = 0 ;
28493 PyObject * obj1 = 0 ;
28494 PyObject * obj2 = 0 ;
28495 char * kwnames[] = {
28496 (char *) "self",(char *) "format",(char *) "tz", NULL
28497 };
28498
28499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28500 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28501 if (!SWIG_IsOK(res1)) {
28502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Format" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28503 }
28504 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28505 if (obj1) {
28506 {
28507 arg2 = wxString_in_helper(obj1);
28508 if (arg2 == NULL) SWIG_fail;
28509 temp2 = true;
28510 }
28511 }
28512 if (obj2) {
28513 {
28514 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
28515 temp3 = true;
28516 }
28517 }
28518 {
28519 PyThreadState* __tstate = wxPyBeginAllowThreads();
28520 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
28521 wxPyEndAllowThreads(__tstate);
28522 if (PyErr_Occurred()) SWIG_fail;
28523 }
28524 {
28525 #if wxUSE_UNICODE
28526 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28527 #else
28528 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28529 #endif
28530 }
28531 {
28532 if (temp2)
28533 delete arg2;
28534 }
28535 {
28536 if (temp3) delete arg3;
28537 }
28538 return resultobj;
28539 fail:
28540 {
28541 if (temp2)
28542 delete arg2;
28543 }
28544 {
28545 if (temp3) delete arg3;
28546 }
28547 return NULL;
28548 }
28549
28550
28551 SWIGINTERN PyObject *_wrap_DateTime_FormatDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28552 PyObject *resultobj = 0;
28553 wxDateTime *arg1 = (wxDateTime *) 0 ;
28554 wxString result;
28555 void *argp1 = 0 ;
28556 int res1 = 0 ;
28557 PyObject *swig_obj[1] ;
28558
28559 if (!args) SWIG_fail;
28560 swig_obj[0] = args;
28561 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28562 if (!SWIG_IsOK(res1)) {
28563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28564 }
28565 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28566 {
28567 PyThreadState* __tstate = wxPyBeginAllowThreads();
28568 result = ((wxDateTime const *)arg1)->FormatDate();
28569 wxPyEndAllowThreads(__tstate);
28570 if (PyErr_Occurred()) SWIG_fail;
28571 }
28572 {
28573 #if wxUSE_UNICODE
28574 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28575 #else
28576 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28577 #endif
28578 }
28579 return resultobj;
28580 fail:
28581 return NULL;
28582 }
28583
28584
28585 SWIGINTERN PyObject *_wrap_DateTime_FormatTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28586 PyObject *resultobj = 0;
28587 wxDateTime *arg1 = (wxDateTime *) 0 ;
28588 wxString result;
28589 void *argp1 = 0 ;
28590 int res1 = 0 ;
28591 PyObject *swig_obj[1] ;
28592
28593 if (!args) SWIG_fail;
28594 swig_obj[0] = args;
28595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28596 if (!SWIG_IsOK(res1)) {
28597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28598 }
28599 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28600 {
28601 PyThreadState* __tstate = wxPyBeginAllowThreads();
28602 result = ((wxDateTime const *)arg1)->FormatTime();
28603 wxPyEndAllowThreads(__tstate);
28604 if (PyErr_Occurred()) SWIG_fail;
28605 }
28606 {
28607 #if wxUSE_UNICODE
28608 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28609 #else
28610 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28611 #endif
28612 }
28613 return resultobj;
28614 fail:
28615 return NULL;
28616 }
28617
28618
28619 SWIGINTERN PyObject *_wrap_DateTime_FormatISODate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28620 PyObject *resultobj = 0;
28621 wxDateTime *arg1 = (wxDateTime *) 0 ;
28622 wxString result;
28623 void *argp1 = 0 ;
28624 int res1 = 0 ;
28625 PyObject *swig_obj[1] ;
28626
28627 if (!args) SWIG_fail;
28628 swig_obj[0] = args;
28629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28630 if (!SWIG_IsOK(res1)) {
28631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISODate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28632 }
28633 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28634 {
28635 PyThreadState* __tstate = wxPyBeginAllowThreads();
28636 result = ((wxDateTime const *)arg1)->FormatISODate();
28637 wxPyEndAllowThreads(__tstate);
28638 if (PyErr_Occurred()) SWIG_fail;
28639 }
28640 {
28641 #if wxUSE_UNICODE
28642 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28643 #else
28644 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28645 #endif
28646 }
28647 return resultobj;
28648 fail:
28649 return NULL;
28650 }
28651
28652
28653 SWIGINTERN PyObject *_wrap_DateTime_FormatISOTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28654 PyObject *resultobj = 0;
28655 wxDateTime *arg1 = (wxDateTime *) 0 ;
28656 wxString result;
28657 void *argp1 = 0 ;
28658 int res1 = 0 ;
28659 PyObject *swig_obj[1] ;
28660
28661 if (!args) SWIG_fail;
28662 swig_obj[0] = args;
28663 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28664 if (!SWIG_IsOK(res1)) {
28665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISOTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28666 }
28667 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28668 {
28669 PyThreadState* __tstate = wxPyBeginAllowThreads();
28670 result = ((wxDateTime const *)arg1)->FormatISOTime();
28671 wxPyEndAllowThreads(__tstate);
28672 if (PyErr_Occurred()) SWIG_fail;
28673 }
28674 {
28675 #if wxUSE_UNICODE
28676 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28677 #else
28678 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28679 #endif
28680 }
28681 return resultobj;
28682 fail:
28683 return NULL;
28684 }
28685
28686
28687 SWIGINTERN PyObject *DateTime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28688 PyObject *obj;
28689 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28690 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateTime, SWIG_NewClientData(obj));
28691 return SWIG_Py_Void();
28692 }
28693
28694 SWIGINTERN PyObject *DateTime_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28695 return SWIG_Python_InitShadowInstance(args);
28696 }
28697
28698 SWIGINTERN PyObject *_wrap_TimeSpan_Milliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28699 PyObject *resultobj = 0;
28700 long arg1 ;
28701 wxTimeSpan result;
28702 long val1 ;
28703 int ecode1 = 0 ;
28704 PyObject * obj0 = 0 ;
28705 char * kwnames[] = {
28706 (char *) "ms", NULL
28707 };
28708
28709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Milliseconds",kwnames,&obj0)) SWIG_fail;
28710 ecode1 = SWIG_AsVal_long(obj0, &val1);
28711 if (!SWIG_IsOK(ecode1)) {
28712 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Milliseconds" "', expected argument " "1"" of type '" "long""'");
28713 }
28714 arg1 = static_cast< long >(val1);
28715 {
28716 PyThreadState* __tstate = wxPyBeginAllowThreads();
28717 result = wxTimeSpan::Milliseconds(arg1);
28718 wxPyEndAllowThreads(__tstate);
28719 if (PyErr_Occurred()) SWIG_fail;
28720 }
28721 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28722 return resultobj;
28723 fail:
28724 return NULL;
28725 }
28726
28727
28728 SWIGINTERN PyObject *_wrap_TimeSpan_Millisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28729 PyObject *resultobj = 0;
28730 wxTimeSpan result;
28731
28732 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Millisecond",0,0,0)) SWIG_fail;
28733 {
28734 PyThreadState* __tstate = wxPyBeginAllowThreads();
28735 result = wxTimeSpan::Millisecond();
28736 wxPyEndAllowThreads(__tstate);
28737 if (PyErr_Occurred()) SWIG_fail;
28738 }
28739 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28740 return resultobj;
28741 fail:
28742 return NULL;
28743 }
28744
28745
28746 SWIGINTERN PyObject *_wrap_TimeSpan_Seconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28747 PyObject *resultobj = 0;
28748 long arg1 ;
28749 wxTimeSpan result;
28750 long val1 ;
28751 int ecode1 = 0 ;
28752 PyObject * obj0 = 0 ;
28753 char * kwnames[] = {
28754 (char *) "sec", NULL
28755 };
28756
28757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) SWIG_fail;
28758 ecode1 = SWIG_AsVal_long(obj0, &val1);
28759 if (!SWIG_IsOK(ecode1)) {
28760 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Seconds" "', expected argument " "1"" of type '" "long""'");
28761 }
28762 arg1 = static_cast< long >(val1);
28763 {
28764 PyThreadState* __tstate = wxPyBeginAllowThreads();
28765 result = wxTimeSpan::Seconds(arg1);
28766 wxPyEndAllowThreads(__tstate);
28767 if (PyErr_Occurred()) SWIG_fail;
28768 }
28769 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28770 return resultobj;
28771 fail:
28772 return NULL;
28773 }
28774
28775
28776 SWIGINTERN PyObject *_wrap_TimeSpan_Second(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28777 PyObject *resultobj = 0;
28778 wxTimeSpan result;
28779
28780 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Second",0,0,0)) SWIG_fail;
28781 {
28782 PyThreadState* __tstate = wxPyBeginAllowThreads();
28783 result = wxTimeSpan::Second();
28784 wxPyEndAllowThreads(__tstate);
28785 if (PyErr_Occurred()) SWIG_fail;
28786 }
28787 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28788 return resultobj;
28789 fail:
28790 return NULL;
28791 }
28792
28793
28794 SWIGINTERN PyObject *_wrap_TimeSpan_Minutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28795 PyObject *resultobj = 0;
28796 long arg1 ;
28797 wxTimeSpan result;
28798 long val1 ;
28799 int ecode1 = 0 ;
28800 PyObject * obj0 = 0 ;
28801 char * kwnames[] = {
28802 (char *) "min", NULL
28803 };
28804
28805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) SWIG_fail;
28806 ecode1 = SWIG_AsVal_long(obj0, &val1);
28807 if (!SWIG_IsOK(ecode1)) {
28808 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Minutes" "', expected argument " "1"" of type '" "long""'");
28809 }
28810 arg1 = static_cast< long >(val1);
28811 {
28812 PyThreadState* __tstate = wxPyBeginAllowThreads();
28813 result = wxTimeSpan::Minutes(arg1);
28814 wxPyEndAllowThreads(__tstate);
28815 if (PyErr_Occurred()) SWIG_fail;
28816 }
28817 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28818 return resultobj;
28819 fail:
28820 return NULL;
28821 }
28822
28823
28824 SWIGINTERN PyObject *_wrap_TimeSpan_Minute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28825 PyObject *resultobj = 0;
28826 wxTimeSpan result;
28827
28828 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Minute",0,0,0)) SWIG_fail;
28829 {
28830 PyThreadState* __tstate = wxPyBeginAllowThreads();
28831 result = wxTimeSpan::Minute();
28832 wxPyEndAllowThreads(__tstate);
28833 if (PyErr_Occurred()) SWIG_fail;
28834 }
28835 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28836 return resultobj;
28837 fail:
28838 return NULL;
28839 }
28840
28841
28842 SWIGINTERN PyObject *_wrap_TimeSpan_Hours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28843 PyObject *resultobj = 0;
28844 long arg1 ;
28845 wxTimeSpan result;
28846 long val1 ;
28847 int ecode1 = 0 ;
28848 PyObject * obj0 = 0 ;
28849 char * kwnames[] = {
28850 (char *) "hours", NULL
28851 };
28852
28853 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) SWIG_fail;
28854 ecode1 = SWIG_AsVal_long(obj0, &val1);
28855 if (!SWIG_IsOK(ecode1)) {
28856 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Hours" "', expected argument " "1"" of type '" "long""'");
28857 }
28858 arg1 = static_cast< long >(val1);
28859 {
28860 PyThreadState* __tstate = wxPyBeginAllowThreads();
28861 result = wxTimeSpan::Hours(arg1);
28862 wxPyEndAllowThreads(__tstate);
28863 if (PyErr_Occurred()) SWIG_fail;
28864 }
28865 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28866 return resultobj;
28867 fail:
28868 return NULL;
28869 }
28870
28871
28872 SWIGINTERN PyObject *_wrap_TimeSpan_Hour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28873 PyObject *resultobj = 0;
28874 wxTimeSpan result;
28875
28876 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Hour",0,0,0)) SWIG_fail;
28877 {
28878 PyThreadState* __tstate = wxPyBeginAllowThreads();
28879 result = wxTimeSpan::Hour();
28880 wxPyEndAllowThreads(__tstate);
28881 if (PyErr_Occurred()) SWIG_fail;
28882 }
28883 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28884 return resultobj;
28885 fail:
28886 return NULL;
28887 }
28888
28889
28890 SWIGINTERN PyObject *_wrap_TimeSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28891 PyObject *resultobj = 0;
28892 long arg1 ;
28893 wxTimeSpan result;
28894 long val1 ;
28895 int ecode1 = 0 ;
28896 PyObject * obj0 = 0 ;
28897 char * kwnames[] = {
28898 (char *) "days", NULL
28899 };
28900
28901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) SWIG_fail;
28902 ecode1 = SWIG_AsVal_long(obj0, &val1);
28903 if (!SWIG_IsOK(ecode1)) {
28904 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Days" "', expected argument " "1"" of type '" "long""'");
28905 }
28906 arg1 = static_cast< long >(val1);
28907 {
28908 PyThreadState* __tstate = wxPyBeginAllowThreads();
28909 result = wxTimeSpan::Days(arg1);
28910 wxPyEndAllowThreads(__tstate);
28911 if (PyErr_Occurred()) SWIG_fail;
28912 }
28913 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28914 return resultobj;
28915 fail:
28916 return NULL;
28917 }
28918
28919
28920 SWIGINTERN PyObject *_wrap_TimeSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28921 PyObject *resultobj = 0;
28922 wxTimeSpan result;
28923
28924 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Day",0,0,0)) SWIG_fail;
28925 {
28926 PyThreadState* __tstate = wxPyBeginAllowThreads();
28927 result = wxTimeSpan::Day();
28928 wxPyEndAllowThreads(__tstate);
28929 if (PyErr_Occurred()) SWIG_fail;
28930 }
28931 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28932 return resultobj;
28933 fail:
28934 return NULL;
28935 }
28936
28937
28938 SWIGINTERN PyObject *_wrap_TimeSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28939 PyObject *resultobj = 0;
28940 long arg1 ;
28941 wxTimeSpan result;
28942 long val1 ;
28943 int ecode1 = 0 ;
28944 PyObject * obj0 = 0 ;
28945 char * kwnames[] = {
28946 (char *) "days", NULL
28947 };
28948
28949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) SWIG_fail;
28950 ecode1 = SWIG_AsVal_long(obj0, &val1);
28951 if (!SWIG_IsOK(ecode1)) {
28952 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Weeks" "', expected argument " "1"" of type '" "long""'");
28953 }
28954 arg1 = static_cast< long >(val1);
28955 {
28956 PyThreadState* __tstate = wxPyBeginAllowThreads();
28957 result = wxTimeSpan::Weeks(arg1);
28958 wxPyEndAllowThreads(__tstate);
28959 if (PyErr_Occurred()) SWIG_fail;
28960 }
28961 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28962 return resultobj;
28963 fail:
28964 return NULL;
28965 }
28966
28967
28968 SWIGINTERN PyObject *_wrap_TimeSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28969 PyObject *resultobj = 0;
28970 wxTimeSpan result;
28971
28972 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Week",0,0,0)) SWIG_fail;
28973 {
28974 PyThreadState* __tstate = wxPyBeginAllowThreads();
28975 result = wxTimeSpan::Week();
28976 wxPyEndAllowThreads(__tstate);
28977 if (PyErr_Occurred()) SWIG_fail;
28978 }
28979 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28980 return resultobj;
28981 fail:
28982 return NULL;
28983 }
28984
28985
28986 SWIGINTERN PyObject *_wrap_new_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28987 PyObject *resultobj = 0;
28988 long arg1 = (long) 0 ;
28989 long arg2 = (long) 0 ;
28990 long arg3 = (long) 0 ;
28991 long arg4 = (long) 0 ;
28992 wxTimeSpan *result = 0 ;
28993 long val1 ;
28994 int ecode1 = 0 ;
28995 long val2 ;
28996 int ecode2 = 0 ;
28997 long val3 ;
28998 int ecode3 = 0 ;
28999 long val4 ;
29000 int ecode4 = 0 ;
29001 PyObject * obj0 = 0 ;
29002 PyObject * obj1 = 0 ;
29003 PyObject * obj2 = 0 ;
29004 PyObject * obj3 = 0 ;
29005 char * kwnames[] = {
29006 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
29007 };
29008
29009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29010 if (obj0) {
29011 ecode1 = SWIG_AsVal_long(obj0, &val1);
29012 if (!SWIG_IsOK(ecode1)) {
29013 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimeSpan" "', expected argument " "1"" of type '" "long""'");
29014 }
29015 arg1 = static_cast< long >(val1);
29016 }
29017 if (obj1) {
29018 ecode2 = SWIG_AsVal_long(obj1, &val2);
29019 if (!SWIG_IsOK(ecode2)) {
29020 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimeSpan" "', expected argument " "2"" of type '" "long""'");
29021 }
29022 arg2 = static_cast< long >(val2);
29023 }
29024 if (obj2) {
29025 ecode3 = SWIG_AsVal_long(obj2, &val3);
29026 if (!SWIG_IsOK(ecode3)) {
29027 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimeSpan" "', expected argument " "3"" of type '" "long""'");
29028 }
29029 arg3 = static_cast< long >(val3);
29030 }
29031 if (obj3) {
29032 ecode4 = SWIG_AsVal_long(obj3, &val4);
29033 if (!SWIG_IsOK(ecode4)) {
29034 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TimeSpan" "', expected argument " "4"" of type '" "long""'");
29035 }
29036 arg4 = static_cast< long >(val4);
29037 }
29038 {
29039 PyThreadState* __tstate = wxPyBeginAllowThreads();
29040 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
29041 wxPyEndAllowThreads(__tstate);
29042 if (PyErr_Occurred()) SWIG_fail;
29043 }
29044 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_NEW | 0 );
29045 return resultobj;
29046 fail:
29047 return NULL;
29048 }
29049
29050
29051 SWIGINTERN PyObject *_wrap_delete_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29052 PyObject *resultobj = 0;
29053 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29054 void *argp1 = 0 ;
29055 int res1 = 0 ;
29056 PyObject *swig_obj[1] ;
29057
29058 if (!args) SWIG_fail;
29059 swig_obj[0] = args;
29060 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29061 if (!SWIG_IsOK(res1)) {
29062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimeSpan" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29063 }
29064 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29065 {
29066 PyThreadState* __tstate = wxPyBeginAllowThreads();
29067 delete arg1;
29068
29069 wxPyEndAllowThreads(__tstate);
29070 if (PyErr_Occurred()) SWIG_fail;
29071 }
29072 resultobj = SWIG_Py_Void();
29073 return resultobj;
29074 fail:
29075 return NULL;
29076 }
29077
29078
29079 SWIGINTERN PyObject *_wrap_TimeSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29080 PyObject *resultobj = 0;
29081 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29082 wxTimeSpan *arg2 = 0 ;
29083 wxTimeSpan *result = 0 ;
29084 void *argp1 = 0 ;
29085 int res1 = 0 ;
29086 void *argp2 = 0 ;
29087 int res2 = 0 ;
29088 PyObject * obj0 = 0 ;
29089 PyObject * obj1 = 0 ;
29090 char * kwnames[] = {
29091 (char *) "self",(char *) "diff", NULL
29092 };
29093
29094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
29095 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29096 if (!SWIG_IsOK(res1)) {
29097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Add" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29098 }
29099 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29100 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29101 if (!SWIG_IsOK(res2)) {
29102 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29103 }
29104 if (!argp2) {
29105 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29106 }
29107 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29108 {
29109 PyThreadState* __tstate = wxPyBeginAllowThreads();
29110 {
29111 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
29112 result = (wxTimeSpan *) &_result_ref;
29113 }
29114 wxPyEndAllowThreads(__tstate);
29115 if (PyErr_Occurred()) SWIG_fail;
29116 }
29117 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29118 return resultobj;
29119 fail:
29120 return NULL;
29121 }
29122
29123
29124 SWIGINTERN PyObject *_wrap_TimeSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29125 PyObject *resultobj = 0;
29126 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29127 wxTimeSpan *arg2 = 0 ;
29128 wxTimeSpan *result = 0 ;
29129 void *argp1 = 0 ;
29130 int res1 = 0 ;
29131 void *argp2 = 0 ;
29132 int res2 = 0 ;
29133 PyObject * obj0 = 0 ;
29134 PyObject * obj1 = 0 ;
29135 char * kwnames[] = {
29136 (char *) "self",(char *) "diff", NULL
29137 };
29138
29139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
29140 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29141 if (!SWIG_IsOK(res1)) {
29142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Subtract" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29143 }
29144 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29145 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29146 if (!SWIG_IsOK(res2)) {
29147 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29148 }
29149 if (!argp2) {
29150 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29151 }
29152 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29153 {
29154 PyThreadState* __tstate = wxPyBeginAllowThreads();
29155 {
29156 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
29157 result = (wxTimeSpan *) &_result_ref;
29158 }
29159 wxPyEndAllowThreads(__tstate);
29160 if (PyErr_Occurred()) SWIG_fail;
29161 }
29162 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29163 return resultobj;
29164 fail:
29165 return NULL;
29166 }
29167
29168
29169 SWIGINTERN PyObject *_wrap_TimeSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29170 PyObject *resultobj = 0;
29171 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29172 int arg2 ;
29173 wxTimeSpan *result = 0 ;
29174 void *argp1 = 0 ;
29175 int res1 = 0 ;
29176 int val2 ;
29177 int ecode2 = 0 ;
29178 PyObject * obj0 = 0 ;
29179 PyObject * obj1 = 0 ;
29180 char * kwnames[] = {
29181 (char *) "self",(char *) "n", NULL
29182 };
29183
29184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
29185 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29186 if (!SWIG_IsOK(res1)) {
29187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Multiply" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29188 }
29189 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29190 ecode2 = SWIG_AsVal_int(obj1, &val2);
29191 if (!SWIG_IsOK(ecode2)) {
29192 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
29193 }
29194 arg2 = static_cast< int >(val2);
29195 {
29196 PyThreadState* __tstate = wxPyBeginAllowThreads();
29197 {
29198 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
29199 result = (wxTimeSpan *) &_result_ref;
29200 }
29201 wxPyEndAllowThreads(__tstate);
29202 if (PyErr_Occurred()) SWIG_fail;
29203 }
29204 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29205 return resultobj;
29206 fail:
29207 return NULL;
29208 }
29209
29210
29211 SWIGINTERN PyObject *_wrap_TimeSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29212 PyObject *resultobj = 0;
29213 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29214 wxTimeSpan *result = 0 ;
29215 void *argp1 = 0 ;
29216 int res1 = 0 ;
29217 PyObject *swig_obj[1] ;
29218
29219 if (!args) SWIG_fail;
29220 swig_obj[0] = args;
29221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29222 if (!SWIG_IsOK(res1)) {
29223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Neg" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29224 }
29225 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29226 {
29227 PyThreadState* __tstate = wxPyBeginAllowThreads();
29228 {
29229 wxTimeSpan &_result_ref = (arg1)->Neg();
29230 result = (wxTimeSpan *) &_result_ref;
29231 }
29232 wxPyEndAllowThreads(__tstate);
29233 if (PyErr_Occurred()) SWIG_fail;
29234 }
29235 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29236 return resultobj;
29237 fail:
29238 return NULL;
29239 }
29240
29241
29242 SWIGINTERN PyObject *_wrap_TimeSpan_Abs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29243 PyObject *resultobj = 0;
29244 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29245 wxTimeSpan result;
29246 void *argp1 = 0 ;
29247 int res1 = 0 ;
29248 PyObject *swig_obj[1] ;
29249
29250 if (!args) SWIG_fail;
29251 swig_obj[0] = args;
29252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29253 if (!SWIG_IsOK(res1)) {
29254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Abs" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29255 }
29256 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29257 {
29258 PyThreadState* __tstate = wxPyBeginAllowThreads();
29259 result = ((wxTimeSpan const *)arg1)->Abs();
29260 wxPyEndAllowThreads(__tstate);
29261 if (PyErr_Occurred()) SWIG_fail;
29262 }
29263 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29264 return resultobj;
29265 fail:
29266 return NULL;
29267 }
29268
29269
29270 SWIGINTERN PyObject *_wrap_TimeSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29271 PyObject *resultobj = 0;
29272 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29273 wxTimeSpan *arg2 = 0 ;
29274 wxTimeSpan *result = 0 ;
29275 void *argp1 = 0 ;
29276 int res1 = 0 ;
29277 void *argp2 = 0 ;
29278 int res2 = 0 ;
29279 PyObject * obj0 = 0 ;
29280 PyObject * obj1 = 0 ;
29281 char * kwnames[] = {
29282 (char *) "self",(char *) "diff", NULL
29283 };
29284
29285 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
29286 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29287 if (!SWIG_IsOK(res1)) {
29288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___iadd__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29289 }
29290 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29291 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29292 if (!SWIG_IsOK(res2)) {
29293 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29294 }
29295 if (!argp2) {
29296 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29297 }
29298 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29299 {
29300 PyThreadState* __tstate = wxPyBeginAllowThreads();
29301 {
29302 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
29303 result = (wxTimeSpan *) &_result_ref;
29304 }
29305 wxPyEndAllowThreads(__tstate);
29306 if (PyErr_Occurred()) SWIG_fail;
29307 }
29308 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29309 return resultobj;
29310 fail:
29311 return NULL;
29312 }
29313
29314
29315 SWIGINTERN PyObject *_wrap_TimeSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29316 PyObject *resultobj = 0;
29317 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29318 wxTimeSpan *arg2 = 0 ;
29319 wxTimeSpan *result = 0 ;
29320 void *argp1 = 0 ;
29321 int res1 = 0 ;
29322 void *argp2 = 0 ;
29323 int res2 = 0 ;
29324 PyObject * obj0 = 0 ;
29325 PyObject * obj1 = 0 ;
29326 char * kwnames[] = {
29327 (char *) "self",(char *) "diff", NULL
29328 };
29329
29330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
29331 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29332 if (!SWIG_IsOK(res1)) {
29333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___isub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29334 }
29335 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29336 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29337 if (!SWIG_IsOK(res2)) {
29338 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29339 }
29340 if (!argp2) {
29341 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29342 }
29343 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29344 {
29345 PyThreadState* __tstate = wxPyBeginAllowThreads();
29346 {
29347 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
29348 result = (wxTimeSpan *) &_result_ref;
29349 }
29350 wxPyEndAllowThreads(__tstate);
29351 if (PyErr_Occurred()) SWIG_fail;
29352 }
29353 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29354 return resultobj;
29355 fail:
29356 return NULL;
29357 }
29358
29359
29360 SWIGINTERN PyObject *_wrap_TimeSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29361 PyObject *resultobj = 0;
29362 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29363 int arg2 ;
29364 wxTimeSpan *result = 0 ;
29365 void *argp1 = 0 ;
29366 int res1 = 0 ;
29367 int val2 ;
29368 int ecode2 = 0 ;
29369 PyObject * obj0 = 0 ;
29370 PyObject * obj1 = 0 ;
29371 char * kwnames[] = {
29372 (char *) "self",(char *) "n", NULL
29373 };
29374
29375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
29376 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29377 if (!SWIG_IsOK(res1)) {
29378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___imul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29379 }
29380 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29381 ecode2 = SWIG_AsVal_int(obj1, &val2);
29382 if (!SWIG_IsOK(ecode2)) {
29383 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___imul__" "', expected argument " "2"" of type '" "int""'");
29384 }
29385 arg2 = static_cast< int >(val2);
29386 {
29387 PyThreadState* __tstate = wxPyBeginAllowThreads();
29388 {
29389 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
29390 result = (wxTimeSpan *) &_result_ref;
29391 }
29392 wxPyEndAllowThreads(__tstate);
29393 if (PyErr_Occurred()) SWIG_fail;
29394 }
29395 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29396 return resultobj;
29397 fail:
29398 return NULL;
29399 }
29400
29401
29402 SWIGINTERN PyObject *_wrap_TimeSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29403 PyObject *resultobj = 0;
29404 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29405 wxTimeSpan *result = 0 ;
29406 void *argp1 = 0 ;
29407 int res1 = 0 ;
29408 PyObject *swig_obj[1] ;
29409
29410 if (!args) SWIG_fail;
29411 swig_obj[0] = args;
29412 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29413 if (!SWIG_IsOK(res1)) {
29414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___neg__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29415 }
29416 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29417 {
29418 PyThreadState* __tstate = wxPyBeginAllowThreads();
29419 {
29420 wxTimeSpan &_result_ref = (arg1)->operator -();
29421 result = (wxTimeSpan *) &_result_ref;
29422 }
29423 wxPyEndAllowThreads(__tstate);
29424 if (PyErr_Occurred()) SWIG_fail;
29425 }
29426 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29427 return resultobj;
29428 fail:
29429 return NULL;
29430 }
29431
29432
29433 SWIGINTERN PyObject *_wrap_TimeSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29434 PyObject *resultobj = 0;
29435 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29436 wxTimeSpan *arg2 = 0 ;
29437 wxTimeSpan result;
29438 void *argp1 = 0 ;
29439 int res1 = 0 ;
29440 void *argp2 = 0 ;
29441 int res2 = 0 ;
29442 PyObject * obj0 = 0 ;
29443 PyObject * obj1 = 0 ;
29444 char * kwnames[] = {
29445 (char *) "self",(char *) "other", NULL
29446 };
29447
29448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
29449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29450 if (!SWIG_IsOK(res1)) {
29451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___add__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29452 }
29453 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29454 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29455 if (!SWIG_IsOK(res2)) {
29456 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29457 }
29458 if (!argp2) {
29459 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29460 }
29461 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29462 {
29463 PyThreadState* __tstate = wxPyBeginAllowThreads();
29464 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
29465 wxPyEndAllowThreads(__tstate);
29466 if (PyErr_Occurred()) SWIG_fail;
29467 }
29468 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29469 return resultobj;
29470 fail:
29471 return NULL;
29472 }
29473
29474
29475 SWIGINTERN PyObject *_wrap_TimeSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29476 PyObject *resultobj = 0;
29477 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29478 wxTimeSpan *arg2 = 0 ;
29479 wxTimeSpan result;
29480 void *argp1 = 0 ;
29481 int res1 = 0 ;
29482 void *argp2 = 0 ;
29483 int res2 = 0 ;
29484 PyObject * obj0 = 0 ;
29485 PyObject * obj1 = 0 ;
29486 char * kwnames[] = {
29487 (char *) "self",(char *) "other", NULL
29488 };
29489
29490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
29491 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29492 if (!SWIG_IsOK(res1)) {
29493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___sub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29494 }
29495 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29496 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29497 if (!SWIG_IsOK(res2)) {
29498 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29499 }
29500 if (!argp2) {
29501 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29502 }
29503 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29504 {
29505 PyThreadState* __tstate = wxPyBeginAllowThreads();
29506 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
29507 wxPyEndAllowThreads(__tstate);
29508 if (PyErr_Occurred()) SWIG_fail;
29509 }
29510 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29511 return resultobj;
29512 fail:
29513 return NULL;
29514 }
29515
29516
29517 SWIGINTERN PyObject *_wrap_TimeSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29518 PyObject *resultobj = 0;
29519 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29520 int arg2 ;
29521 wxTimeSpan result;
29522 void *argp1 = 0 ;
29523 int res1 = 0 ;
29524 int val2 ;
29525 int ecode2 = 0 ;
29526 PyObject * obj0 = 0 ;
29527 PyObject * obj1 = 0 ;
29528 char * kwnames[] = {
29529 (char *) "self",(char *) "n", NULL
29530 };
29531
29532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
29533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29534 if (!SWIG_IsOK(res1)) {
29535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___mul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29536 }
29537 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29538 ecode2 = SWIG_AsVal_int(obj1, &val2);
29539 if (!SWIG_IsOK(ecode2)) {
29540 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___mul__" "', expected argument " "2"" of type '" "int""'");
29541 }
29542 arg2 = static_cast< int >(val2);
29543 {
29544 PyThreadState* __tstate = wxPyBeginAllowThreads();
29545 result = wxTimeSpan___mul__(arg1,arg2);
29546 wxPyEndAllowThreads(__tstate);
29547 if (PyErr_Occurred()) SWIG_fail;
29548 }
29549 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29550 return resultobj;
29551 fail:
29552 return NULL;
29553 }
29554
29555
29556 SWIGINTERN PyObject *_wrap_TimeSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29557 PyObject *resultobj = 0;
29558 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29559 int arg2 ;
29560 wxTimeSpan result;
29561 void *argp1 = 0 ;
29562 int res1 = 0 ;
29563 int val2 ;
29564 int ecode2 = 0 ;
29565 PyObject * obj0 = 0 ;
29566 PyObject * obj1 = 0 ;
29567 char * kwnames[] = {
29568 (char *) "self",(char *) "n", NULL
29569 };
29570
29571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
29572 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29573 if (!SWIG_IsOK(res1)) {
29574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___rmul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29575 }
29576 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29577 ecode2 = SWIG_AsVal_int(obj1, &val2);
29578 if (!SWIG_IsOK(ecode2)) {
29579 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
29580 }
29581 arg2 = static_cast< int >(val2);
29582 {
29583 PyThreadState* __tstate = wxPyBeginAllowThreads();
29584 result = wxTimeSpan___rmul__(arg1,arg2);
29585 wxPyEndAllowThreads(__tstate);
29586 if (PyErr_Occurred()) SWIG_fail;
29587 }
29588 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29589 return resultobj;
29590 fail:
29591 return NULL;
29592 }
29593
29594
29595 SWIGINTERN PyObject *_wrap_TimeSpan___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29596 PyObject *resultobj = 0;
29597 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29598 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29599 bool result;
29600 void *argp1 = 0 ;
29601 int res1 = 0 ;
29602 void *argp2 = 0 ;
29603 int res2 = 0 ;
29604 PyObject * obj0 = 0 ;
29605 PyObject * obj1 = 0 ;
29606 char * kwnames[] = {
29607 (char *) "self",(char *) "other", NULL
29608 };
29609
29610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
29611 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29612 if (!SWIG_IsOK(res1)) {
29613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___lt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29614 }
29615 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29616 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29617 if (!SWIG_IsOK(res2)) {
29618 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___lt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29619 }
29620 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29621 {
29622 PyThreadState* __tstate = wxPyBeginAllowThreads();
29623 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
29624 wxPyEndAllowThreads(__tstate);
29625 if (PyErr_Occurred()) SWIG_fail;
29626 }
29627 {
29628 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29629 }
29630 return resultobj;
29631 fail:
29632 return NULL;
29633 }
29634
29635
29636 SWIGINTERN PyObject *_wrap_TimeSpan___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29637 PyObject *resultobj = 0;
29638 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29639 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29640 bool result;
29641 void *argp1 = 0 ;
29642 int res1 = 0 ;
29643 void *argp2 = 0 ;
29644 int res2 = 0 ;
29645 PyObject * obj0 = 0 ;
29646 PyObject * obj1 = 0 ;
29647 char * kwnames[] = {
29648 (char *) "self",(char *) "other", NULL
29649 };
29650
29651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) SWIG_fail;
29652 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29653 if (!SWIG_IsOK(res1)) {
29654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___le__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29655 }
29656 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29657 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29658 if (!SWIG_IsOK(res2)) {
29659 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___le__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29660 }
29661 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29662 {
29663 PyThreadState* __tstate = wxPyBeginAllowThreads();
29664 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
29665 wxPyEndAllowThreads(__tstate);
29666 if (PyErr_Occurred()) SWIG_fail;
29667 }
29668 {
29669 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29670 }
29671 return resultobj;
29672 fail:
29673 return NULL;
29674 }
29675
29676
29677 SWIGINTERN PyObject *_wrap_TimeSpan___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29678 PyObject *resultobj = 0;
29679 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29680 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29681 bool result;
29682 void *argp1 = 0 ;
29683 int res1 = 0 ;
29684 void *argp2 = 0 ;
29685 int res2 = 0 ;
29686 PyObject * obj0 = 0 ;
29687 PyObject * obj1 = 0 ;
29688 char * kwnames[] = {
29689 (char *) "self",(char *) "other", NULL
29690 };
29691
29692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
29693 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29694 if (!SWIG_IsOK(res1)) {
29695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___gt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29696 }
29697 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29698 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29699 if (!SWIG_IsOK(res2)) {
29700 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___gt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29701 }
29702 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29703 {
29704 PyThreadState* __tstate = wxPyBeginAllowThreads();
29705 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
29706 wxPyEndAllowThreads(__tstate);
29707 if (PyErr_Occurred()) SWIG_fail;
29708 }
29709 {
29710 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29711 }
29712 return resultobj;
29713 fail:
29714 return NULL;
29715 }
29716
29717
29718 SWIGINTERN PyObject *_wrap_TimeSpan___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29719 PyObject *resultobj = 0;
29720 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29721 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29722 bool result;
29723 void *argp1 = 0 ;
29724 int res1 = 0 ;
29725 void *argp2 = 0 ;
29726 int res2 = 0 ;
29727 PyObject * obj0 = 0 ;
29728 PyObject * obj1 = 0 ;
29729 char * kwnames[] = {
29730 (char *) "self",(char *) "other", NULL
29731 };
29732
29733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
29734 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29735 if (!SWIG_IsOK(res1)) {
29736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ge__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29737 }
29738 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29739 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29740 if (!SWIG_IsOK(res2)) {
29741 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ge__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29742 }
29743 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29744 {
29745 PyThreadState* __tstate = wxPyBeginAllowThreads();
29746 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
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___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29760 PyObject *resultobj = 0;
29761 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29762 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29763 bool result;
29764 void *argp1 = 0 ;
29765 int res1 = 0 ;
29766 void *argp2 = 0 ;
29767 int res2 = 0 ;
29768 PyObject * obj0 = 0 ;
29769 PyObject * obj1 = 0 ;
29770 char * kwnames[] = {
29771 (char *) "self",(char *) "other", NULL
29772 };
29773
29774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
29775 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29776 if (!SWIG_IsOK(res1)) {
29777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___eq__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29778 }
29779 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29780 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29781 if (!SWIG_IsOK(res2)) {
29782 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___eq__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29783 }
29784 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29785 {
29786 PyThreadState* __tstate = wxPyBeginAllowThreads();
29787 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
29788 wxPyEndAllowThreads(__tstate);
29789 if (PyErr_Occurred()) SWIG_fail;
29790 }
29791 {
29792 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29793 }
29794 return resultobj;
29795 fail:
29796 return NULL;
29797 }
29798
29799
29800 SWIGINTERN PyObject *_wrap_TimeSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29801 PyObject *resultobj = 0;
29802 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29803 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29804 bool result;
29805 void *argp1 = 0 ;
29806 int res1 = 0 ;
29807 void *argp2 = 0 ;
29808 int res2 = 0 ;
29809 PyObject * obj0 = 0 ;
29810 PyObject * obj1 = 0 ;
29811 char * kwnames[] = {
29812 (char *) "self",(char *) "other", NULL
29813 };
29814
29815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
29816 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29817 if (!SWIG_IsOK(res1)) {
29818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ne__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29819 }
29820 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29821 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29822 if (!SWIG_IsOK(res2)) {
29823 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ne__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29824 }
29825 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29826 {
29827 PyThreadState* __tstate = wxPyBeginAllowThreads();
29828 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
29829 wxPyEndAllowThreads(__tstate);
29830 if (PyErr_Occurred()) SWIG_fail;
29831 }
29832 {
29833 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29834 }
29835 return resultobj;
29836 fail:
29837 return NULL;
29838 }
29839
29840
29841 SWIGINTERN PyObject *_wrap_TimeSpan_IsNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29842 PyObject *resultobj = 0;
29843 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29844 bool result;
29845 void *argp1 = 0 ;
29846 int res1 = 0 ;
29847 PyObject *swig_obj[1] ;
29848
29849 if (!args) SWIG_fail;
29850 swig_obj[0] = args;
29851 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29852 if (!SWIG_IsOK(res1)) {
29853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNull" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29854 }
29855 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29856 {
29857 PyThreadState* __tstate = wxPyBeginAllowThreads();
29858 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
29859 wxPyEndAllowThreads(__tstate);
29860 if (PyErr_Occurred()) SWIG_fail;
29861 }
29862 {
29863 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29864 }
29865 return resultobj;
29866 fail:
29867 return NULL;
29868 }
29869
29870
29871 SWIGINTERN PyObject *_wrap_TimeSpan_IsPositive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29872 PyObject *resultobj = 0;
29873 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29874 bool result;
29875 void *argp1 = 0 ;
29876 int res1 = 0 ;
29877 PyObject *swig_obj[1] ;
29878
29879 if (!args) SWIG_fail;
29880 swig_obj[0] = args;
29881 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29882 if (!SWIG_IsOK(res1)) {
29883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsPositive" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29884 }
29885 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29886 {
29887 PyThreadState* __tstate = wxPyBeginAllowThreads();
29888 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
29889 wxPyEndAllowThreads(__tstate);
29890 if (PyErr_Occurred()) SWIG_fail;
29891 }
29892 {
29893 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29894 }
29895 return resultobj;
29896 fail:
29897 return NULL;
29898 }
29899
29900
29901 SWIGINTERN PyObject *_wrap_TimeSpan_IsNegative(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29902 PyObject *resultobj = 0;
29903 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29904 bool result;
29905 void *argp1 = 0 ;
29906 int res1 = 0 ;
29907 PyObject *swig_obj[1] ;
29908
29909 if (!args) SWIG_fail;
29910 swig_obj[0] = args;
29911 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29912 if (!SWIG_IsOK(res1)) {
29913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNegative" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29914 }
29915 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29916 {
29917 PyThreadState* __tstate = wxPyBeginAllowThreads();
29918 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
29919 wxPyEndAllowThreads(__tstate);
29920 if (PyErr_Occurred()) SWIG_fail;
29921 }
29922 {
29923 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29924 }
29925 return resultobj;
29926 fail:
29927 return NULL;
29928 }
29929
29930
29931 SWIGINTERN PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29932 PyObject *resultobj = 0;
29933 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29934 wxTimeSpan *arg2 = 0 ;
29935 bool result;
29936 void *argp1 = 0 ;
29937 int res1 = 0 ;
29938 void *argp2 = 0 ;
29939 int res2 = 0 ;
29940 PyObject * obj0 = 0 ;
29941 PyObject * obj1 = 0 ;
29942 char * kwnames[] = {
29943 (char *) "self",(char *) "ts", NULL
29944 };
29945
29946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
29947 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29948 if (!SWIG_IsOK(res1)) {
29949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29950 }
29951 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29952 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29953 if (!SWIG_IsOK(res2)) {
29954 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29955 }
29956 if (!argp2) {
29957 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29958 }
29959 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29960 {
29961 PyThreadState* __tstate = wxPyBeginAllowThreads();
29962 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
29963 wxPyEndAllowThreads(__tstate);
29964 if (PyErr_Occurred()) SWIG_fail;
29965 }
29966 {
29967 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29968 }
29969 return resultobj;
29970 fail:
29971 return NULL;
29972 }
29973
29974
29975 SWIGINTERN PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29976 PyObject *resultobj = 0;
29977 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29978 wxTimeSpan *arg2 = 0 ;
29979 bool result;
29980 void *argp1 = 0 ;
29981 int res1 = 0 ;
29982 void *argp2 = 0 ;
29983 int res2 = 0 ;
29984 PyObject * obj0 = 0 ;
29985 PyObject * obj1 = 0 ;
29986 char * kwnames[] = {
29987 (char *) "self",(char *) "ts", NULL
29988 };
29989
29990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) SWIG_fail;
29991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29992 if (!SWIG_IsOK(res1)) {
29993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29994 }
29995 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29996 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29997 if (!SWIG_IsOK(res2)) {
29998 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29999 }
30000 if (!argp2) {
30001 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
30002 }
30003 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
30004 {
30005 PyThreadState* __tstate = wxPyBeginAllowThreads();
30006 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
30007 wxPyEndAllowThreads(__tstate);
30008 if (PyErr_Occurred()) SWIG_fail;
30009 }
30010 {
30011 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30012 }
30013 return resultobj;
30014 fail:
30015 return NULL;
30016 }
30017
30018
30019 SWIGINTERN PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30020 PyObject *resultobj = 0;
30021 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30022 wxTimeSpan *arg2 = 0 ;
30023 bool result;
30024 void *argp1 = 0 ;
30025 int res1 = 0 ;
30026 void *argp2 = 0 ;
30027 int res2 = 0 ;
30028 PyObject * obj0 = 0 ;
30029 PyObject * obj1 = 0 ;
30030 char * kwnames[] = {
30031 (char *) "self",(char *) "t", NULL
30032 };
30033
30034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) SWIG_fail;
30035 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30036 if (!SWIG_IsOK(res1)) {
30037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30038 }
30039 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30040 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
30041 if (!SWIG_IsOK(res2)) {
30042 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
30043 }
30044 if (!argp2) {
30045 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
30046 }
30047 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
30048 {
30049 PyThreadState* __tstate = wxPyBeginAllowThreads();
30050 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
30051 wxPyEndAllowThreads(__tstate);
30052 if (PyErr_Occurred()) SWIG_fail;
30053 }
30054 {
30055 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30056 }
30057 return resultobj;
30058 fail:
30059 return NULL;
30060 }
30061
30062
30063 SWIGINTERN PyObject *_wrap_TimeSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30064 PyObject *resultobj = 0;
30065 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30066 int 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_GetWeeks" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30076 }
30077 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30078 {
30079 PyThreadState* __tstate = wxPyBeginAllowThreads();
30080 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
30081 wxPyEndAllowThreads(__tstate);
30082 if (PyErr_Occurred()) SWIG_fail;
30083 }
30084 resultobj = SWIG_From_int(static_cast< int >(result));
30085 return resultobj;
30086 fail:
30087 return NULL;
30088 }
30089
30090
30091 SWIGINTERN PyObject *_wrap_TimeSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30092 PyObject *resultobj = 0;
30093 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30094 int result;
30095 void *argp1 = 0 ;
30096 int res1 = 0 ;
30097 PyObject *swig_obj[1] ;
30098
30099 if (!args) SWIG_fail;
30100 swig_obj[0] = args;
30101 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30102 if (!SWIG_IsOK(res1)) {
30103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetDays" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30104 }
30105 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30106 {
30107 PyThreadState* __tstate = wxPyBeginAllowThreads();
30108 result = (int)((wxTimeSpan const *)arg1)->GetDays();
30109 wxPyEndAllowThreads(__tstate);
30110 if (PyErr_Occurred()) SWIG_fail;
30111 }
30112 resultobj = SWIG_From_int(static_cast< int >(result));
30113 return resultobj;
30114 fail:
30115 return NULL;
30116 }
30117
30118
30119 SWIGINTERN PyObject *_wrap_TimeSpan_GetHours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30120 PyObject *resultobj = 0;
30121 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30122 int result;
30123 void *argp1 = 0 ;
30124 int res1 = 0 ;
30125 PyObject *swig_obj[1] ;
30126
30127 if (!args) SWIG_fail;
30128 swig_obj[0] = args;
30129 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30130 if (!SWIG_IsOK(res1)) {
30131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetHours" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30132 }
30133 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30134 {
30135 PyThreadState* __tstate = wxPyBeginAllowThreads();
30136 result = (int)((wxTimeSpan const *)arg1)->GetHours();
30137 wxPyEndAllowThreads(__tstate);
30138 if (PyErr_Occurred()) SWIG_fail;
30139 }
30140 resultobj = SWIG_From_int(static_cast< int >(result));
30141 return resultobj;
30142 fail:
30143 return NULL;
30144 }
30145
30146
30147 SWIGINTERN PyObject *_wrap_TimeSpan_GetMinutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30148 PyObject *resultobj = 0;
30149 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30150 int result;
30151 void *argp1 = 0 ;
30152 int res1 = 0 ;
30153 PyObject *swig_obj[1] ;
30154
30155 if (!args) SWIG_fail;
30156 swig_obj[0] = args;
30157 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30158 if (!SWIG_IsOK(res1)) {
30159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMinutes" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30160 }
30161 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30162 {
30163 PyThreadState* __tstate = wxPyBeginAllowThreads();
30164 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
30165 wxPyEndAllowThreads(__tstate);
30166 if (PyErr_Occurred()) SWIG_fail;
30167 }
30168 resultobj = SWIG_From_int(static_cast< int >(result));
30169 return resultobj;
30170 fail:
30171 return NULL;
30172 }
30173
30174
30175 SWIGINTERN PyObject *_wrap_TimeSpan_GetSeconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30176 PyObject *resultobj = 0;
30177 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30178 wxLongLong result;
30179 void *argp1 = 0 ;
30180 int res1 = 0 ;
30181 PyObject *swig_obj[1] ;
30182
30183 if (!args) SWIG_fail;
30184 swig_obj[0] = args;
30185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30186 if (!SWIG_IsOK(res1)) {
30187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetSeconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30188 }
30189 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30190 {
30191 PyThreadState* __tstate = wxPyBeginAllowThreads();
30192 result = ((wxTimeSpan const *)arg1)->GetSeconds();
30193 wxPyEndAllowThreads(__tstate);
30194 if (PyErr_Occurred()) SWIG_fail;
30195 }
30196 {
30197 PyObject *hi, *lo, *shifter, *shifted;
30198 hi = PyLong_FromLong( (&result)->GetHi() );
30199 lo = PyLong_FromLong( (&result)->GetLo() );
30200 shifter = PyLong_FromLong(32);
30201 shifted = PyNumber_Lshift(hi, shifter);
30202 resultobj = PyNumber_Or(shifted, lo);
30203 Py_DECREF(hi);
30204 Py_DECREF(lo);
30205 Py_DECREF(shifter);
30206 Py_DECREF(shifted);
30207 }
30208 return resultobj;
30209 fail:
30210 return NULL;
30211 }
30212
30213
30214 SWIGINTERN PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30215 PyObject *resultobj = 0;
30216 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30217 wxLongLong result;
30218 void *argp1 = 0 ;
30219 int res1 = 0 ;
30220 PyObject *swig_obj[1] ;
30221
30222 if (!args) SWIG_fail;
30223 swig_obj[0] = args;
30224 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30225 if (!SWIG_IsOK(res1)) {
30226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMilliseconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30227 }
30228 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30229 {
30230 PyThreadState* __tstate = wxPyBeginAllowThreads();
30231 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
30232 wxPyEndAllowThreads(__tstate);
30233 if (PyErr_Occurred()) SWIG_fail;
30234 }
30235 {
30236 PyObject *hi, *lo, *shifter, *shifted;
30237 hi = PyLong_FromLong( (&result)->GetHi() );
30238 lo = PyLong_FromLong( (&result)->GetLo() );
30239 shifter = PyLong_FromLong(32);
30240 shifted = PyNumber_Lshift(hi, shifter);
30241 resultobj = PyNumber_Or(shifted, lo);
30242 Py_DECREF(hi);
30243 Py_DECREF(lo);
30244 Py_DECREF(shifter);
30245 Py_DECREF(shifted);
30246 }
30247 return resultobj;
30248 fail:
30249 return NULL;
30250 }
30251
30252
30253 SWIGINTERN PyObject *_wrap_TimeSpan_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30254 PyObject *resultobj = 0;
30255 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30256 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
30257 wxString *arg2 = (wxString *) &arg2_defvalue ;
30258 wxString result;
30259 void *argp1 = 0 ;
30260 int res1 = 0 ;
30261 bool temp2 = false ;
30262 PyObject * obj0 = 0 ;
30263 PyObject * obj1 = 0 ;
30264 char * kwnames[] = {
30265 (char *) "self",(char *) "format", NULL
30266 };
30267
30268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) SWIG_fail;
30269 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30270 if (!SWIG_IsOK(res1)) {
30271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Format" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30272 }
30273 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30274 if (obj1) {
30275 {
30276 arg2 = wxString_in_helper(obj1);
30277 if (arg2 == NULL) SWIG_fail;
30278 temp2 = true;
30279 }
30280 }
30281 {
30282 PyThreadState* __tstate = wxPyBeginAllowThreads();
30283 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
30284 wxPyEndAllowThreads(__tstate);
30285 if (PyErr_Occurred()) SWIG_fail;
30286 }
30287 {
30288 #if wxUSE_UNICODE
30289 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30290 #else
30291 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30292 #endif
30293 }
30294 {
30295 if (temp2)
30296 delete arg2;
30297 }
30298 return resultobj;
30299 fail:
30300 {
30301 if (temp2)
30302 delete arg2;
30303 }
30304 return NULL;
30305 }
30306
30307
30308 SWIGINTERN PyObject *TimeSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30309 PyObject *obj;
30310 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30311 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimeSpan, SWIG_NewClientData(obj));
30312 return SWIG_Py_Void();
30313 }
30314
30315 SWIGINTERN PyObject *TimeSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30316 return SWIG_Python_InitShadowInstance(args);
30317 }
30318
30319 SWIGINTERN PyObject *_wrap_new_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30320 PyObject *resultobj = 0;
30321 int arg1 = (int) 0 ;
30322 int arg2 = (int) 0 ;
30323 int arg3 = (int) 0 ;
30324 int arg4 = (int) 0 ;
30325 wxDateSpan *result = 0 ;
30326 int val1 ;
30327 int ecode1 = 0 ;
30328 int val2 ;
30329 int ecode2 = 0 ;
30330 int val3 ;
30331 int ecode3 = 0 ;
30332 int val4 ;
30333 int ecode4 = 0 ;
30334 PyObject * obj0 = 0 ;
30335 PyObject * obj1 = 0 ;
30336 PyObject * obj2 = 0 ;
30337 PyObject * obj3 = 0 ;
30338 char * kwnames[] = {
30339 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
30340 };
30341
30342 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30343 if (obj0) {
30344 ecode1 = SWIG_AsVal_int(obj0, &val1);
30345 if (!SWIG_IsOK(ecode1)) {
30346 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateSpan" "', expected argument " "1"" of type '" "int""'");
30347 }
30348 arg1 = static_cast< int >(val1);
30349 }
30350 if (obj1) {
30351 ecode2 = SWIG_AsVal_int(obj1, &val2);
30352 if (!SWIG_IsOK(ecode2)) {
30353 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateSpan" "', expected argument " "2"" of type '" "int""'");
30354 }
30355 arg2 = static_cast< int >(val2);
30356 }
30357 if (obj2) {
30358 ecode3 = SWIG_AsVal_int(obj2, &val3);
30359 if (!SWIG_IsOK(ecode3)) {
30360 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateSpan" "', expected argument " "3"" of type '" "int""'");
30361 }
30362 arg3 = static_cast< int >(val3);
30363 }
30364 if (obj3) {
30365 ecode4 = SWIG_AsVal_int(obj3, &val4);
30366 if (!SWIG_IsOK(ecode4)) {
30367 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateSpan" "', expected argument " "4"" of type '" "int""'");
30368 }
30369 arg4 = static_cast< int >(val4);
30370 }
30371 {
30372 PyThreadState* __tstate = wxPyBeginAllowThreads();
30373 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
30374 wxPyEndAllowThreads(__tstate);
30375 if (PyErr_Occurred()) SWIG_fail;
30376 }
30377 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_NEW | 0 );
30378 return resultobj;
30379 fail:
30380 return NULL;
30381 }
30382
30383
30384 SWIGINTERN PyObject *_wrap_delete_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30385 PyObject *resultobj = 0;
30386 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30387 void *argp1 = 0 ;
30388 int res1 = 0 ;
30389 PyObject *swig_obj[1] ;
30390
30391 if (!args) SWIG_fail;
30392 swig_obj[0] = args;
30393 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
30394 if (!SWIG_IsOK(res1)) {
30395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateSpan" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30396 }
30397 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30398 {
30399 PyThreadState* __tstate = wxPyBeginAllowThreads();
30400 delete arg1;
30401
30402 wxPyEndAllowThreads(__tstate);
30403 if (PyErr_Occurred()) SWIG_fail;
30404 }
30405 resultobj = SWIG_Py_Void();
30406 return resultobj;
30407 fail:
30408 return NULL;
30409 }
30410
30411
30412 SWIGINTERN PyObject *_wrap_DateSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30413 PyObject *resultobj = 0;
30414 int arg1 ;
30415 wxDateSpan result;
30416 int val1 ;
30417 int ecode1 = 0 ;
30418 PyObject * obj0 = 0 ;
30419 char * kwnames[] = {
30420 (char *) "days", NULL
30421 };
30422
30423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) SWIG_fail;
30424 ecode1 = SWIG_AsVal_int(obj0, &val1);
30425 if (!SWIG_IsOK(ecode1)) {
30426 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Days" "', expected argument " "1"" of type '" "int""'");
30427 }
30428 arg1 = static_cast< int >(val1);
30429 {
30430 PyThreadState* __tstate = wxPyBeginAllowThreads();
30431 result = wxDateSpan::Days(arg1);
30432 wxPyEndAllowThreads(__tstate);
30433 if (PyErr_Occurred()) SWIG_fail;
30434 }
30435 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30436 return resultobj;
30437 fail:
30438 return NULL;
30439 }
30440
30441
30442 SWIGINTERN PyObject *_wrap_DateSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30443 PyObject *resultobj = 0;
30444 wxDateSpan result;
30445
30446 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Day",0,0,0)) SWIG_fail;
30447 {
30448 PyThreadState* __tstate = wxPyBeginAllowThreads();
30449 result = wxDateSpan::Day();
30450 wxPyEndAllowThreads(__tstate);
30451 if (PyErr_Occurred()) SWIG_fail;
30452 }
30453 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30454 return resultobj;
30455 fail:
30456 return NULL;
30457 }
30458
30459
30460 SWIGINTERN PyObject *_wrap_DateSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30461 PyObject *resultobj = 0;
30462 int arg1 ;
30463 wxDateSpan result;
30464 int val1 ;
30465 int ecode1 = 0 ;
30466 PyObject * obj0 = 0 ;
30467 char * kwnames[] = {
30468 (char *) "weeks", NULL
30469 };
30470
30471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) SWIG_fail;
30472 ecode1 = SWIG_AsVal_int(obj0, &val1);
30473 if (!SWIG_IsOK(ecode1)) {
30474 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Weeks" "', expected argument " "1"" of type '" "int""'");
30475 }
30476 arg1 = static_cast< int >(val1);
30477 {
30478 PyThreadState* __tstate = wxPyBeginAllowThreads();
30479 result = wxDateSpan::Weeks(arg1);
30480 wxPyEndAllowThreads(__tstate);
30481 if (PyErr_Occurred()) SWIG_fail;
30482 }
30483 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30484 return resultobj;
30485 fail:
30486 return NULL;
30487 }
30488
30489
30490 SWIGINTERN PyObject *_wrap_DateSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30491 PyObject *resultobj = 0;
30492 wxDateSpan result;
30493
30494 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Week",0,0,0)) SWIG_fail;
30495 {
30496 PyThreadState* __tstate = wxPyBeginAllowThreads();
30497 result = wxDateSpan::Week();
30498 wxPyEndAllowThreads(__tstate);
30499 if (PyErr_Occurred()) SWIG_fail;
30500 }
30501 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30502 return resultobj;
30503 fail:
30504 return NULL;
30505 }
30506
30507
30508 SWIGINTERN PyObject *_wrap_DateSpan_Months(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30509 PyObject *resultobj = 0;
30510 int arg1 ;
30511 wxDateSpan result;
30512 int val1 ;
30513 int ecode1 = 0 ;
30514 PyObject * obj0 = 0 ;
30515 char * kwnames[] = {
30516 (char *) "mon", NULL
30517 };
30518
30519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) SWIG_fail;
30520 ecode1 = SWIG_AsVal_int(obj0, &val1);
30521 if (!SWIG_IsOK(ecode1)) {
30522 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Months" "', expected argument " "1"" of type '" "int""'");
30523 }
30524 arg1 = static_cast< int >(val1);
30525 {
30526 PyThreadState* __tstate = wxPyBeginAllowThreads();
30527 result = wxDateSpan::Months(arg1);
30528 wxPyEndAllowThreads(__tstate);
30529 if (PyErr_Occurred()) SWIG_fail;
30530 }
30531 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30532 return resultobj;
30533 fail:
30534 return NULL;
30535 }
30536
30537
30538 SWIGINTERN PyObject *_wrap_DateSpan_Month(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30539 PyObject *resultobj = 0;
30540 wxDateSpan result;
30541
30542 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Month",0,0,0)) SWIG_fail;
30543 {
30544 PyThreadState* __tstate = wxPyBeginAllowThreads();
30545 result = wxDateSpan::Month();
30546 wxPyEndAllowThreads(__tstate);
30547 if (PyErr_Occurred()) SWIG_fail;
30548 }
30549 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30550 return resultobj;
30551 fail:
30552 return NULL;
30553 }
30554
30555
30556 SWIGINTERN PyObject *_wrap_DateSpan_Years(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30557 PyObject *resultobj = 0;
30558 int arg1 ;
30559 wxDateSpan result;
30560 int val1 ;
30561 int ecode1 = 0 ;
30562 PyObject * obj0 = 0 ;
30563 char * kwnames[] = {
30564 (char *) "years", NULL
30565 };
30566
30567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) SWIG_fail;
30568 ecode1 = SWIG_AsVal_int(obj0, &val1);
30569 if (!SWIG_IsOK(ecode1)) {
30570 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Years" "', expected argument " "1"" of type '" "int""'");
30571 }
30572 arg1 = static_cast< int >(val1);
30573 {
30574 PyThreadState* __tstate = wxPyBeginAllowThreads();
30575 result = wxDateSpan::Years(arg1);
30576 wxPyEndAllowThreads(__tstate);
30577 if (PyErr_Occurred()) SWIG_fail;
30578 }
30579 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30580 return resultobj;
30581 fail:
30582 return NULL;
30583 }
30584
30585
30586 SWIGINTERN PyObject *_wrap_DateSpan_Year(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30587 PyObject *resultobj = 0;
30588 wxDateSpan result;
30589
30590 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Year",0,0,0)) SWIG_fail;
30591 {
30592 PyThreadState* __tstate = wxPyBeginAllowThreads();
30593 result = wxDateSpan::Year();
30594 wxPyEndAllowThreads(__tstate);
30595 if (PyErr_Occurred()) SWIG_fail;
30596 }
30597 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30598 return resultobj;
30599 fail:
30600 return NULL;
30601 }
30602
30603
30604 SWIGINTERN PyObject *_wrap_DateSpan_SetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30605 PyObject *resultobj = 0;
30606 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30607 int arg2 ;
30608 wxDateSpan *result = 0 ;
30609 void *argp1 = 0 ;
30610 int res1 = 0 ;
30611 int val2 ;
30612 int ecode2 = 0 ;
30613 PyObject * obj0 = 0 ;
30614 PyObject * obj1 = 0 ;
30615 char * kwnames[] = {
30616 (char *) "self",(char *) "n", NULL
30617 };
30618
30619 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) SWIG_fail;
30620 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30621 if (!SWIG_IsOK(res1)) {
30622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetYears" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30623 }
30624 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30625 ecode2 = SWIG_AsVal_int(obj1, &val2);
30626 if (!SWIG_IsOK(ecode2)) {
30627 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetYears" "', expected argument " "2"" of type '" "int""'");
30628 }
30629 arg2 = static_cast< int >(val2);
30630 {
30631 PyThreadState* __tstate = wxPyBeginAllowThreads();
30632 {
30633 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
30634 result = (wxDateSpan *) &_result_ref;
30635 }
30636 wxPyEndAllowThreads(__tstate);
30637 if (PyErr_Occurred()) SWIG_fail;
30638 }
30639 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30640 return resultobj;
30641 fail:
30642 return NULL;
30643 }
30644
30645
30646 SWIGINTERN PyObject *_wrap_DateSpan_SetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30647 PyObject *resultobj = 0;
30648 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30649 int arg2 ;
30650 wxDateSpan *result = 0 ;
30651 void *argp1 = 0 ;
30652 int res1 = 0 ;
30653 int val2 ;
30654 int ecode2 = 0 ;
30655 PyObject * obj0 = 0 ;
30656 PyObject * obj1 = 0 ;
30657 char * kwnames[] = {
30658 (char *) "self",(char *) "n", NULL
30659 };
30660
30661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) SWIG_fail;
30662 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30663 if (!SWIG_IsOK(res1)) {
30664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetMonths" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30665 }
30666 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30667 ecode2 = SWIG_AsVal_int(obj1, &val2);
30668 if (!SWIG_IsOK(ecode2)) {
30669 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetMonths" "', expected argument " "2"" of type '" "int""'");
30670 }
30671 arg2 = static_cast< int >(val2);
30672 {
30673 PyThreadState* __tstate = wxPyBeginAllowThreads();
30674 {
30675 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
30676 result = (wxDateSpan *) &_result_ref;
30677 }
30678 wxPyEndAllowThreads(__tstate);
30679 if (PyErr_Occurred()) SWIG_fail;
30680 }
30681 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30682 return resultobj;
30683 fail:
30684 return NULL;
30685 }
30686
30687
30688 SWIGINTERN PyObject *_wrap_DateSpan_SetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30689 PyObject *resultobj = 0;
30690 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30691 int arg2 ;
30692 wxDateSpan *result = 0 ;
30693 void *argp1 = 0 ;
30694 int res1 = 0 ;
30695 int val2 ;
30696 int ecode2 = 0 ;
30697 PyObject * obj0 = 0 ;
30698 PyObject * obj1 = 0 ;
30699 char * kwnames[] = {
30700 (char *) "self",(char *) "n", NULL
30701 };
30702
30703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) SWIG_fail;
30704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30705 if (!SWIG_IsOK(res1)) {
30706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetWeeks" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30707 }
30708 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30709 ecode2 = SWIG_AsVal_int(obj1, &val2);
30710 if (!SWIG_IsOK(ecode2)) {
30711 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetWeeks" "', expected argument " "2"" of type '" "int""'");
30712 }
30713 arg2 = static_cast< int >(val2);
30714 {
30715 PyThreadState* __tstate = wxPyBeginAllowThreads();
30716 {
30717 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
30718 result = (wxDateSpan *) &_result_ref;
30719 }
30720 wxPyEndAllowThreads(__tstate);
30721 if (PyErr_Occurred()) SWIG_fail;
30722 }
30723 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30724 return resultobj;
30725 fail:
30726 return NULL;
30727 }
30728
30729
30730 SWIGINTERN PyObject *_wrap_DateSpan_SetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30731 PyObject *resultobj = 0;
30732 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30733 int arg2 ;
30734 wxDateSpan *result = 0 ;
30735 void *argp1 = 0 ;
30736 int res1 = 0 ;
30737 int val2 ;
30738 int ecode2 = 0 ;
30739 PyObject * obj0 = 0 ;
30740 PyObject * obj1 = 0 ;
30741 char * kwnames[] = {
30742 (char *) "self",(char *) "n", NULL
30743 };
30744
30745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) SWIG_fail;
30746 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30747 if (!SWIG_IsOK(res1)) {
30748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetDays" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30749 }
30750 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30751 ecode2 = SWIG_AsVal_int(obj1, &val2);
30752 if (!SWIG_IsOK(ecode2)) {
30753 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetDays" "', expected argument " "2"" of type '" "int""'");
30754 }
30755 arg2 = static_cast< int >(val2);
30756 {
30757 PyThreadState* __tstate = wxPyBeginAllowThreads();
30758 {
30759 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
30760 result = (wxDateSpan *) &_result_ref;
30761 }
30762 wxPyEndAllowThreads(__tstate);
30763 if (PyErr_Occurred()) SWIG_fail;
30764 }
30765 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30766 return resultobj;
30767 fail:
30768 return NULL;
30769 }
30770
30771
30772 SWIGINTERN PyObject *_wrap_DateSpan_GetYears(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_GetYears" "', 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)->GetYears();
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_GetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30801 PyObject *resultobj = 0;
30802 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30803 int result;
30804 void *argp1 = 0 ;
30805 int res1 = 0 ;
30806 PyObject *swig_obj[1] ;
30807
30808 if (!args) SWIG_fail;
30809 swig_obj[0] = args;
30810 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30811 if (!SWIG_IsOK(res1)) {
30812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetMonths" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30813 }
30814 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30815 {
30816 PyThreadState* __tstate = wxPyBeginAllowThreads();
30817 result = (int)((wxDateSpan const *)arg1)->GetMonths();
30818 wxPyEndAllowThreads(__tstate);
30819 if (PyErr_Occurred()) SWIG_fail;
30820 }
30821 resultobj = SWIG_From_int(static_cast< int >(result));
30822 return resultobj;
30823 fail:
30824 return NULL;
30825 }
30826
30827
30828 SWIGINTERN PyObject *_wrap_DateSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30829 PyObject *resultobj = 0;
30830 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30831 int result;
30832 void *argp1 = 0 ;
30833 int res1 = 0 ;
30834 PyObject *swig_obj[1] ;
30835
30836 if (!args) SWIG_fail;
30837 swig_obj[0] = args;
30838 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30839 if (!SWIG_IsOK(res1)) {
30840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetWeeks" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30841 }
30842 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30843 {
30844 PyThreadState* __tstate = wxPyBeginAllowThreads();
30845 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
30846 wxPyEndAllowThreads(__tstate);
30847 if (PyErr_Occurred()) SWIG_fail;
30848 }
30849 resultobj = SWIG_From_int(static_cast< int >(result));
30850 return resultobj;
30851 fail:
30852 return NULL;
30853 }
30854
30855
30856 SWIGINTERN PyObject *_wrap_DateSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30857 PyObject *resultobj = 0;
30858 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30859 int result;
30860 void *argp1 = 0 ;
30861 int res1 = 0 ;
30862 PyObject *swig_obj[1] ;
30863
30864 if (!args) SWIG_fail;
30865 swig_obj[0] = args;
30866 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30867 if (!SWIG_IsOK(res1)) {
30868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30869 }
30870 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30871 {
30872 PyThreadState* __tstate = wxPyBeginAllowThreads();
30873 result = (int)((wxDateSpan const *)arg1)->GetDays();
30874 wxPyEndAllowThreads(__tstate);
30875 if (PyErr_Occurred()) SWIG_fail;
30876 }
30877 resultobj = SWIG_From_int(static_cast< int >(result));
30878 return resultobj;
30879 fail:
30880 return NULL;
30881 }
30882
30883
30884 SWIGINTERN PyObject *_wrap_DateSpan_GetTotalDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30885 PyObject *resultobj = 0;
30886 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30887 int result;
30888 void *argp1 = 0 ;
30889 int res1 = 0 ;
30890 PyObject *swig_obj[1] ;
30891
30892 if (!args) SWIG_fail;
30893 swig_obj[0] = args;
30894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30895 if (!SWIG_IsOK(res1)) {
30896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetTotalDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30897 }
30898 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30899 {
30900 PyThreadState* __tstate = wxPyBeginAllowThreads();
30901 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
30902 wxPyEndAllowThreads(__tstate);
30903 if (PyErr_Occurred()) SWIG_fail;
30904 }
30905 resultobj = SWIG_From_int(static_cast< int >(result));
30906 return resultobj;
30907 fail:
30908 return NULL;
30909 }
30910
30911
30912 SWIGINTERN PyObject *_wrap_DateSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30913 PyObject *resultobj = 0;
30914 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30915 wxDateSpan *arg2 = 0 ;
30916 wxDateSpan *result = 0 ;
30917 void *argp1 = 0 ;
30918 int res1 = 0 ;
30919 void *argp2 = 0 ;
30920 int res2 = 0 ;
30921 PyObject * obj0 = 0 ;
30922 PyObject * obj1 = 0 ;
30923 char * kwnames[] = {
30924 (char *) "self",(char *) "other", NULL
30925 };
30926
30927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
30928 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30929 if (!SWIG_IsOK(res1)) {
30930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Add" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30931 }
30932 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30933 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30934 if (!SWIG_IsOK(res2)) {
30935 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30936 }
30937 if (!argp2) {
30938 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30939 }
30940 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30941 {
30942 PyThreadState* __tstate = wxPyBeginAllowThreads();
30943 {
30944 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
30945 result = (wxDateSpan *) &_result_ref;
30946 }
30947 wxPyEndAllowThreads(__tstate);
30948 if (PyErr_Occurred()) SWIG_fail;
30949 }
30950 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30951 return resultobj;
30952 fail:
30953 return NULL;
30954 }
30955
30956
30957 SWIGINTERN PyObject *_wrap_DateSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30958 PyObject *resultobj = 0;
30959 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30960 wxDateSpan *arg2 = 0 ;
30961 wxDateSpan *result = 0 ;
30962 void *argp1 = 0 ;
30963 int res1 = 0 ;
30964 void *argp2 = 0 ;
30965 int res2 = 0 ;
30966 PyObject * obj0 = 0 ;
30967 PyObject * obj1 = 0 ;
30968 char * kwnames[] = {
30969 (char *) "self",(char *) "other", NULL
30970 };
30971
30972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
30973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30974 if (!SWIG_IsOK(res1)) {
30975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Subtract" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30976 }
30977 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30978 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30979 if (!SWIG_IsOK(res2)) {
30980 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30981 }
30982 if (!argp2) {
30983 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30984 }
30985 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30986 {
30987 PyThreadState* __tstate = wxPyBeginAllowThreads();
30988 {
30989 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
30990 result = (wxDateSpan *) &_result_ref;
30991 }
30992 wxPyEndAllowThreads(__tstate);
30993 if (PyErr_Occurred()) SWIG_fail;
30994 }
30995 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30996 return resultobj;
30997 fail:
30998 return NULL;
30999 }
31000
31001
31002 SWIGINTERN PyObject *_wrap_DateSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31003 PyObject *resultobj = 0;
31004 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31005 wxDateSpan *result = 0 ;
31006 void *argp1 = 0 ;
31007 int res1 = 0 ;
31008 PyObject *swig_obj[1] ;
31009
31010 if (!args) SWIG_fail;
31011 swig_obj[0] = args;
31012 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31013 if (!SWIG_IsOK(res1)) {
31014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Neg" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31015 }
31016 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31017 {
31018 PyThreadState* __tstate = wxPyBeginAllowThreads();
31019 {
31020 wxDateSpan &_result_ref = (arg1)->Neg();
31021 result = (wxDateSpan *) &_result_ref;
31022 }
31023 wxPyEndAllowThreads(__tstate);
31024 if (PyErr_Occurred()) SWIG_fail;
31025 }
31026 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
31027 return resultobj;
31028 fail:
31029 return NULL;
31030 }
31031
31032
31033 SWIGINTERN PyObject *_wrap_DateSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31034 PyObject *resultobj = 0;
31035 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31036 int arg2 ;
31037 wxDateSpan *result = 0 ;
31038 void *argp1 = 0 ;
31039 int res1 = 0 ;
31040 int val2 ;
31041 int ecode2 = 0 ;
31042 PyObject * obj0 = 0 ;
31043 PyObject * obj1 = 0 ;
31044 char * kwnames[] = {
31045 (char *) "self",(char *) "factor", NULL
31046 };
31047
31048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
31049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31050 if (!SWIG_IsOK(res1)) {
31051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Multiply" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31052 }
31053 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31054 ecode2 = SWIG_AsVal_int(obj1, &val2);
31055 if (!SWIG_IsOK(ecode2)) {
31056 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
31057 }
31058 arg2 = static_cast< int >(val2);
31059 {
31060 PyThreadState* __tstate = wxPyBeginAllowThreads();
31061 {
31062 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
31063 result = (wxDateSpan *) &_result_ref;
31064 }
31065 wxPyEndAllowThreads(__tstate);
31066 if (PyErr_Occurred()) SWIG_fail;
31067 }
31068 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
31069 return resultobj;
31070 fail:
31071 return NULL;
31072 }
31073
31074
31075 SWIGINTERN PyObject *_wrap_DateSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31076 PyObject *resultobj = 0;
31077 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31078 wxDateSpan *arg2 = 0 ;
31079 wxDateSpan *result = 0 ;
31080 void *argp1 = 0 ;
31081 int res1 = 0 ;
31082 void *argp2 = 0 ;
31083 int res2 = 0 ;
31084 PyObject * obj0 = 0 ;
31085 PyObject * obj1 = 0 ;
31086 char * kwnames[] = {
31087 (char *) "self",(char *) "other", NULL
31088 };
31089
31090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
31091 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
31092 if (!SWIG_IsOK(res1)) {
31093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___iadd__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31094 }
31095 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31096 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31097 if (!SWIG_IsOK(res2)) {
31098 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31099 }
31100 if (!argp2) {
31101 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31102 }
31103 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31104 {
31105 PyThreadState* __tstate = wxPyBeginAllowThreads();
31106 {
31107 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
31108 result = (wxDateSpan *) &_result_ref;
31109 }
31110 wxPyEndAllowThreads(__tstate);
31111 if (PyErr_Occurred()) SWIG_fail;
31112 }
31113 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31114 return resultobj;
31115 fail:
31116 return NULL;
31117 }
31118
31119
31120 SWIGINTERN PyObject *_wrap_DateSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31121 PyObject *resultobj = 0;
31122 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31123 wxDateSpan *arg2 = 0 ;
31124 wxDateSpan *result = 0 ;
31125 void *argp1 = 0 ;
31126 int res1 = 0 ;
31127 void *argp2 = 0 ;
31128 int res2 = 0 ;
31129 PyObject * obj0 = 0 ;
31130 PyObject * obj1 = 0 ;
31131 char * kwnames[] = {
31132 (char *) "self",(char *) "other", NULL
31133 };
31134
31135 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
31136 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
31137 if (!SWIG_IsOK(res1)) {
31138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___isub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31139 }
31140 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31141 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31142 if (!SWIG_IsOK(res2)) {
31143 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31144 }
31145 if (!argp2) {
31146 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31147 }
31148 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31149 {
31150 PyThreadState* __tstate = wxPyBeginAllowThreads();
31151 {
31152 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
31153 result = (wxDateSpan *) &_result_ref;
31154 }
31155 wxPyEndAllowThreads(__tstate);
31156 if (PyErr_Occurred()) SWIG_fail;
31157 }
31158 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31159 return resultobj;
31160 fail:
31161 return NULL;
31162 }
31163
31164
31165 SWIGINTERN PyObject *_wrap_DateSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31166 PyObject *resultobj = 0;
31167 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31168 wxDateSpan *result = 0 ;
31169 void *argp1 = 0 ;
31170 int res1 = 0 ;
31171 PyObject *swig_obj[1] ;
31172
31173 if (!args) SWIG_fail;
31174 swig_obj[0] = args;
31175 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31176 if (!SWIG_IsOK(res1)) {
31177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___neg__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31178 }
31179 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31180 {
31181 PyThreadState* __tstate = wxPyBeginAllowThreads();
31182 {
31183 wxDateSpan &_result_ref = (arg1)->operator -();
31184 result = (wxDateSpan *) &_result_ref;
31185 }
31186 wxPyEndAllowThreads(__tstate);
31187 if (PyErr_Occurred()) SWIG_fail;
31188 }
31189 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
31190 return resultobj;
31191 fail:
31192 return NULL;
31193 }
31194
31195
31196 SWIGINTERN PyObject *_wrap_DateSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31197 PyObject *resultobj = 0;
31198 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31199 int arg2 ;
31200 wxDateSpan *result = 0 ;
31201 void *argp1 = 0 ;
31202 int res1 = 0 ;
31203 int val2 ;
31204 int ecode2 = 0 ;
31205 PyObject * obj0 = 0 ;
31206 PyObject * obj1 = 0 ;
31207 char * kwnames[] = {
31208 (char *) "self",(char *) "factor", NULL
31209 };
31210
31211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
31212 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
31213 if (!SWIG_IsOK(res1)) {
31214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___imul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31215 }
31216 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31217 ecode2 = SWIG_AsVal_int(obj1, &val2);
31218 if (!SWIG_IsOK(ecode2)) {
31219 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___imul__" "', expected argument " "2"" of type '" "int""'");
31220 }
31221 arg2 = static_cast< int >(val2);
31222 {
31223 PyThreadState* __tstate = wxPyBeginAllowThreads();
31224 {
31225 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
31226 result = (wxDateSpan *) &_result_ref;
31227 }
31228 wxPyEndAllowThreads(__tstate);
31229 if (PyErr_Occurred()) SWIG_fail;
31230 }
31231 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31232 return resultobj;
31233 fail:
31234 return NULL;
31235 }
31236
31237
31238 SWIGINTERN PyObject *_wrap_DateSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31239 PyObject *resultobj = 0;
31240 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31241 wxDateSpan *arg2 = 0 ;
31242 wxDateSpan result;
31243 void *argp1 = 0 ;
31244 int res1 = 0 ;
31245 void *argp2 = 0 ;
31246 int res2 = 0 ;
31247 PyObject * obj0 = 0 ;
31248 PyObject * obj1 = 0 ;
31249 char * kwnames[] = {
31250 (char *) "self",(char *) "other", NULL
31251 };
31252
31253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
31254 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31255 if (!SWIG_IsOK(res1)) {
31256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___add__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31257 }
31258 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31259 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31260 if (!SWIG_IsOK(res2)) {
31261 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31262 }
31263 if (!argp2) {
31264 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31265 }
31266 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31267 {
31268 PyThreadState* __tstate = wxPyBeginAllowThreads();
31269 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
31270 wxPyEndAllowThreads(__tstate);
31271 if (PyErr_Occurred()) SWIG_fail;
31272 }
31273 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31274 return resultobj;
31275 fail:
31276 return NULL;
31277 }
31278
31279
31280 SWIGINTERN PyObject *_wrap_DateSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31281 PyObject *resultobj = 0;
31282 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31283 wxDateSpan *arg2 = 0 ;
31284 wxDateSpan result;
31285 void *argp1 = 0 ;
31286 int res1 = 0 ;
31287 void *argp2 = 0 ;
31288 int res2 = 0 ;
31289 PyObject * obj0 = 0 ;
31290 PyObject * obj1 = 0 ;
31291 char * kwnames[] = {
31292 (char *) "self",(char *) "other", NULL
31293 };
31294
31295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
31296 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31297 if (!SWIG_IsOK(res1)) {
31298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___sub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31299 }
31300 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31301 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31302 if (!SWIG_IsOK(res2)) {
31303 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31304 }
31305 if (!argp2) {
31306 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31307 }
31308 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31309 {
31310 PyThreadState* __tstate = wxPyBeginAllowThreads();
31311 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
31312 wxPyEndAllowThreads(__tstate);
31313 if (PyErr_Occurred()) SWIG_fail;
31314 }
31315 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31316 return resultobj;
31317 fail:
31318 return NULL;
31319 }
31320
31321
31322 SWIGINTERN PyObject *_wrap_DateSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31323 PyObject *resultobj = 0;
31324 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31325 int arg2 ;
31326 wxDateSpan result;
31327 void *argp1 = 0 ;
31328 int res1 = 0 ;
31329 int val2 ;
31330 int ecode2 = 0 ;
31331 PyObject * obj0 = 0 ;
31332 PyObject * obj1 = 0 ;
31333 char * kwnames[] = {
31334 (char *) "self",(char *) "n", NULL
31335 };
31336
31337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
31338 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31339 if (!SWIG_IsOK(res1)) {
31340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___mul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31341 }
31342 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31343 ecode2 = SWIG_AsVal_int(obj1, &val2);
31344 if (!SWIG_IsOK(ecode2)) {
31345 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___mul__" "', expected argument " "2"" of type '" "int""'");
31346 }
31347 arg2 = static_cast< int >(val2);
31348 {
31349 PyThreadState* __tstate = wxPyBeginAllowThreads();
31350 result = wxDateSpan___mul__(arg1,arg2);
31351 wxPyEndAllowThreads(__tstate);
31352 if (PyErr_Occurred()) SWIG_fail;
31353 }
31354 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31355 return resultobj;
31356 fail:
31357 return NULL;
31358 }
31359
31360
31361 SWIGINTERN PyObject *_wrap_DateSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31362 PyObject *resultobj = 0;
31363 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31364 int arg2 ;
31365 wxDateSpan result;
31366 void *argp1 = 0 ;
31367 int res1 = 0 ;
31368 int val2 ;
31369 int ecode2 = 0 ;
31370 PyObject * obj0 = 0 ;
31371 PyObject * obj1 = 0 ;
31372 char * kwnames[] = {
31373 (char *) "self",(char *) "n", NULL
31374 };
31375
31376 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
31377 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31378 if (!SWIG_IsOK(res1)) {
31379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___rmul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31380 }
31381 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31382 ecode2 = SWIG_AsVal_int(obj1, &val2);
31383 if (!SWIG_IsOK(ecode2)) {
31384 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
31385 }
31386 arg2 = static_cast< int >(val2);
31387 {
31388 PyThreadState* __tstate = wxPyBeginAllowThreads();
31389 result = wxDateSpan___rmul__(arg1,arg2);
31390 wxPyEndAllowThreads(__tstate);
31391 if (PyErr_Occurred()) SWIG_fail;
31392 }
31393 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31394 return resultobj;
31395 fail:
31396 return NULL;
31397 }
31398
31399
31400 SWIGINTERN PyObject *_wrap_DateSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31401 PyObject *resultobj = 0;
31402 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31403 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
31404 bool result;
31405 void *argp1 = 0 ;
31406 int res1 = 0 ;
31407 void *argp2 = 0 ;
31408 int res2 = 0 ;
31409 PyObject * obj0 = 0 ;
31410 PyObject * obj1 = 0 ;
31411 char * kwnames[] = {
31412 (char *) "self",(char *) "other", NULL
31413 };
31414
31415 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
31416 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31417 if (!SWIG_IsOK(res1)) {
31418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___eq__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31419 }
31420 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31421 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31422 if (!SWIG_IsOK(res2)) {
31423 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___eq__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
31424 }
31425 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31426 {
31427 PyThreadState* __tstate = wxPyBeginAllowThreads();
31428 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
31429 wxPyEndAllowThreads(__tstate);
31430 if (PyErr_Occurred()) SWIG_fail;
31431 }
31432 {
31433 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31434 }
31435 return resultobj;
31436 fail:
31437 return NULL;
31438 }
31439
31440
31441 SWIGINTERN PyObject *_wrap_DateSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31442 PyObject *resultobj = 0;
31443 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31444 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
31445 bool result;
31446 void *argp1 = 0 ;
31447 int res1 = 0 ;
31448 void *argp2 = 0 ;
31449 int res2 = 0 ;
31450 PyObject * obj0 = 0 ;
31451 PyObject * obj1 = 0 ;
31452 char * kwnames[] = {
31453 (char *) "self",(char *) "other", NULL
31454 };
31455
31456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
31457 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31458 if (!SWIG_IsOK(res1)) {
31459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___ne__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31460 }
31461 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31462 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31463 if (!SWIG_IsOK(res2)) {
31464 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___ne__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
31465 }
31466 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31467 {
31468 PyThreadState* __tstate = wxPyBeginAllowThreads();
31469 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
31470 wxPyEndAllowThreads(__tstate);
31471 if (PyErr_Occurred()) SWIG_fail;
31472 }
31473 {
31474 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31475 }
31476 return resultobj;
31477 fail:
31478 return NULL;
31479 }
31480
31481
31482 SWIGINTERN PyObject *DateSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31483 PyObject *obj;
31484 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31485 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateSpan, SWIG_NewClientData(obj));
31486 return SWIG_Py_Void();
31487 }
31488
31489 SWIGINTERN PyObject *DateSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31490 return SWIG_Python_InitShadowInstance(args);
31491 }
31492
31493 SWIGINTERN PyObject *_wrap_GetLocalTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31494 PyObject *resultobj = 0;
31495 long result;
31496
31497 if (!SWIG_Python_UnpackTuple(args,"GetLocalTime",0,0,0)) SWIG_fail;
31498 {
31499 PyThreadState* __tstate = wxPyBeginAllowThreads();
31500 result = (long)wxGetLocalTime();
31501 wxPyEndAllowThreads(__tstate);
31502 if (PyErr_Occurred()) SWIG_fail;
31503 }
31504 resultobj = SWIG_From_long(static_cast< long >(result));
31505 return resultobj;
31506 fail:
31507 return NULL;
31508 }
31509
31510
31511 SWIGINTERN PyObject *_wrap_GetUTCTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31512 PyObject *resultobj = 0;
31513 long result;
31514
31515 if (!SWIG_Python_UnpackTuple(args,"GetUTCTime",0,0,0)) SWIG_fail;
31516 {
31517 PyThreadState* __tstate = wxPyBeginAllowThreads();
31518 result = (long)wxGetUTCTime();
31519 wxPyEndAllowThreads(__tstate);
31520 if (PyErr_Occurred()) SWIG_fail;
31521 }
31522 resultobj = SWIG_From_long(static_cast< long >(result));
31523 return resultobj;
31524 fail:
31525 return NULL;
31526 }
31527
31528
31529 SWIGINTERN PyObject *_wrap_GetCurrentTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31530 PyObject *resultobj = 0;
31531 long result;
31532
31533 if (!SWIG_Python_UnpackTuple(args,"GetCurrentTime",0,0,0)) SWIG_fail;
31534 {
31535 PyThreadState* __tstate = wxPyBeginAllowThreads();
31536 result = (long)wxGetCurrentTime();
31537 wxPyEndAllowThreads(__tstate);
31538 if (PyErr_Occurred()) SWIG_fail;
31539 }
31540 resultobj = SWIG_From_long(static_cast< long >(result));
31541 return resultobj;
31542 fail:
31543 return NULL;
31544 }
31545
31546
31547 SWIGINTERN PyObject *_wrap_GetLocalTimeMillis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31548 PyObject *resultobj = 0;
31549 wxLongLong result;
31550
31551 if (!SWIG_Python_UnpackTuple(args,"GetLocalTimeMillis",0,0,0)) SWIG_fail;
31552 {
31553 PyThreadState* __tstate = wxPyBeginAllowThreads();
31554 result = wxGetLocalTimeMillis();
31555 wxPyEndAllowThreads(__tstate);
31556 if (PyErr_Occurred()) SWIG_fail;
31557 }
31558 {
31559 PyObject *hi, *lo, *shifter, *shifted;
31560 hi = PyLong_FromLong( (&result)->GetHi() );
31561 lo = PyLong_FromLong( (&result)->GetLo() );
31562 shifter = PyLong_FromLong(32);
31563 shifted = PyNumber_Lshift(hi, shifter);
31564 resultobj = PyNumber_Or(shifted, lo);
31565 Py_DECREF(hi);
31566 Py_DECREF(lo);
31567 Py_DECREF(shifter);
31568 Py_DECREF(shifted);
31569 }
31570 return resultobj;
31571 fail:
31572 return NULL;
31573 }
31574
31575
31576 SWIGINTERN int DefaultDateTime_set(PyObject *) {
31577 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTime is read-only.");
31578 return 1;
31579 }
31580
31581
31582 SWIGINTERN PyObject *DefaultDateTime_get(void) {
31583 PyObject *pyobj = 0;
31584
31585 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0 );
31586 return pyobj;
31587 }
31588
31589
31590 SWIGINTERN PyObject *_wrap_new_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31591 PyObject *resultobj = 0;
31592 wxDataFormatId arg1 ;
31593 wxDataFormat *result = 0 ;
31594 int val1 ;
31595 int ecode1 = 0 ;
31596 PyObject * obj0 = 0 ;
31597 char * kwnames[] = {
31598 (char *) "type", NULL
31599 };
31600
31601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) SWIG_fail;
31602 ecode1 = SWIG_AsVal_int(obj0, &val1);
31603 if (!SWIG_IsOK(ecode1)) {
31604 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DataFormat" "', expected argument " "1"" of type '" "wxDataFormatId""'");
31605 }
31606 arg1 = static_cast< wxDataFormatId >(val1);
31607 {
31608 PyThreadState* __tstate = wxPyBeginAllowThreads();
31609 result = (wxDataFormat *)new wxDataFormat(arg1);
31610 wxPyEndAllowThreads(__tstate);
31611 if (PyErr_Occurred()) SWIG_fail;
31612 }
31613 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_NEW | 0 );
31614 return resultobj;
31615 fail:
31616 return NULL;
31617 }
31618
31619
31620 SWIGINTERN PyObject *_wrap_new_CustomDataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31621 PyObject *resultobj = 0;
31622 wxString *arg1 = 0 ;
31623 wxDataFormat *result = 0 ;
31624 bool temp1 = false ;
31625 PyObject * obj0 = 0 ;
31626 char * kwnames[] = {
31627 (char *) "format", NULL
31628 };
31629
31630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) SWIG_fail;
31631 {
31632 arg1 = wxString_in_helper(obj0);
31633 if (arg1 == NULL) SWIG_fail;
31634 temp1 = true;
31635 }
31636 {
31637 PyThreadState* __tstate = wxPyBeginAllowThreads();
31638 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
31639 wxPyEndAllowThreads(__tstate);
31640 if (PyErr_Occurred()) SWIG_fail;
31641 }
31642 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
31643 {
31644 if (temp1)
31645 delete arg1;
31646 }
31647 return resultobj;
31648 fail:
31649 {
31650 if (temp1)
31651 delete arg1;
31652 }
31653 return NULL;
31654 }
31655
31656
31657 SWIGINTERN PyObject *_wrap_delete_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31658 PyObject *resultobj = 0;
31659 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31660 void *argp1 = 0 ;
31661 int res1 = 0 ;
31662 PyObject *swig_obj[1] ;
31663
31664 if (!args) SWIG_fail;
31665 swig_obj[0] = args;
31666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, SWIG_POINTER_DISOWN | 0 );
31667 if (!SWIG_IsOK(res1)) {
31668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataFormat" "', expected argument " "1"" of type '" "wxDataFormat *""'");
31669 }
31670 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31671 {
31672 PyThreadState* __tstate = wxPyBeginAllowThreads();
31673 delete arg1;
31674
31675 wxPyEndAllowThreads(__tstate);
31676 if (PyErr_Occurred()) SWIG_fail;
31677 }
31678 resultobj = SWIG_Py_Void();
31679 return resultobj;
31680 fail:
31681 return NULL;
31682 }
31683
31684
31685 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31686 PyObject *resultobj = 0;
31687 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31688 wxDataFormatId arg2 ;
31689 bool result;
31690 void *argp1 = 0 ;
31691 int res1 = 0 ;
31692 int val2 ;
31693 int ecode2 = 0 ;
31694
31695 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31697 if (!SWIG_IsOK(res1)) {
31698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31699 }
31700 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31701 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
31702 if (!SWIG_IsOK(ecode2)) {
31703 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31704 }
31705 arg2 = static_cast< wxDataFormatId >(val2);
31706 {
31707 PyThreadState* __tstate = wxPyBeginAllowThreads();
31708 result = (bool)((wxDataFormat const *)arg1)->operator ==(arg2);
31709 wxPyEndAllowThreads(__tstate);
31710 if (PyErr_Occurred()) SWIG_fail;
31711 }
31712 {
31713 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31714 }
31715 return resultobj;
31716 fail:
31717 return NULL;
31718 }
31719
31720
31721 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31722 PyObject *resultobj = 0;
31723 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31724 wxDataFormatId arg2 ;
31725 bool result;
31726 void *argp1 = 0 ;
31727 int res1 = 0 ;
31728 int val2 ;
31729 int ecode2 = 0 ;
31730
31731 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31733 if (!SWIG_IsOK(res1)) {
31734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31735 }
31736 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31737 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
31738 if (!SWIG_IsOK(ecode2)) {
31739 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31740 }
31741 arg2 = static_cast< wxDataFormatId >(val2);
31742 {
31743 PyThreadState* __tstate = wxPyBeginAllowThreads();
31744 result = (bool)((wxDataFormat const *)arg1)->operator !=(arg2);
31745 wxPyEndAllowThreads(__tstate);
31746 if (PyErr_Occurred()) SWIG_fail;
31747 }
31748 {
31749 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31750 }
31751 return resultobj;
31752 fail:
31753 return NULL;
31754 }
31755
31756
31757 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31758 PyObject *resultobj = 0;
31759 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31760 wxDataFormat *arg2 = 0 ;
31761 bool result;
31762 void *argp1 = 0 ;
31763 int res1 = 0 ;
31764 void *argp2 = 0 ;
31765 int res2 = 0 ;
31766
31767 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31769 if (!SWIG_IsOK(res1)) {
31770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31771 }
31772 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31773 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31774 if (!SWIG_IsOK(res2)) {
31775 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31776 }
31777 if (!argp2) {
31778 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31779 }
31780 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31781 {
31782 PyThreadState* __tstate = wxPyBeginAllowThreads();
31783 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
31784 wxPyEndAllowThreads(__tstate);
31785 if (PyErr_Occurred()) SWIG_fail;
31786 }
31787 {
31788 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31789 }
31790 return resultobj;
31791 fail:
31792 return NULL;
31793 }
31794
31795
31796 SWIGINTERN PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
31797 int argc;
31798 PyObject *argv[3];
31799
31800 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___eq__",0,2,argv))) SWIG_fail;
31801 --argc;
31802 if (argc == 2) {
31803 int _v = 0;
31804 {
31805 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
31806 _v = SWIG_CheckState(res);
31807 }
31808 if (!_v) goto check_1;
31809 return _wrap_DataFormat___eq____SWIG_1(self, argc, argv);
31810 }
31811 check_1:
31812
31813 if (argc == 2) {
31814 return _wrap_DataFormat___eq____SWIG_0(self, argc, argv);
31815 }
31816
31817 fail:
31818 Py_INCREF(Py_NotImplemented);
31819 return Py_NotImplemented;
31820 }
31821
31822
31823 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31824 PyObject *resultobj = 0;
31825 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31826 wxDataFormat *arg2 = 0 ;
31827 bool result;
31828 void *argp1 = 0 ;
31829 int res1 = 0 ;
31830 void *argp2 = 0 ;
31831 int res2 = 0 ;
31832
31833 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31835 if (!SWIG_IsOK(res1)) {
31836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31837 }
31838 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31839 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31840 if (!SWIG_IsOK(res2)) {
31841 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31842 }
31843 if (!argp2) {
31844 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31845 }
31846 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31847 {
31848 PyThreadState* __tstate = wxPyBeginAllowThreads();
31849 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
31850 wxPyEndAllowThreads(__tstate);
31851 if (PyErr_Occurred()) SWIG_fail;
31852 }
31853 {
31854 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31855 }
31856 return resultobj;
31857 fail:
31858 return NULL;
31859 }
31860
31861
31862 SWIGINTERN PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
31863 int argc;
31864 PyObject *argv[3];
31865
31866 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___ne__",0,2,argv))) SWIG_fail;
31867 --argc;
31868 if (argc == 2) {
31869 int _v = 0;
31870 {
31871 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
31872 _v = SWIG_CheckState(res);
31873 }
31874 if (!_v) goto check_1;
31875 return _wrap_DataFormat___ne____SWIG_1(self, argc, argv);
31876 }
31877 check_1:
31878
31879 if (argc == 2) {
31880 return _wrap_DataFormat___ne____SWIG_0(self, argc, argv);
31881 }
31882
31883 fail:
31884 Py_INCREF(Py_NotImplemented);
31885 return Py_NotImplemented;
31886 }
31887
31888
31889 SWIGINTERN PyObject *_wrap_DataFormat_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31890 PyObject *resultobj = 0;
31891 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31892 wxDataFormatId arg2 ;
31893 void *argp1 = 0 ;
31894 int res1 = 0 ;
31895 int val2 ;
31896 int ecode2 = 0 ;
31897 PyObject * obj0 = 0 ;
31898 PyObject * obj1 = 0 ;
31899 char * kwnames[] = {
31900 (char *) "self",(char *) "format", NULL
31901 };
31902
31903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
31904 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31905 if (!SWIG_IsOK(res1)) {
31906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetType" "', expected argument " "1"" of type '" "wxDataFormat *""'");
31907 }
31908 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31909 ecode2 = SWIG_AsVal_int(obj1, &val2);
31910 if (!SWIG_IsOK(ecode2)) {
31911 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat_SetType" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31912 }
31913 arg2 = static_cast< wxDataFormatId >(val2);
31914 {
31915 PyThreadState* __tstate = wxPyBeginAllowThreads();
31916 (arg1)->SetType(arg2);
31917 wxPyEndAllowThreads(__tstate);
31918 if (PyErr_Occurred()) SWIG_fail;
31919 }
31920 resultobj = SWIG_Py_Void();
31921 return resultobj;
31922 fail:
31923 return NULL;
31924 }
31925
31926
31927 SWIGINTERN PyObject *_wrap_DataFormat_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31928 PyObject *resultobj = 0;
31929 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31930 wxDataFormatId result;
31931 void *argp1 = 0 ;
31932 int res1 = 0 ;
31933 PyObject *swig_obj[1] ;
31934
31935 if (!args) SWIG_fail;
31936 swig_obj[0] = args;
31937 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31938 if (!SWIG_IsOK(res1)) {
31939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetType" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31940 }
31941 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31942 {
31943 PyThreadState* __tstate = wxPyBeginAllowThreads();
31944 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
31945 wxPyEndAllowThreads(__tstate);
31946 if (PyErr_Occurred()) SWIG_fail;
31947 }
31948 resultobj = SWIG_From_int(static_cast< int >(result));
31949 return resultobj;
31950 fail:
31951 return NULL;
31952 }
31953
31954
31955 SWIGINTERN PyObject *_wrap_DataFormat__GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31956 PyObject *resultobj = 0;
31957 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31958 wxString result;
31959 void *argp1 = 0 ;
31960 int res1 = 0 ;
31961 PyObject *swig_obj[1] ;
31962
31963 if (!args) SWIG_fail;
31964 swig_obj[0] = args;
31965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31966 if (!SWIG_IsOK(res1)) {
31967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat__GetId" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31968 }
31969 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31970 {
31971 PyThreadState* __tstate = wxPyBeginAllowThreads();
31972 result = ((wxDataFormat const *)arg1)->GetId();
31973 wxPyEndAllowThreads(__tstate);
31974 if (PyErr_Occurred()) SWIG_fail;
31975 }
31976 {
31977 #if wxUSE_UNICODE
31978 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31979 #else
31980 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31981 #endif
31982 }
31983 return resultobj;
31984 fail:
31985 return NULL;
31986 }
31987
31988
31989 SWIGINTERN PyObject *_wrap_DataFormat_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31990 PyObject *resultobj = 0;
31991 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31992 wxString *arg2 = 0 ;
31993 void *argp1 = 0 ;
31994 int res1 = 0 ;
31995 bool temp2 = false ;
31996 PyObject * obj0 = 0 ;
31997 PyObject * obj1 = 0 ;
31998 char * kwnames[] = {
31999 (char *) "self",(char *) "format", NULL
32000 };
32001
32002 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
32003 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
32004 if (!SWIG_IsOK(res1)) {
32005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetId" "', expected argument " "1"" of type '" "wxDataFormat *""'");
32006 }
32007 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
32008 {
32009 arg2 = wxString_in_helper(obj1);
32010 if (arg2 == NULL) SWIG_fail;
32011 temp2 = true;
32012 }
32013 {
32014 PyThreadState* __tstate = wxPyBeginAllowThreads();
32015 (arg1)->SetId((wxString const &)*arg2);
32016 wxPyEndAllowThreads(__tstate);
32017 if (PyErr_Occurred()) SWIG_fail;
32018 }
32019 resultobj = SWIG_Py_Void();
32020 {
32021 if (temp2)
32022 delete arg2;
32023 }
32024 return resultobj;
32025 fail:
32026 {
32027 if (temp2)
32028 delete arg2;
32029 }
32030 return NULL;
32031 }
32032
32033
32034 SWIGINTERN PyObject *DataFormat_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32035 PyObject *obj;
32036 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32037 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataFormat, SWIG_NewClientData(obj));
32038 return SWIG_Py_Void();
32039 }
32040
32041 SWIGINTERN PyObject *DataFormat_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32042 return SWIG_Python_InitShadowInstance(args);
32043 }
32044
32045 SWIGINTERN int FormatInvalid_set(PyObject *) {
32046 SWIG_Error(SWIG_AttributeError,"Variable FormatInvalid is read-only.");
32047 return 1;
32048 }
32049
32050
32051 SWIGINTERN PyObject *FormatInvalid_get(void) {
32052 PyObject *pyobj = 0;
32053
32054 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0 );
32055 return pyobj;
32056 }
32057
32058
32059 SWIGINTERN PyObject *_wrap_delete_DataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32060 PyObject *resultobj = 0;
32061 wxDataObject *arg1 = (wxDataObject *) 0 ;
32062 void *argp1 = 0 ;
32063 int res1 = 0 ;
32064 PyObject *swig_obj[1] ;
32065
32066 if (!args) SWIG_fail;
32067 swig_obj[0] = args;
32068 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
32069 if (!SWIG_IsOK(res1)) {
32070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataObject" "', expected argument " "1"" of type '" "wxDataObject *""'");
32071 }
32072 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32073 {
32074 PyThreadState* __tstate = wxPyBeginAllowThreads();
32075 delete arg1;
32076
32077 wxPyEndAllowThreads(__tstate);
32078 if (PyErr_Occurred()) SWIG_fail;
32079 }
32080 resultobj = SWIG_Py_Void();
32081 return resultobj;
32082 fail:
32083 return NULL;
32084 }
32085
32086
32087 SWIGINTERN PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32088 PyObject *resultobj = 0;
32089 wxDataObject *arg1 = (wxDataObject *) 0 ;
32090 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
32091 SwigValueWrapper<wxDataFormat > result;
32092 void *argp1 = 0 ;
32093 int res1 = 0 ;
32094 int val2 ;
32095 int ecode2 = 0 ;
32096 PyObject * obj0 = 0 ;
32097 PyObject * obj1 = 0 ;
32098 char * kwnames[] = {
32099 (char *) "self",(char *) "dir", NULL
32100 };
32101
32102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) SWIG_fail;
32103 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32104 if (!SWIG_IsOK(res1)) {
32105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32106 }
32107 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32108 if (obj1) {
32109 ecode2 = SWIG_AsVal_int(obj1, &val2);
32110 if (!SWIG_IsOK(ecode2)) {
32111 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
32112 }
32113 arg2 = static_cast< wxDataObject::Direction >(val2);
32114 }
32115 {
32116 PyThreadState* __tstate = wxPyBeginAllowThreads();
32117 result = ((wxDataObject const *)arg1)->GetPreferredFormat(arg2);
32118 wxPyEndAllowThreads(__tstate);
32119 if (PyErr_Occurred()) SWIG_fail;
32120 }
32121 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
32122 return resultobj;
32123 fail:
32124 return NULL;
32125 }
32126
32127
32128 SWIGINTERN PyObject *_wrap_DataObject_GetFormatCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32129 PyObject *resultobj = 0;
32130 wxDataObject *arg1 = (wxDataObject *) 0 ;
32131 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
32132 size_t result;
32133 void *argp1 = 0 ;
32134 int res1 = 0 ;
32135 int val2 ;
32136 int ecode2 = 0 ;
32137 PyObject * obj0 = 0 ;
32138 PyObject * obj1 = 0 ;
32139 char * kwnames[] = {
32140 (char *) "self",(char *) "dir", NULL
32141 };
32142
32143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) SWIG_fail;
32144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32145 if (!SWIG_IsOK(res1)) {
32146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetFormatCount" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32147 }
32148 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32149 if (obj1) {
32150 ecode2 = SWIG_AsVal_int(obj1, &val2);
32151 if (!SWIG_IsOK(ecode2)) {
32152 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetFormatCount" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
32153 }
32154 arg2 = static_cast< wxDataObject::Direction >(val2);
32155 }
32156 {
32157 PyThreadState* __tstate = wxPyBeginAllowThreads();
32158 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount(arg2);
32159 wxPyEndAllowThreads(__tstate);
32160 if (PyErr_Occurred()) SWIG_fail;
32161 }
32162 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32163 return resultobj;
32164 fail:
32165 return NULL;
32166 }
32167
32168
32169 SWIGINTERN PyObject *_wrap_DataObject_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32170 PyObject *resultobj = 0;
32171 wxDataObject *arg1 = (wxDataObject *) 0 ;
32172 wxDataFormat *arg2 = 0 ;
32173 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
32174 bool result;
32175 void *argp1 = 0 ;
32176 int res1 = 0 ;
32177 void *argp2 = 0 ;
32178 int res2 = 0 ;
32179 int val3 ;
32180 int ecode3 = 0 ;
32181 PyObject * obj0 = 0 ;
32182 PyObject * obj1 = 0 ;
32183 PyObject * obj2 = 0 ;
32184 char * kwnames[] = {
32185 (char *) "self",(char *) "format",(char *) "dir", NULL
32186 };
32187
32188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32189 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32190 if (!SWIG_IsOK(res1)) {
32191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_IsSupported" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32192 }
32193 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32194 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32195 if (!SWIG_IsOK(res2)) {
32196 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32197 }
32198 if (!argp2) {
32199 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32200 }
32201 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32202 if (obj2) {
32203 ecode3 = SWIG_AsVal_int(obj2, &val3);
32204 if (!SWIG_IsOK(ecode3)) {
32205 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObject_IsSupported" "', expected argument " "3"" of type '" "wxDataObject::Direction""'");
32206 }
32207 arg3 = static_cast< wxDataObject::Direction >(val3);
32208 }
32209 {
32210 PyThreadState* __tstate = wxPyBeginAllowThreads();
32211 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,arg3);
32212 wxPyEndAllowThreads(__tstate);
32213 if (PyErr_Occurred()) SWIG_fail;
32214 }
32215 {
32216 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32217 }
32218 return resultobj;
32219 fail:
32220 return NULL;
32221 }
32222
32223
32224 SWIGINTERN PyObject *_wrap_DataObject_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32225 PyObject *resultobj = 0;
32226 wxDataObject *arg1 = (wxDataObject *) 0 ;
32227 wxDataFormat *arg2 = 0 ;
32228 size_t result;
32229 void *argp1 = 0 ;
32230 int res1 = 0 ;
32231 void *argp2 = 0 ;
32232 int res2 = 0 ;
32233 PyObject * obj0 = 0 ;
32234 PyObject * obj1 = 0 ;
32235 char * kwnames[] = {
32236 (char *) "self",(char *) "format", NULL
32237 };
32238
32239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) SWIG_fail;
32240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32241 if (!SWIG_IsOK(res1)) {
32242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataSize" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32243 }
32244 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32245 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32246 if (!SWIG_IsOK(res2)) {
32247 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32248 }
32249 if (!argp2) {
32250 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32251 }
32252 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32253 {
32254 PyThreadState* __tstate = wxPyBeginAllowThreads();
32255 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
32256 wxPyEndAllowThreads(__tstate);
32257 if (PyErr_Occurred()) SWIG_fail;
32258 }
32259 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32260 return resultobj;
32261 fail:
32262 return NULL;
32263 }
32264
32265
32266 SWIGINTERN PyObject *_wrap_DataObject_GetAllFormats(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32267 PyObject *resultobj = 0;
32268 wxDataObject *arg1 = (wxDataObject *) 0 ;
32269 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
32270 PyObject *result = 0 ;
32271 void *argp1 = 0 ;
32272 int res1 = 0 ;
32273 int val2 ;
32274 int ecode2 = 0 ;
32275 PyObject * obj0 = 0 ;
32276 PyObject * obj1 = 0 ;
32277 char * kwnames[] = {
32278 (char *) "self",(char *) "dir", NULL
32279 };
32280
32281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) SWIG_fail;
32282 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32283 if (!SWIG_IsOK(res1)) {
32284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetAllFormats" "', expected argument " "1"" of type '" "wxDataObject *""'");
32285 }
32286 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32287 if (obj1) {
32288 ecode2 = SWIG_AsVal_int(obj1, &val2);
32289 if (!SWIG_IsOK(ecode2)) {
32290 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetAllFormats" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
32291 }
32292 arg2 = static_cast< wxDataObject::Direction >(val2);
32293 }
32294 {
32295 PyThreadState* __tstate = wxPyBeginAllowThreads();
32296 result = (PyObject *)wxDataObject_GetAllFormats(arg1,arg2);
32297 wxPyEndAllowThreads(__tstate);
32298 if (PyErr_Occurred()) SWIG_fail;
32299 }
32300 resultobj = result;
32301 return resultobj;
32302 fail:
32303 return NULL;
32304 }
32305
32306
32307 SWIGINTERN PyObject *_wrap_DataObject_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32308 PyObject *resultobj = 0;
32309 wxDataObject *arg1 = (wxDataObject *) 0 ;
32310 wxDataFormat *arg2 = 0 ;
32311 PyObject *result = 0 ;
32312 void *argp1 = 0 ;
32313 int res1 = 0 ;
32314 void *argp2 = 0 ;
32315 int res2 = 0 ;
32316 PyObject * obj0 = 0 ;
32317 PyObject * obj1 = 0 ;
32318 char * kwnames[] = {
32319 (char *) "self",(char *) "format", NULL
32320 };
32321
32322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) SWIG_fail;
32323 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32324 if (!SWIG_IsOK(res1)) {
32325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataHere" "', expected argument " "1"" of type '" "wxDataObject *""'");
32326 }
32327 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32328 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32329 if (!SWIG_IsOK(res2)) {
32330 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32331 }
32332 if (!argp2) {
32333 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32334 }
32335 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32336 {
32337 PyThreadState* __tstate = wxPyBeginAllowThreads();
32338 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
32339 wxPyEndAllowThreads(__tstate);
32340 if (PyErr_Occurred()) SWIG_fail;
32341 }
32342 resultobj = result;
32343 return resultobj;
32344 fail:
32345 return NULL;
32346 }
32347
32348
32349 SWIGINTERN PyObject *_wrap_DataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32350 PyObject *resultobj = 0;
32351 wxDataObject *arg1 = (wxDataObject *) 0 ;
32352 wxDataFormat *arg2 = 0 ;
32353 PyObject *arg3 = (PyObject *) 0 ;
32354 bool result;
32355 void *argp1 = 0 ;
32356 int res1 = 0 ;
32357 void *argp2 = 0 ;
32358 int res2 = 0 ;
32359 PyObject * obj0 = 0 ;
32360 PyObject * obj1 = 0 ;
32361 PyObject * obj2 = 0 ;
32362 char * kwnames[] = {
32363 (char *) "self",(char *) "format",(char *) "data", NULL
32364 };
32365
32366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32367 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32368 if (!SWIG_IsOK(res1)) {
32369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_SetData" "', expected argument " "1"" of type '" "wxDataObject *""'");
32370 }
32371 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32372 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32373 if (!SWIG_IsOK(res2)) {
32374 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32375 }
32376 if (!argp2) {
32377 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32378 }
32379 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32380 arg3 = obj2;
32381 {
32382 PyThreadState* __tstate = wxPyBeginAllowThreads();
32383 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
32384 wxPyEndAllowThreads(__tstate);
32385 if (PyErr_Occurred()) SWIG_fail;
32386 }
32387 {
32388 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32389 }
32390 return resultobj;
32391 fail:
32392 return NULL;
32393 }
32394
32395
32396 SWIGINTERN PyObject *DataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32397 PyObject *obj;
32398 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32399 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObject, SWIG_NewClientData(obj));
32400 return SWIG_Py_Void();
32401 }
32402
32403 SWIGINTERN PyObject *_wrap_new_DataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32404 PyObject *resultobj = 0;
32405 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
32406 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
32407 wxDataObjectSimple *result = 0 ;
32408 void *argp1 = 0 ;
32409 int res1 = 0 ;
32410 PyObject * obj0 = 0 ;
32411 char * kwnames[] = {
32412 (char *) "format", NULL
32413 };
32414
32415 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) SWIG_fail;
32416 if (obj0) {
32417 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
32418 if (!SWIG_IsOK(res1)) {
32419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32420 }
32421 if (!argp1) {
32422 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32423 }
32424 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
32425 }
32426 {
32427 PyThreadState* __tstate = wxPyBeginAllowThreads();
32428 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
32429 wxPyEndAllowThreads(__tstate);
32430 if (PyErr_Occurred()) SWIG_fail;
32431 }
32432 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_NEW | 0 );
32433 return resultobj;
32434 fail:
32435 return NULL;
32436 }
32437
32438
32439 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32440 PyObject *resultobj = 0;
32441 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32442 wxDataFormat *result = 0 ;
32443 void *argp1 = 0 ;
32444 int res1 = 0 ;
32445 PyObject *swig_obj[1] ;
32446
32447 if (!args) SWIG_fail;
32448 swig_obj[0] = args;
32449 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32450 if (!SWIG_IsOK(res1)) {
32451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32452 }
32453 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32454 {
32455 PyThreadState* __tstate = wxPyBeginAllowThreads();
32456 {
32457 wxDataFormat const &_result_ref = (arg1)->GetFormat();
32458 result = (wxDataFormat *) &_result_ref;
32459 }
32460 wxPyEndAllowThreads(__tstate);
32461 if (PyErr_Occurred()) SWIG_fail;
32462 }
32463 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, 0 | 0 );
32464 return resultobj;
32465 fail:
32466 return NULL;
32467 }
32468
32469
32470 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32471 PyObject *resultobj = 0;
32472 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32473 wxDataFormat *arg2 = 0 ;
32474 void *argp1 = 0 ;
32475 int res1 = 0 ;
32476 void *argp2 = 0 ;
32477 int res2 = 0 ;
32478 PyObject * obj0 = 0 ;
32479 PyObject * obj1 = 0 ;
32480 char * kwnames[] = {
32481 (char *) "self",(char *) "format", NULL
32482 };
32483
32484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) SWIG_fail;
32485 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32486 if (!SWIG_IsOK(res1)) {
32487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32488 }
32489 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32490 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32491 if (!SWIG_IsOK(res2)) {
32492 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32493 }
32494 if (!argp2) {
32495 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32496 }
32497 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32498 {
32499 PyThreadState* __tstate = wxPyBeginAllowThreads();
32500 (arg1)->SetFormat((wxDataFormat const &)*arg2);
32501 wxPyEndAllowThreads(__tstate);
32502 if (PyErr_Occurred()) SWIG_fail;
32503 }
32504 resultobj = SWIG_Py_Void();
32505 return resultobj;
32506 fail:
32507 return NULL;
32508 }
32509
32510
32511 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32512 PyObject *resultobj = 0;
32513 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32514 size_t result;
32515 void *argp1 = 0 ;
32516 int res1 = 0 ;
32517 PyObject *swig_obj[1] ;
32518
32519 if (!args) SWIG_fail;
32520 swig_obj[0] = args;
32521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32522 if (!SWIG_IsOK(res1)) {
32523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataSize" "', expected argument " "1"" of type '" "wxDataObjectSimple const *""'");
32524 }
32525 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32526 {
32527 PyThreadState* __tstate = wxPyBeginAllowThreads();
32528 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
32529 wxPyEndAllowThreads(__tstate);
32530 if (PyErr_Occurred()) SWIG_fail;
32531 }
32532 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32533 return resultobj;
32534 fail:
32535 return NULL;
32536 }
32537
32538
32539 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32540 PyObject *resultobj = 0;
32541 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32542 PyObject *result = 0 ;
32543 void *argp1 = 0 ;
32544 int res1 = 0 ;
32545 PyObject *swig_obj[1] ;
32546
32547 if (!args) SWIG_fail;
32548 swig_obj[0] = args;
32549 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32550 if (!SWIG_IsOK(res1)) {
32551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataHere" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32552 }
32553 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32554 {
32555 PyThreadState* __tstate = wxPyBeginAllowThreads();
32556 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
32557 wxPyEndAllowThreads(__tstate);
32558 if (PyErr_Occurred()) SWIG_fail;
32559 }
32560 resultobj = result;
32561 return resultobj;
32562 fail:
32563 return NULL;
32564 }
32565
32566
32567 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32568 PyObject *resultobj = 0;
32569 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32570 PyObject *arg2 = (PyObject *) 0 ;
32571 bool result;
32572 void *argp1 = 0 ;
32573 int res1 = 0 ;
32574 PyObject * obj0 = 0 ;
32575 PyObject * obj1 = 0 ;
32576 char * kwnames[] = {
32577 (char *) "self",(char *) "data", NULL
32578 };
32579
32580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
32581 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32582 if (!SWIG_IsOK(res1)) {
32583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetData" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32584 }
32585 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32586 arg2 = obj1;
32587 {
32588 PyThreadState* __tstate = wxPyBeginAllowThreads();
32589 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
32590 wxPyEndAllowThreads(__tstate);
32591 if (PyErr_Occurred()) SWIG_fail;
32592 }
32593 {
32594 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32595 }
32596 return resultobj;
32597 fail:
32598 return NULL;
32599 }
32600
32601
32602 SWIGINTERN PyObject *DataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32603 PyObject *obj;
32604 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32605 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectSimple, SWIG_NewClientData(obj));
32606 return SWIG_Py_Void();
32607 }
32608
32609 SWIGINTERN PyObject *DataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32610 return SWIG_Python_InitShadowInstance(args);
32611 }
32612
32613 SWIGINTERN PyObject *_wrap_new_PyDataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32614 PyObject *resultobj = 0;
32615 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
32616 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
32617 wxPyDataObjectSimple *result = 0 ;
32618 void *argp1 = 0 ;
32619 int res1 = 0 ;
32620 PyObject * obj0 = 0 ;
32621 char * kwnames[] = {
32622 (char *) "format", NULL
32623 };
32624
32625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) SWIG_fail;
32626 if (obj0) {
32627 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
32628 if (!SWIG_IsOK(res1)) {
32629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32630 }
32631 if (!argp1) {
32632 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32633 }
32634 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
32635 }
32636 {
32637 PyThreadState* __tstate = wxPyBeginAllowThreads();
32638 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
32639 wxPyEndAllowThreads(__tstate);
32640 if (PyErr_Occurred()) SWIG_fail;
32641 }
32642 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_NEW | 0 );
32643 return resultobj;
32644 fail:
32645 return NULL;
32646 }
32647
32648
32649 SWIGINTERN PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32650 PyObject *resultobj = 0;
32651 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
32652 PyObject *arg2 = (PyObject *) 0 ;
32653 PyObject *arg3 = (PyObject *) 0 ;
32654 void *argp1 = 0 ;
32655 int res1 = 0 ;
32656 PyObject * obj0 = 0 ;
32657 PyObject * obj1 = 0 ;
32658 PyObject * obj2 = 0 ;
32659 char * kwnames[] = {
32660 (char *) "self",(char *) "self",(char *) "_class", NULL
32661 };
32662
32663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDataObjectSimple, 0 | 0 );
32665 if (!SWIG_IsOK(res1)) {
32666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyDataObjectSimple__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDataObjectSimple *""'");
32667 }
32668 arg1 = reinterpret_cast< wxPyDataObjectSimple * >(argp1);
32669 arg2 = obj1;
32670 arg3 = obj2;
32671 {
32672 PyThreadState* __tstate = wxPyBeginAllowThreads();
32673 (arg1)->_setCallbackInfo(arg2,arg3);
32674 wxPyEndAllowThreads(__tstate);
32675 if (PyErr_Occurred()) SWIG_fail;
32676 }
32677 resultobj = SWIG_Py_Void();
32678 return resultobj;
32679 fail:
32680 return NULL;
32681 }
32682
32683
32684 SWIGINTERN PyObject *PyDataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32685 PyObject *obj;
32686 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32687 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDataObjectSimple, SWIG_NewClientData(obj));
32688 return SWIG_Py_Void();
32689 }
32690
32691 SWIGINTERN PyObject *PyDataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32692 return SWIG_Python_InitShadowInstance(args);
32693 }
32694
32695 SWIGINTERN PyObject *_wrap_new_DataObjectComposite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32696 PyObject *resultobj = 0;
32697 wxDataObjectComposite *result = 0 ;
32698
32699 if (!SWIG_Python_UnpackTuple(args,"new_DataObjectComposite",0,0,0)) SWIG_fail;
32700 {
32701 PyThreadState* __tstate = wxPyBeginAllowThreads();
32702 result = (wxDataObjectComposite *)new wxDataObjectComposite();
32703 wxPyEndAllowThreads(__tstate);
32704 if (PyErr_Occurred()) SWIG_fail;
32705 }
32706 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_NEW | 0 );
32707 return resultobj;
32708 fail:
32709 return NULL;
32710 }
32711
32712
32713 SWIGINTERN PyObject *_wrap_DataObjectComposite_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32714 PyObject *resultobj = 0;
32715 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
32716 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
32717 bool arg3 = (bool) false ;
32718 void *argp1 = 0 ;
32719 int res1 = 0 ;
32720 int res2 = 0 ;
32721 bool val3 ;
32722 int ecode3 = 0 ;
32723 PyObject * obj0 = 0 ;
32724 PyObject * obj1 = 0 ;
32725 PyObject * obj2 = 0 ;
32726 char * kwnames[] = {
32727 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
32728 };
32729
32730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32731 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
32732 if (!SWIG_IsOK(res1)) {
32733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_Add" "', expected argument " "1"" of type '" "wxDataObjectComposite *""'");
32734 }
32735 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
32736 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_DISOWN | 0 );
32737 if (!SWIG_IsOK(res2)) {
32738 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectComposite_Add" "', expected argument " "2"" of type '" "wxDataObjectSimple *""'");
32739 }
32740 if (obj2) {
32741 ecode3 = SWIG_AsVal_bool(obj2, &val3);
32742 if (!SWIG_IsOK(ecode3)) {
32743 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObjectComposite_Add" "', expected argument " "3"" of type '" "bool""'");
32744 }
32745 arg3 = static_cast< bool >(val3);
32746 }
32747 {
32748 PyThreadState* __tstate = wxPyBeginAllowThreads();
32749 (arg1)->Add(arg2,arg3);
32750 wxPyEndAllowThreads(__tstate);
32751 if (PyErr_Occurred()) SWIG_fail;
32752 }
32753 resultobj = SWIG_Py_Void();
32754 return resultobj;
32755 fail:
32756 return NULL;
32757 }
32758
32759
32760 SWIGINTERN PyObject *_wrap_DataObjectComposite_GetReceivedFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32761 PyObject *resultobj = 0;
32762 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
32763 SwigValueWrapper<wxDataFormat > result;
32764 void *argp1 = 0 ;
32765 int res1 = 0 ;
32766 PyObject *swig_obj[1] ;
32767
32768 if (!args) SWIG_fail;
32769 swig_obj[0] = args;
32770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
32771 if (!SWIG_IsOK(res1)) {
32772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_GetReceivedFormat" "', expected argument " "1"" of type '" "wxDataObjectComposite const *""'");
32773 }
32774 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
32775 {
32776 PyThreadState* __tstate = wxPyBeginAllowThreads();
32777 result = ((wxDataObjectComposite const *)arg1)->GetReceivedFormat();
32778 wxPyEndAllowThreads(__tstate);
32779 if (PyErr_Occurred()) SWIG_fail;
32780 }
32781 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
32782 return resultobj;
32783 fail:
32784 return NULL;
32785 }
32786
32787
32788 SWIGINTERN PyObject *DataObjectComposite_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32789 PyObject *obj;
32790 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32791 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectComposite, SWIG_NewClientData(obj));
32792 return SWIG_Py_Void();
32793 }
32794
32795 SWIGINTERN PyObject *DataObjectComposite_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32796 return SWIG_Python_InitShadowInstance(args);
32797 }
32798
32799 SWIGINTERN PyObject *_wrap_new_TextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32800 PyObject *resultobj = 0;
32801 wxString const &arg1_defvalue = wxPyEmptyString ;
32802 wxString *arg1 = (wxString *) &arg1_defvalue ;
32803 wxTextDataObject *result = 0 ;
32804 bool temp1 = false ;
32805 PyObject * obj0 = 0 ;
32806 char * kwnames[] = {
32807 (char *) "text", NULL
32808 };
32809
32810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) SWIG_fail;
32811 if (obj0) {
32812 {
32813 arg1 = wxString_in_helper(obj0);
32814 if (arg1 == NULL) SWIG_fail;
32815 temp1 = true;
32816 }
32817 }
32818 {
32819 PyThreadState* __tstate = wxPyBeginAllowThreads();
32820 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
32821 wxPyEndAllowThreads(__tstate);
32822 if (PyErr_Occurred()) SWIG_fail;
32823 }
32824 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_NEW | 0 );
32825 {
32826 if (temp1)
32827 delete arg1;
32828 }
32829 return resultobj;
32830 fail:
32831 {
32832 if (temp1)
32833 delete arg1;
32834 }
32835 return NULL;
32836 }
32837
32838
32839 SWIGINTERN PyObject *_wrap_TextDataObject_GetTextLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32840 PyObject *resultobj = 0;
32841 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32842 size_t result;
32843 void *argp1 = 0 ;
32844 int res1 = 0 ;
32845 PyObject *swig_obj[1] ;
32846
32847 if (!args) SWIG_fail;
32848 swig_obj[0] = args;
32849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32850 if (!SWIG_IsOK(res1)) {
32851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetTextLength" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32852 }
32853 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32854 {
32855 PyThreadState* __tstate = wxPyBeginAllowThreads();
32856 result = (size_t)(arg1)->GetTextLength();
32857 wxPyEndAllowThreads(__tstate);
32858 if (PyErr_Occurred()) SWIG_fail;
32859 }
32860 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32861 return resultobj;
32862 fail:
32863 return NULL;
32864 }
32865
32866
32867 SWIGINTERN PyObject *_wrap_TextDataObject_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32868 PyObject *resultobj = 0;
32869 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32870 wxString result;
32871 void *argp1 = 0 ;
32872 int res1 = 0 ;
32873 PyObject *swig_obj[1] ;
32874
32875 if (!args) SWIG_fail;
32876 swig_obj[0] = args;
32877 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32878 if (!SWIG_IsOK(res1)) {
32879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32880 }
32881 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32882 {
32883 PyThreadState* __tstate = wxPyBeginAllowThreads();
32884 result = (arg1)->GetText();
32885 wxPyEndAllowThreads(__tstate);
32886 if (PyErr_Occurred()) SWIG_fail;
32887 }
32888 {
32889 #if wxUSE_UNICODE
32890 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32891 #else
32892 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32893 #endif
32894 }
32895 return resultobj;
32896 fail:
32897 return NULL;
32898 }
32899
32900
32901 SWIGINTERN PyObject *_wrap_TextDataObject_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32902 PyObject *resultobj = 0;
32903 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32904 wxString *arg2 = 0 ;
32905 void *argp1 = 0 ;
32906 int res1 = 0 ;
32907 bool temp2 = false ;
32908 PyObject * obj0 = 0 ;
32909 PyObject * obj1 = 0 ;
32910 char * kwnames[] = {
32911 (char *) "self",(char *) "text", NULL
32912 };
32913
32914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
32915 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32916 if (!SWIG_IsOK(res1)) {
32917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_SetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32918 }
32919 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32920 {
32921 arg2 = wxString_in_helper(obj1);
32922 if (arg2 == NULL) SWIG_fail;
32923 temp2 = true;
32924 }
32925 {
32926 PyThreadState* __tstate = wxPyBeginAllowThreads();
32927 (arg1)->SetText((wxString const &)*arg2);
32928 wxPyEndAllowThreads(__tstate);
32929 if (PyErr_Occurred()) SWIG_fail;
32930 }
32931 resultobj = SWIG_Py_Void();
32932 {
32933 if (temp2)
32934 delete arg2;
32935 }
32936 return resultobj;
32937 fail:
32938 {
32939 if (temp2)
32940 delete arg2;
32941 }
32942 return NULL;
32943 }
32944
32945
32946 SWIGINTERN PyObject *TextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32947 PyObject *obj;
32948 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32949 SWIG_TypeNewClientData(SWIGTYPE_p_wxTextDataObject, SWIG_NewClientData(obj));
32950 return SWIG_Py_Void();
32951 }
32952
32953 SWIGINTERN PyObject *TextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32954 return SWIG_Python_InitShadowInstance(args);
32955 }
32956
32957 SWIGINTERN PyObject *_wrap_new_PyTextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32958 PyObject *resultobj = 0;
32959 wxString const &arg1_defvalue = wxPyEmptyString ;
32960 wxString *arg1 = (wxString *) &arg1_defvalue ;
32961 wxPyTextDataObject *result = 0 ;
32962 bool temp1 = false ;
32963 PyObject * obj0 = 0 ;
32964 char * kwnames[] = {
32965 (char *) "text", NULL
32966 };
32967
32968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) SWIG_fail;
32969 if (obj0) {
32970 {
32971 arg1 = wxString_in_helper(obj0);
32972 if (arg1 == NULL) SWIG_fail;
32973 temp1 = true;
32974 }
32975 }
32976 {
32977 PyThreadState* __tstate = wxPyBeginAllowThreads();
32978 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
32979 wxPyEndAllowThreads(__tstate);
32980 if (PyErr_Occurred()) SWIG_fail;
32981 }
32982 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_NEW | 0 );
32983 {
32984 if (temp1)
32985 delete arg1;
32986 }
32987 return resultobj;
32988 fail:
32989 {
32990 if (temp1)
32991 delete arg1;
32992 }
32993 return NULL;
32994 }
32995
32996
32997 SWIGINTERN PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32998 PyObject *resultobj = 0;
32999 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
33000 PyObject *arg2 = (PyObject *) 0 ;
33001 PyObject *arg3 = (PyObject *) 0 ;
33002 void *argp1 = 0 ;
33003 int res1 = 0 ;
33004 PyObject * obj0 = 0 ;
33005 PyObject * obj1 = 0 ;
33006 PyObject * obj2 = 0 ;
33007 char * kwnames[] = {
33008 (char *) "self",(char *) "self",(char *) "_class", NULL
33009 };
33010
33011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDataObject, 0 | 0 );
33013 if (!SWIG_IsOK(res1)) {
33014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTextDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDataObject *""'");
33015 }
33016 arg1 = reinterpret_cast< wxPyTextDataObject * >(argp1);
33017 arg2 = obj1;
33018 arg3 = obj2;
33019 {
33020 PyThreadState* __tstate = wxPyBeginAllowThreads();
33021 (arg1)->_setCallbackInfo(arg2,arg3);
33022 wxPyEndAllowThreads(__tstate);
33023 if (PyErr_Occurred()) SWIG_fail;
33024 }
33025 resultobj = SWIG_Py_Void();
33026 return resultobj;
33027 fail:
33028 return NULL;
33029 }
33030
33031
33032 SWIGINTERN PyObject *PyTextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33033 PyObject *obj;
33034 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33035 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDataObject, SWIG_NewClientData(obj));
33036 return SWIG_Py_Void();
33037 }
33038
33039 SWIGINTERN PyObject *PyTextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33040 return SWIG_Python_InitShadowInstance(args);
33041 }
33042
33043 SWIGINTERN PyObject *_wrap_new_BitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33044 PyObject *resultobj = 0;
33045 wxBitmap const &arg1_defvalue = wxNullBitmap ;
33046 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
33047 wxBitmapDataObject *result = 0 ;
33048 void *argp1 = 0 ;
33049 int res1 = 0 ;
33050 PyObject * obj0 = 0 ;
33051 char * kwnames[] = {
33052 (char *) "bitmap", NULL
33053 };
33054
33055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) SWIG_fail;
33056 if (obj0) {
33057 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
33058 if (!SWIG_IsOK(res1)) {
33059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
33060 }
33061 if (!argp1) {
33062 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
33063 }
33064 arg1 = reinterpret_cast< wxBitmap * >(argp1);
33065 }
33066 {
33067 PyThreadState* __tstate = wxPyBeginAllowThreads();
33068 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
33069 wxPyEndAllowThreads(__tstate);
33070 if (PyErr_Occurred()) SWIG_fail;
33071 }
33072 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_NEW | 0 );
33073 return resultobj;
33074 fail:
33075 return NULL;
33076 }
33077
33078
33079 SWIGINTERN PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33080 PyObject *resultobj = 0;
33081 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
33082 wxBitmap result;
33083 void *argp1 = 0 ;
33084 int res1 = 0 ;
33085 PyObject *swig_obj[1] ;
33086
33087 if (!args) SWIG_fail;
33088 swig_obj[0] = args;
33089 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
33090 if (!SWIG_IsOK(res1)) {
33091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_GetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject const *""'");
33092 }
33093 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
33094 {
33095 PyThreadState* __tstate = wxPyBeginAllowThreads();
33096 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
33097 wxPyEndAllowThreads(__tstate);
33098 if (PyErr_Occurred()) SWIG_fail;
33099 }
33100 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
33101 return resultobj;
33102 fail:
33103 return NULL;
33104 }
33105
33106
33107 SWIGINTERN PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33108 PyObject *resultobj = 0;
33109 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
33110 wxBitmap *arg2 = 0 ;
33111 void *argp1 = 0 ;
33112 int res1 = 0 ;
33113 void *argp2 = 0 ;
33114 int res2 = 0 ;
33115 PyObject * obj0 = 0 ;
33116 PyObject * obj1 = 0 ;
33117 char * kwnames[] = {
33118 (char *) "self",(char *) "bitmap", NULL
33119 };
33120
33121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
33122 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
33123 if (!SWIG_IsOK(res1)) {
33124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject *""'");
33125 }
33126 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
33127 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
33128 if (!SWIG_IsOK(res2)) {
33129 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
33130 }
33131 if (!argp2) {
33132 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
33133 }
33134 arg2 = reinterpret_cast< wxBitmap * >(argp2);
33135 {
33136 PyThreadState* __tstate = wxPyBeginAllowThreads();
33137 (arg1)->SetBitmap((wxBitmap const &)*arg2);
33138 wxPyEndAllowThreads(__tstate);
33139 if (PyErr_Occurred()) SWIG_fail;
33140 }
33141 resultobj = SWIG_Py_Void();
33142 return resultobj;
33143 fail:
33144 return NULL;
33145 }
33146
33147
33148 SWIGINTERN PyObject *BitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33149 PyObject *obj;
33150 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33151 SWIG_TypeNewClientData(SWIGTYPE_p_wxBitmapDataObject, SWIG_NewClientData(obj));
33152 return SWIG_Py_Void();
33153 }
33154
33155 SWIGINTERN PyObject *BitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33156 return SWIG_Python_InitShadowInstance(args);
33157 }
33158
33159 SWIGINTERN PyObject *_wrap_new_PyBitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33160 PyObject *resultobj = 0;
33161 wxBitmap const &arg1_defvalue = wxNullBitmap ;
33162 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
33163 wxPyBitmapDataObject *result = 0 ;
33164 void *argp1 = 0 ;
33165 int res1 = 0 ;
33166 PyObject * obj0 = 0 ;
33167 char * kwnames[] = {
33168 (char *) "bitmap", NULL
33169 };
33170
33171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) SWIG_fail;
33172 if (obj0) {
33173 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
33174 if (!SWIG_IsOK(res1)) {
33175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
33176 }
33177 if (!argp1) {
33178 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
33179 }
33180 arg1 = reinterpret_cast< wxBitmap * >(argp1);
33181 }
33182 {
33183 PyThreadState* __tstate = wxPyBeginAllowThreads();
33184 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
33185 wxPyEndAllowThreads(__tstate);
33186 if (PyErr_Occurred()) SWIG_fail;
33187 }
33188 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_NEW | 0 );
33189 return resultobj;
33190 fail:
33191 return NULL;
33192 }
33193
33194
33195 SWIGINTERN PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33196 PyObject *resultobj = 0;
33197 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
33198 PyObject *arg2 = (PyObject *) 0 ;
33199 PyObject *arg3 = (PyObject *) 0 ;
33200 void *argp1 = 0 ;
33201 int res1 = 0 ;
33202 PyObject * obj0 = 0 ;
33203 PyObject * obj1 = 0 ;
33204 PyObject * obj2 = 0 ;
33205 char * kwnames[] = {
33206 (char *) "self",(char *) "self",(char *) "_class", NULL
33207 };
33208
33209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyBitmapDataObject, 0 | 0 );
33211 if (!SWIG_IsOK(res1)) {
33212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyBitmapDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyBitmapDataObject *""'");
33213 }
33214 arg1 = reinterpret_cast< wxPyBitmapDataObject * >(argp1);
33215 arg2 = obj1;
33216 arg3 = obj2;
33217 {
33218 PyThreadState* __tstate = wxPyBeginAllowThreads();
33219 (arg1)->_setCallbackInfo(arg2,arg3);
33220 wxPyEndAllowThreads(__tstate);
33221 if (PyErr_Occurred()) SWIG_fail;
33222 }
33223 resultobj = SWIG_Py_Void();
33224 return resultobj;
33225 fail:
33226 return NULL;
33227 }
33228
33229
33230 SWIGINTERN PyObject *PyBitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33231 PyObject *obj;
33232 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33233 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyBitmapDataObject, SWIG_NewClientData(obj));
33234 return SWIG_Py_Void();
33235 }
33236
33237 SWIGINTERN PyObject *PyBitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33238 return SWIG_Python_InitShadowInstance(args);
33239 }
33240
33241 SWIGINTERN PyObject *_wrap_new_FileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33242 PyObject *resultobj = 0;
33243 wxFileDataObject *result = 0 ;
33244
33245 if (!SWIG_Python_UnpackTuple(args,"new_FileDataObject",0,0,0)) SWIG_fail;
33246 {
33247 PyThreadState* __tstate = wxPyBeginAllowThreads();
33248 result = (wxFileDataObject *)new wxFileDataObject();
33249 wxPyEndAllowThreads(__tstate);
33250 if (PyErr_Occurred()) SWIG_fail;
33251 }
33252 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_NEW | 0 );
33253 return resultobj;
33254 fail:
33255 return NULL;
33256 }
33257
33258
33259 SWIGINTERN PyObject *_wrap_FileDataObject_GetFilenames(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33260 PyObject *resultobj = 0;
33261 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
33262 wxArrayString *result = 0 ;
33263 void *argp1 = 0 ;
33264 int res1 = 0 ;
33265 PyObject *swig_obj[1] ;
33266
33267 if (!args) SWIG_fail;
33268 swig_obj[0] = args;
33269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
33270 if (!SWIG_IsOK(res1)) {
33271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_GetFilenames" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
33272 }
33273 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
33274 {
33275 PyThreadState* __tstate = wxPyBeginAllowThreads();
33276 {
33277 wxArrayString const &_result_ref = (arg1)->GetFilenames();
33278 result = (wxArrayString *) &_result_ref;
33279 }
33280 wxPyEndAllowThreads(__tstate);
33281 if (PyErr_Occurred()) SWIG_fail;
33282 }
33283 {
33284 resultobj = wxArrayString2PyList_helper(*result);
33285 }
33286 return resultobj;
33287 fail:
33288 return NULL;
33289 }
33290
33291
33292 SWIGINTERN PyObject *_wrap_FileDataObject_AddFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33293 PyObject *resultobj = 0;
33294 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
33295 wxString *arg2 = 0 ;
33296 void *argp1 = 0 ;
33297 int res1 = 0 ;
33298 bool temp2 = false ;
33299 PyObject * obj0 = 0 ;
33300 PyObject * obj1 = 0 ;
33301 char * kwnames[] = {
33302 (char *) "self",(char *) "filename", NULL
33303 };
33304
33305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) SWIG_fail;
33306 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
33307 if (!SWIG_IsOK(res1)) {
33308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_AddFile" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
33309 }
33310 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
33311 {
33312 arg2 = wxString_in_helper(obj1);
33313 if (arg2 == NULL) SWIG_fail;
33314 temp2 = true;
33315 }
33316 {
33317 PyThreadState* __tstate = wxPyBeginAllowThreads();
33318 (arg1)->AddFile((wxString const &)*arg2);
33319 wxPyEndAllowThreads(__tstate);
33320 if (PyErr_Occurred()) SWIG_fail;
33321 }
33322 resultobj = SWIG_Py_Void();
33323 {
33324 if (temp2)
33325 delete arg2;
33326 }
33327 return resultobj;
33328 fail:
33329 {
33330 if (temp2)
33331 delete arg2;
33332 }
33333 return NULL;
33334 }
33335
33336
33337 SWIGINTERN PyObject *FileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33338 PyObject *obj;
33339 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33340 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileDataObject, SWIG_NewClientData(obj));
33341 return SWIG_Py_Void();
33342 }
33343
33344 SWIGINTERN PyObject *FileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33345 return SWIG_Python_InitShadowInstance(args);
33346 }
33347
33348 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
33349 PyObject *resultobj = 0;
33350 wxDataFormat *arg1 = 0 ;
33351 wxCustomDataObject *result = 0 ;
33352 void *argp1 = 0 ;
33353 int res1 = 0 ;
33354
33355 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
33356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
33357 if (!SWIG_IsOK(res1)) {
33358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
33359 }
33360 if (!argp1) {
33361 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
33362 }
33363 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
33364 {
33365 PyThreadState* __tstate = wxPyBeginAllowThreads();
33366 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
33367 wxPyEndAllowThreads(__tstate);
33368 if (PyErr_Occurred()) SWIG_fail;
33369 }
33370 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33371 return resultobj;
33372 fail:
33373 return NULL;
33374 }
33375
33376
33377 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
33378 PyObject *resultobj = 0;
33379 wxString *arg1 = 0 ;
33380 wxCustomDataObject *result = 0 ;
33381 bool temp1 = false ;
33382
33383 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
33384 {
33385 arg1 = wxString_in_helper(swig_obj[0]);
33386 if (arg1 == NULL) SWIG_fail;
33387 temp1 = true;
33388 }
33389 {
33390 PyThreadState* __tstate = wxPyBeginAllowThreads();
33391 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
33392 wxPyEndAllowThreads(__tstate);
33393 if (PyErr_Occurred()) SWIG_fail;
33394 }
33395 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33396 {
33397 if (temp1)
33398 delete arg1;
33399 }
33400 return resultobj;
33401 fail:
33402 {
33403 if (temp1)
33404 delete arg1;
33405 }
33406 return NULL;
33407 }
33408
33409
33410 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
33411 PyObject *resultobj = 0;
33412 wxCustomDataObject *result = 0 ;
33413
33414 if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
33415 {
33416 PyThreadState* __tstate = wxPyBeginAllowThreads();
33417 result = (wxCustomDataObject *)new wxCustomDataObject();
33418 wxPyEndAllowThreads(__tstate);
33419 if (PyErr_Occurred()) SWIG_fail;
33420 }
33421 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33422 return resultobj;
33423 fail:
33424 return NULL;
33425 }
33426
33427
33428 SWIGINTERN PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
33429 int argc;
33430 PyObject *argv[2];
33431
33432 if (!(argc = SWIG_Python_UnpackTuple(args,"new_CustomDataObject",0,1,argv))) SWIG_fail;
33433 --argc;
33434 if (argc == 0) {
33435 return _wrap_new_CustomDataObject__SWIG_2(self, argc, argv);
33436 }
33437 if (argc == 1) {
33438 int _v = 0;
33439 {
33440 {
33441 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
33442 }
33443 }
33444 if (!_v) goto check_2;
33445 return _wrap_new_CustomDataObject__SWIG_1(self, argc, argv);
33446 }
33447 check_2:
33448
33449 if (argc == 1) {
33450 return _wrap_new_CustomDataObject__SWIG_0(self, argc, argv);
33451 }
33452
33453 fail:
33454 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
33455 return NULL;
33456 }
33457
33458
33459 SWIGINTERN PyObject *_wrap_CustomDataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33460 PyObject *resultobj = 0;
33461 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33462 PyObject *arg2 = (PyObject *) 0 ;
33463 bool result;
33464 void *argp1 = 0 ;
33465 int res1 = 0 ;
33466 PyObject * obj0 = 0 ;
33467 PyObject * obj1 = 0 ;
33468 char * kwnames[] = {
33469 (char *) "self",(char *) "data", NULL
33470 };
33471
33472 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
33473 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33474 if (!SWIG_IsOK(res1)) {
33475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_SetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33476 }
33477 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33478 arg2 = obj1;
33479 {
33480 PyThreadState* __tstate = wxPyBeginAllowThreads();
33481 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
33482 wxPyEndAllowThreads(__tstate);
33483 if (PyErr_Occurred()) SWIG_fail;
33484 }
33485 {
33486 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33487 }
33488 return resultobj;
33489 fail:
33490 return NULL;
33491 }
33492
33493
33494 SWIGINTERN PyObject *_wrap_CustomDataObject_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33495 PyObject *resultobj = 0;
33496 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33497 size_t result;
33498 void *argp1 = 0 ;
33499 int res1 = 0 ;
33500 PyObject *swig_obj[1] ;
33501
33502 if (!args) SWIG_fail;
33503 swig_obj[0] = args;
33504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33505 if (!SWIG_IsOK(res1)) {
33506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetSize" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33507 }
33508 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33509 {
33510 PyThreadState* __tstate = wxPyBeginAllowThreads();
33511 result = (size_t)(arg1)->GetSize();
33512 wxPyEndAllowThreads(__tstate);
33513 if (PyErr_Occurred()) SWIG_fail;
33514 }
33515 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
33516 return resultobj;
33517 fail:
33518 return NULL;
33519 }
33520
33521
33522 SWIGINTERN PyObject *_wrap_CustomDataObject_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33523 PyObject *resultobj = 0;
33524 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33525 PyObject *result = 0 ;
33526 void *argp1 = 0 ;
33527 int res1 = 0 ;
33528 PyObject *swig_obj[1] ;
33529
33530 if (!args) SWIG_fail;
33531 swig_obj[0] = args;
33532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33533 if (!SWIG_IsOK(res1)) {
33534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33535 }
33536 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33537 {
33538 PyThreadState* __tstate = wxPyBeginAllowThreads();
33539 result = (PyObject *)wxCustomDataObject_GetData(arg1);
33540 wxPyEndAllowThreads(__tstate);
33541 if (PyErr_Occurred()) SWIG_fail;
33542 }
33543 resultobj = result;
33544 return resultobj;
33545 fail:
33546 return NULL;
33547 }
33548
33549
33550 SWIGINTERN PyObject *CustomDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33551 PyObject *obj;
33552 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33553 SWIG_TypeNewClientData(SWIGTYPE_p_wxCustomDataObject, SWIG_NewClientData(obj));
33554 return SWIG_Py_Void();
33555 }
33556
33557 SWIGINTERN PyObject *CustomDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33558 return SWIG_Python_InitShadowInstance(args);
33559 }
33560
33561 SWIGINTERN PyObject *_wrap_new_URLDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33562 PyObject *resultobj = 0;
33563 wxString const &arg1_defvalue = wxPyEmptyString ;
33564 wxString *arg1 = (wxString *) &arg1_defvalue ;
33565 wxURLDataObject *result = 0 ;
33566 bool temp1 = false ;
33567 PyObject * obj0 = 0 ;
33568 char * kwnames[] = {
33569 (char *) "url", NULL
33570 };
33571
33572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_URLDataObject",kwnames,&obj0)) SWIG_fail;
33573 if (obj0) {
33574 {
33575 arg1 = wxString_in_helper(obj0);
33576 if (arg1 == NULL) SWIG_fail;
33577 temp1 = true;
33578 }
33579 }
33580 {
33581 PyThreadState* __tstate = wxPyBeginAllowThreads();
33582 result = (wxURLDataObject *)new wxURLDataObject((wxString const &)*arg1);
33583 wxPyEndAllowThreads(__tstate);
33584 if (PyErr_Occurred()) SWIG_fail;
33585 }
33586 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_NEW | 0 );
33587 {
33588 if (temp1)
33589 delete arg1;
33590 }
33591 return resultobj;
33592 fail:
33593 {
33594 if (temp1)
33595 delete arg1;
33596 }
33597 return NULL;
33598 }
33599
33600
33601 SWIGINTERN PyObject *_wrap_URLDataObject_GetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33602 PyObject *resultobj = 0;
33603 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
33604 wxString result;
33605 void *argp1 = 0 ;
33606 int res1 = 0 ;
33607 PyObject *swig_obj[1] ;
33608
33609 if (!args) SWIG_fail;
33610 swig_obj[0] = args;
33611 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
33612 if (!SWIG_IsOK(res1)) {
33613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_GetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
33614 }
33615 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
33616 {
33617 PyThreadState* __tstate = wxPyBeginAllowThreads();
33618 result = (arg1)->GetURL();
33619 wxPyEndAllowThreads(__tstate);
33620 if (PyErr_Occurred()) SWIG_fail;
33621 }
33622 {
33623 #if wxUSE_UNICODE
33624 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33625 #else
33626 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33627 #endif
33628 }
33629 return resultobj;
33630 fail:
33631 return NULL;
33632 }
33633
33634
33635 SWIGINTERN PyObject *_wrap_URLDataObject_SetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33636 PyObject *resultobj = 0;
33637 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
33638 wxString *arg2 = 0 ;
33639 void *argp1 = 0 ;
33640 int res1 = 0 ;
33641 bool temp2 = false ;
33642 PyObject * obj0 = 0 ;
33643 PyObject * obj1 = 0 ;
33644 char * kwnames[] = {
33645 (char *) "self",(char *) "url", NULL
33646 };
33647
33648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) SWIG_fail;
33649 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
33650 if (!SWIG_IsOK(res1)) {
33651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_SetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
33652 }
33653 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
33654 {
33655 arg2 = wxString_in_helper(obj1);
33656 if (arg2 == NULL) SWIG_fail;
33657 temp2 = true;
33658 }
33659 {
33660 PyThreadState* __tstate = wxPyBeginAllowThreads();
33661 (arg1)->SetURL((wxString const &)*arg2);
33662 wxPyEndAllowThreads(__tstate);
33663 if (PyErr_Occurred()) SWIG_fail;
33664 }
33665 resultobj = SWIG_Py_Void();
33666 {
33667 if (temp2)
33668 delete arg2;
33669 }
33670 return resultobj;
33671 fail:
33672 {
33673 if (temp2)
33674 delete arg2;
33675 }
33676 return NULL;
33677 }
33678
33679
33680 SWIGINTERN PyObject *URLDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33681 PyObject *obj;
33682 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33683 SWIG_TypeNewClientData(SWIGTYPE_p_wxURLDataObject, SWIG_NewClientData(obj));
33684 return SWIG_Py_Void();
33685 }
33686
33687 SWIGINTERN PyObject *URLDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33688 return SWIG_Python_InitShadowInstance(args);
33689 }
33690
33691 SWIGINTERN PyObject *_wrap_new_MetafileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33692 PyObject *resultobj = 0;
33693 wxMetafileDataObject *result = 0 ;
33694
33695 if (!SWIG_Python_UnpackTuple(args,"new_MetafileDataObject",0,0,0)) SWIG_fail;
33696 {
33697 PyThreadState* __tstate = wxPyBeginAllowThreads();
33698 result = (wxMetafileDataObject *)new wxMetafileDataObject();
33699 wxPyEndAllowThreads(__tstate);
33700 if (PyErr_Occurred()) SWIG_fail;
33701 }
33702 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_NEW | 0 );
33703 return resultobj;
33704 fail:
33705 return NULL;
33706 }
33707
33708
33709 SWIGINTERN PyObject *MetafileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33710 PyObject *obj;
33711 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33712 SWIG_TypeNewClientData(SWIGTYPE_p_wxMetafileDataObject, SWIG_NewClientData(obj));
33713 return SWIG_Py_Void();
33714 }
33715
33716 SWIGINTERN PyObject *MetafileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33717 return SWIG_Python_InitShadowInstance(args);
33718 }
33719
33720 SWIGINTERN PyObject *_wrap_IsDragResultOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33721 PyObject *resultobj = 0;
33722 wxDragResult arg1 ;
33723 bool result;
33724 int val1 ;
33725 int ecode1 = 0 ;
33726 PyObject * obj0 = 0 ;
33727 char * kwnames[] = {
33728 (char *) "res", NULL
33729 };
33730
33731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) SWIG_fail;
33732 ecode1 = SWIG_AsVal_int(obj0, &val1);
33733 if (!SWIG_IsOK(ecode1)) {
33734 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsDragResultOk" "', expected argument " "1"" of type '" "wxDragResult""'");
33735 }
33736 arg1 = static_cast< wxDragResult >(val1);
33737 {
33738 PyThreadState* __tstate = wxPyBeginAllowThreads();
33739 result = (bool)wxIsDragResultOk(arg1);
33740 wxPyEndAllowThreads(__tstate);
33741 if (PyErr_Occurred()) SWIG_fail;
33742 }
33743 {
33744 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33745 }
33746 return resultobj;
33747 fail:
33748 return NULL;
33749 }
33750
33751
33752 SWIGINTERN PyObject *_wrap_new_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33753 PyObject *resultobj = 0;
33754 wxWindow *arg1 = (wxWindow *) 0 ;
33755 wxIcon const &arg2_defvalue = wxNullIcon ;
33756 wxIcon *arg2 = (wxIcon *) &arg2_defvalue ;
33757 wxIcon const &arg3_defvalue = wxNullIcon ;
33758 wxIcon *arg3 = (wxIcon *) &arg3_defvalue ;
33759 wxIcon const &arg4_defvalue = wxNullIcon ;
33760 wxIcon *arg4 = (wxIcon *) &arg4_defvalue ;
33761 wxPyDropSource *result = 0 ;
33762 void *argp1 = 0 ;
33763 int res1 = 0 ;
33764 void *argp2 = 0 ;
33765 int res2 = 0 ;
33766 void *argp3 = 0 ;
33767 int res3 = 0 ;
33768 void *argp4 = 0 ;
33769 int res4 = 0 ;
33770 PyObject * obj0 = 0 ;
33771 PyObject * obj1 = 0 ;
33772 PyObject * obj2 = 0 ;
33773 PyObject * obj3 = 0 ;
33774 char * kwnames[] = {
33775 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
33776 };
33777
33778 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33779 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33780 if (!SWIG_IsOK(res1)) {
33781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropSource" "', expected argument " "1"" of type '" "wxWindow *""'");
33782 }
33783 arg1 = reinterpret_cast< wxWindow * >(argp1);
33784 if (obj1) {
33785 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxIcon, 0 | 0);
33786 if (!SWIG_IsOK(res2)) {
33787 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxIcon const &""'");
33788 }
33789 if (!argp2) {
33790 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxIcon const &""'");
33791 }
33792 arg2 = reinterpret_cast< wxIcon * >(argp2);
33793 }
33794 if (obj2) {
33795 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIcon, 0 | 0);
33796 if (!SWIG_IsOK(res3)) {
33797 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxIcon const &""'");
33798 }
33799 if (!argp3) {
33800 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxIcon const &""'");
33801 }
33802 arg3 = reinterpret_cast< wxIcon * >(argp3);
33803 }
33804 if (obj3) {
33805 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxIcon, 0 | 0);
33806 if (!SWIG_IsOK(res4)) {
33807 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxIcon const &""'");
33808 }
33809 if (!argp4) {
33810 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxIcon const &""'");
33811 }
33812 arg4 = reinterpret_cast< wxIcon * >(argp4);
33813 }
33814 {
33815 PyThreadState* __tstate = wxPyBeginAllowThreads();
33816 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxIcon const &)*arg2,(wxIcon const &)*arg3,(wxIcon const &)*arg4);
33817 wxPyEndAllowThreads(__tstate);
33818 if (PyErr_Occurred()) SWIG_fail;
33819 }
33820 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_NEW | 0 );
33821 return resultobj;
33822 fail:
33823 return NULL;
33824 }
33825
33826
33827 SWIGINTERN PyObject *_wrap_DropSource__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33828 PyObject *resultobj = 0;
33829 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33830 PyObject *arg2 = (PyObject *) 0 ;
33831 PyObject *arg3 = (PyObject *) 0 ;
33832 int arg4 = (int) 0 ;
33833 void *argp1 = 0 ;
33834 int res1 = 0 ;
33835 int val4 ;
33836 int ecode4 = 0 ;
33837 PyObject * obj0 = 0 ;
33838 PyObject * obj1 = 0 ;
33839 PyObject * obj2 = 0 ;
33840 PyObject * obj3 = 0 ;
33841 char * kwnames[] = {
33842 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
33843 };
33844
33845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33846 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33847 if (!SWIG_IsOK(res1)) {
33848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33849 }
33850 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33851 arg2 = obj1;
33852 arg3 = obj2;
33853 if (obj3) {
33854 ecode4 = SWIG_AsVal_int(obj3, &val4);
33855 if (!SWIG_IsOK(ecode4)) {
33856 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropSource__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
33857 }
33858 arg4 = static_cast< int >(val4);
33859 }
33860 {
33861 PyThreadState* __tstate = wxPyBeginAllowThreads();
33862 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
33863 wxPyEndAllowThreads(__tstate);
33864 if (PyErr_Occurred()) SWIG_fail;
33865 }
33866 resultobj = SWIG_Py_Void();
33867 return resultobj;
33868 fail:
33869 return NULL;
33870 }
33871
33872
33873 SWIGINTERN PyObject *_wrap_delete_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33874 PyObject *resultobj = 0;
33875 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33876 void *argp1 = 0 ;
33877 int res1 = 0 ;
33878 PyObject *swig_obj[1] ;
33879
33880 if (!args) SWIG_fail;
33881 swig_obj[0] = args;
33882 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_DISOWN | 0 );
33883 if (!SWIG_IsOK(res1)) {
33884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropSource" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33885 }
33886 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33887 {
33888 PyThreadState* __tstate = wxPyBeginAllowThreads();
33889 delete arg1;
33890
33891 wxPyEndAllowThreads(__tstate);
33892 if (PyErr_Occurred()) SWIG_fail;
33893 }
33894 resultobj = SWIG_Py_Void();
33895 return resultobj;
33896 fail:
33897 return NULL;
33898 }
33899
33900
33901 SWIGINTERN PyObject *_wrap_DropSource_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33902 PyObject *resultobj = 0;
33903 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33904 wxDataObject *arg2 = 0 ;
33905 void *argp1 = 0 ;
33906 int res1 = 0 ;
33907 void *argp2 = 0 ;
33908 int res2 = 0 ;
33909 PyObject * obj0 = 0 ;
33910 PyObject * obj1 = 0 ;
33911 char * kwnames[] = {
33912 (char *) "self",(char *) "data", NULL
33913 };
33914
33915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
33916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33917 if (!SWIG_IsOK(res1)) {
33918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetData" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33919 }
33920 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33921 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
33922 if (!SWIG_IsOK(res2)) {
33923 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
33924 }
33925 if (!argp2) {
33926 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
33927 }
33928 arg2 = reinterpret_cast< wxDataObject * >(argp2);
33929 {
33930 PyThreadState* __tstate = wxPyBeginAllowThreads();
33931 (arg1)->SetData(*arg2);
33932 wxPyEndAllowThreads(__tstate);
33933 if (PyErr_Occurred()) SWIG_fail;
33934 }
33935 resultobj = SWIG_Py_Void();
33936 return resultobj;
33937 fail:
33938 return NULL;
33939 }
33940
33941
33942 SWIGINTERN PyObject *_wrap_DropSource_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33943 PyObject *resultobj = 0;
33944 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33945 wxDataObject *result = 0 ;
33946 void *argp1 = 0 ;
33947 int res1 = 0 ;
33948 PyObject *swig_obj[1] ;
33949
33950 if (!args) SWIG_fail;
33951 swig_obj[0] = args;
33952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33953 if (!SWIG_IsOK(res1)) {
33954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33955 }
33956 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33957 {
33958 PyThreadState* __tstate = wxPyBeginAllowThreads();
33959 result = (wxDataObject *)(arg1)->GetDataObject();
33960 wxPyEndAllowThreads(__tstate);
33961 if (PyErr_Occurred()) SWIG_fail;
33962 }
33963 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
33964 return resultobj;
33965 fail:
33966 return NULL;
33967 }
33968
33969
33970 SWIGINTERN PyObject *_wrap_DropSource_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33971 PyObject *resultobj = 0;
33972 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33973 wxDragResult arg2 ;
33974 wxCursor *arg3 = 0 ;
33975 void *argp1 = 0 ;
33976 int res1 = 0 ;
33977 int val2 ;
33978 int ecode2 = 0 ;
33979 void *argp3 = 0 ;
33980 int res3 = 0 ;
33981 PyObject * obj0 = 0 ;
33982 PyObject * obj1 = 0 ;
33983 PyObject * obj2 = 0 ;
33984 char * kwnames[] = {
33985 (char *) "self",(char *) "res",(char *) "cursor", NULL
33986 };
33987
33988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33989 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33990 if (!SWIG_IsOK(res1)) {
33991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetCursor" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33992 }
33993 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33994 ecode2 = SWIG_AsVal_int(obj1, &val2);
33995 if (!SWIG_IsOK(ecode2)) {
33996 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_SetCursor" "', expected argument " "2"" of type '" "wxDragResult""'");
33997 }
33998 arg2 = static_cast< wxDragResult >(val2);
33999 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxCursor, 0 | 0);
34000 if (!SWIG_IsOK(res3)) {
34001 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
34002 }
34003 if (!argp3) {
34004 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
34005 }
34006 arg3 = reinterpret_cast< wxCursor * >(argp3);
34007 {
34008 PyThreadState* __tstate = wxPyBeginAllowThreads();
34009 (arg1)->SetCursor(arg2,(wxCursor const &)*arg3);
34010 wxPyEndAllowThreads(__tstate);
34011 if (PyErr_Occurred()) SWIG_fail;
34012 }
34013 resultobj = SWIG_Py_Void();
34014 return resultobj;
34015 fail:
34016 return NULL;
34017 }
34018
34019
34020 SWIGINTERN PyObject *_wrap_DropSource_DoDragDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34021 PyObject *resultobj = 0;
34022 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
34023 int arg2 = (int) wxDrag_CopyOnly ;
34024 wxDragResult result;
34025 void *argp1 = 0 ;
34026 int res1 = 0 ;
34027 int val2 ;
34028 int ecode2 = 0 ;
34029 PyObject * obj0 = 0 ;
34030 PyObject * obj1 = 0 ;
34031 char * kwnames[] = {
34032 (char *) "self",(char *) "flags", NULL
34033 };
34034
34035 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) SWIG_fail;
34036 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
34037 if (!SWIG_IsOK(res1)) {
34038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_DoDragDrop" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
34039 }
34040 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
34041 if (obj1) {
34042 ecode2 = SWIG_AsVal_int(obj1, &val2);
34043 if (!SWIG_IsOK(ecode2)) {
34044 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_DoDragDrop" "', expected argument " "2"" of type '" "int""'");
34045 }
34046 arg2 = static_cast< int >(val2);
34047 }
34048 {
34049 PyThreadState* __tstate = wxPyBeginAllowThreads();
34050 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
34051 wxPyEndAllowThreads(__tstate);
34052 if (PyErr_Occurred()) SWIG_fail;
34053 }
34054 resultobj = SWIG_From_int(static_cast< int >(result));
34055 return resultobj;
34056 fail:
34057 return NULL;
34058 }
34059
34060
34061 SWIGINTERN PyObject *_wrap_DropSource_GiveFeedback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34062 PyObject *resultobj = 0;
34063 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
34064 wxDragResult arg2 ;
34065 bool result;
34066 void *argp1 = 0 ;
34067 int res1 = 0 ;
34068 int val2 ;
34069 int ecode2 = 0 ;
34070 PyObject * obj0 = 0 ;
34071 PyObject * obj1 = 0 ;
34072 char * kwnames[] = {
34073 (char *) "self",(char *) "effect", NULL
34074 };
34075
34076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_GiveFeedback",kwnames,&obj0,&obj1)) SWIG_fail;
34077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
34078 if (!SWIG_IsOK(res1)) {
34079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GiveFeedback" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
34080 }
34081 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
34082 ecode2 = SWIG_AsVal_int(obj1, &val2);
34083 if (!SWIG_IsOK(ecode2)) {
34084 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_GiveFeedback" "', expected argument " "2"" of type '" "wxDragResult""'");
34085 }
34086 arg2 = static_cast< wxDragResult >(val2);
34087 {
34088 PyThreadState* __tstate = wxPyBeginAllowThreads();
34089 result = (bool)(arg1)->GiveFeedback(arg2);
34090 wxPyEndAllowThreads(__tstate);
34091 if (PyErr_Occurred()) SWIG_fail;
34092 }
34093 {
34094 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34095 }
34096 return resultobj;
34097 fail:
34098 return NULL;
34099 }
34100
34101
34102 SWIGINTERN PyObject *DropSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34103 PyObject *obj;
34104 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34105 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropSource, SWIG_NewClientData(obj));
34106 return SWIG_Py_Void();
34107 }
34108
34109 SWIGINTERN PyObject *DropSource_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34110 return SWIG_Python_InitShadowInstance(args);
34111 }
34112
34113 SWIGINTERN PyObject *_wrap_new_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34114 PyObject *resultobj = 0;
34115 wxDataObject *arg1 = (wxDataObject *) NULL ;
34116 wxPyDropTarget *result = 0 ;
34117 int res1 = 0 ;
34118 PyObject * obj0 = 0 ;
34119 char * kwnames[] = {
34120 (char *) "dataObject", NULL
34121 };
34122
34123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) SWIG_fail;
34124 if (obj0) {
34125 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34126 if (!SWIG_IsOK(res1)) {
34127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropTarget" "', expected argument " "1"" of type '" "wxDataObject *""'");
34128 }
34129 }
34130 {
34131 PyThreadState* __tstate = wxPyBeginAllowThreads();
34132 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
34133 wxPyEndAllowThreads(__tstate);
34134 if (PyErr_Occurred()) SWIG_fail;
34135 }
34136 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_NEW | 0 );
34137 return resultobj;
34138 fail:
34139 return NULL;
34140 }
34141
34142
34143 SWIGINTERN PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34144 PyObject *resultobj = 0;
34145 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34146 PyObject *arg2 = (PyObject *) 0 ;
34147 PyObject *arg3 = (PyObject *) 0 ;
34148 void *argp1 = 0 ;
34149 int res1 = 0 ;
34150 PyObject * obj0 = 0 ;
34151 PyObject * obj1 = 0 ;
34152 PyObject * obj2 = 0 ;
34153 char * kwnames[] = {
34154 (char *) "self",(char *) "self",(char *) "_class", NULL
34155 };
34156
34157 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34158 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34159 if (!SWIG_IsOK(res1)) {
34160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34161 }
34162 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34163 arg2 = obj1;
34164 arg3 = obj2;
34165 {
34166 PyThreadState* __tstate = wxPyBeginAllowThreads();
34167 (arg1)->_setCallbackInfo(arg2,arg3);
34168 wxPyEndAllowThreads(__tstate);
34169 if (PyErr_Occurred()) SWIG_fail;
34170 }
34171 resultobj = SWIG_Py_Void();
34172 return resultobj;
34173 fail:
34174 return NULL;
34175 }
34176
34177
34178 SWIGINTERN PyObject *_wrap_delete_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34179 PyObject *resultobj = 0;
34180 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34181 void *argp1 = 0 ;
34182 int res1 = 0 ;
34183 PyObject *swig_obj[1] ;
34184
34185 if (!args) SWIG_fail;
34186 swig_obj[0] = args;
34187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
34188 if (!SWIG_IsOK(res1)) {
34189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropTarget" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34190 }
34191 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34192 {
34193 PyThreadState* __tstate = wxPyBeginAllowThreads();
34194 delete arg1;
34195
34196 wxPyEndAllowThreads(__tstate);
34197 if (PyErr_Occurred()) SWIG_fail;
34198 }
34199 resultobj = SWIG_Py_Void();
34200 return resultobj;
34201 fail:
34202 return NULL;
34203 }
34204
34205
34206 SWIGINTERN PyObject *_wrap_DropTarget_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34207 PyObject *resultobj = 0;
34208 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34209 wxDataObject *result = 0 ;
34210 void *argp1 = 0 ;
34211 int res1 = 0 ;
34212 PyObject *swig_obj[1] ;
34213
34214 if (!args) SWIG_fail;
34215 swig_obj[0] = args;
34216 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34217 if (!SWIG_IsOK(res1)) {
34218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34219 }
34220 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34221 {
34222 PyThreadState* __tstate = wxPyBeginAllowThreads();
34223 result = (wxDataObject *)(arg1)->GetDataObject();
34224 wxPyEndAllowThreads(__tstate);
34225 if (PyErr_Occurred()) SWIG_fail;
34226 }
34227 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
34228 return resultobj;
34229 fail:
34230 return NULL;
34231 }
34232
34233
34234 SWIGINTERN PyObject *_wrap_DropTarget_SetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34235 PyObject *resultobj = 0;
34236 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34237 wxDataObject *arg2 = (wxDataObject *) 0 ;
34238 void *argp1 = 0 ;
34239 int res1 = 0 ;
34240 int res2 = 0 ;
34241 PyObject * obj0 = 0 ;
34242 PyObject * obj1 = 0 ;
34243 char * kwnames[] = {
34244 (char *) "self",(char *) "dataObject", NULL
34245 };
34246
34247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) SWIG_fail;
34248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34249 if (!SWIG_IsOK(res1)) {
34250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34251 }
34252 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34253 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34254 if (!SWIG_IsOK(res2)) {
34255 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropTarget_SetDataObject" "', expected argument " "2"" of type '" "wxDataObject *""'");
34256 }
34257 {
34258 PyThreadState* __tstate = wxPyBeginAllowThreads();
34259 (arg1)->SetDataObject(arg2);
34260 wxPyEndAllowThreads(__tstate);
34261 if (PyErr_Occurred()) SWIG_fail;
34262 }
34263 resultobj = SWIG_Py_Void();
34264 return resultobj;
34265 fail:
34266 return NULL;
34267 }
34268
34269
34270 SWIGINTERN PyObject *_wrap_DropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34271 PyObject *resultobj = 0;
34272 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34273 int arg2 ;
34274 int arg3 ;
34275 wxDragResult arg4 ;
34276 wxDragResult result;
34277 void *argp1 = 0 ;
34278 int res1 = 0 ;
34279 int val2 ;
34280 int ecode2 = 0 ;
34281 int val3 ;
34282 int ecode3 = 0 ;
34283 int val4 ;
34284 int ecode4 = 0 ;
34285 PyObject * obj0 = 0 ;
34286 PyObject * obj1 = 0 ;
34287 PyObject * obj2 = 0 ;
34288 PyObject * obj3 = 0 ;
34289 char * kwnames[] = {
34290 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34291 };
34292
34293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34294 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34295 if (!SWIG_IsOK(res1)) {
34296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34297 }
34298 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34299 ecode2 = SWIG_AsVal_int(obj1, &val2);
34300 if (!SWIG_IsOK(ecode2)) {
34301 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
34302 }
34303 arg2 = static_cast< int >(val2);
34304 ecode3 = SWIG_AsVal_int(obj2, &val3);
34305 if (!SWIG_IsOK(ecode3)) {
34306 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
34307 }
34308 arg3 = static_cast< int >(val3);
34309 ecode4 = SWIG_AsVal_int(obj3, &val4);
34310 if (!SWIG_IsOK(ecode4)) {
34311 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
34312 }
34313 arg4 = static_cast< wxDragResult >(val4);
34314 {
34315 PyThreadState* __tstate = wxPyBeginAllowThreads();
34316 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
34317 wxPyEndAllowThreads(__tstate);
34318 if (PyErr_Occurred()) SWIG_fail;
34319 }
34320 resultobj = SWIG_From_int(static_cast< int >(result));
34321 return resultobj;
34322 fail:
34323 return NULL;
34324 }
34325
34326
34327 SWIGINTERN PyObject *_wrap_DropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34328 PyObject *resultobj = 0;
34329 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34330 int arg2 ;
34331 int arg3 ;
34332 wxDragResult arg4 ;
34333 wxDragResult result;
34334 void *argp1 = 0 ;
34335 int res1 = 0 ;
34336 int val2 ;
34337 int ecode2 = 0 ;
34338 int val3 ;
34339 int ecode3 = 0 ;
34340 int val4 ;
34341 int ecode4 = 0 ;
34342 PyObject * obj0 = 0 ;
34343 PyObject * obj1 = 0 ;
34344 PyObject * obj2 = 0 ;
34345 PyObject * obj3 = 0 ;
34346 char * kwnames[] = {
34347 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34348 };
34349
34350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34351 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34352 if (!SWIG_IsOK(res1)) {
34353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34354 }
34355 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34356 ecode2 = SWIG_AsVal_int(obj1, &val2);
34357 if (!SWIG_IsOK(ecode2)) {
34358 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
34359 }
34360 arg2 = static_cast< int >(val2);
34361 ecode3 = SWIG_AsVal_int(obj2, &val3);
34362 if (!SWIG_IsOK(ecode3)) {
34363 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
34364 }
34365 arg3 = static_cast< int >(val3);
34366 ecode4 = SWIG_AsVal_int(obj3, &val4);
34367 if (!SWIG_IsOK(ecode4)) {
34368 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
34369 }
34370 arg4 = static_cast< wxDragResult >(val4);
34371 {
34372 PyThreadState* __tstate = wxPyBeginAllowThreads();
34373 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
34374 wxPyEndAllowThreads(__tstate);
34375 if (PyErr_Occurred()) SWIG_fail;
34376 }
34377 resultobj = SWIG_From_int(static_cast< int >(result));
34378 return resultobj;
34379 fail:
34380 return NULL;
34381 }
34382
34383
34384 SWIGINTERN PyObject *_wrap_DropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34385 PyObject *resultobj = 0;
34386 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34387 void *argp1 = 0 ;
34388 int res1 = 0 ;
34389 PyObject *swig_obj[1] ;
34390
34391 if (!args) SWIG_fail;
34392 swig_obj[0] = args;
34393 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34394 if (!SWIG_IsOK(res1)) {
34395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34396 }
34397 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34398 {
34399 PyThreadState* __tstate = wxPyBeginAllowThreads();
34400 (arg1)->OnLeave();
34401 wxPyEndAllowThreads(__tstate);
34402 if (PyErr_Occurred()) SWIG_fail;
34403 }
34404 resultobj = SWIG_Py_Void();
34405 return resultobj;
34406 fail:
34407 return NULL;
34408 }
34409
34410
34411 SWIGINTERN PyObject *_wrap_DropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34412 PyObject *resultobj = 0;
34413 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34414 int arg2 ;
34415 int arg3 ;
34416 bool result;
34417 void *argp1 = 0 ;
34418 int res1 = 0 ;
34419 int val2 ;
34420 int ecode2 = 0 ;
34421 int val3 ;
34422 int ecode3 = 0 ;
34423 PyObject * obj0 = 0 ;
34424 PyObject * obj1 = 0 ;
34425 PyObject * obj2 = 0 ;
34426 char * kwnames[] = {
34427 (char *) "self",(char *) "x",(char *) "y", NULL
34428 };
34429
34430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34431 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34432 if (!SWIG_IsOK(res1)) {
34433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34434 }
34435 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34436 ecode2 = SWIG_AsVal_int(obj1, &val2);
34437 if (!SWIG_IsOK(ecode2)) {
34438 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
34439 }
34440 arg2 = static_cast< int >(val2);
34441 ecode3 = SWIG_AsVal_int(obj2, &val3);
34442 if (!SWIG_IsOK(ecode3)) {
34443 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
34444 }
34445 arg3 = static_cast< int >(val3);
34446 {
34447 PyThreadState* __tstate = wxPyBeginAllowThreads();
34448 result = (bool)(arg1)->OnDrop(arg2,arg3);
34449 wxPyEndAllowThreads(__tstate);
34450 if (PyErr_Occurred()) SWIG_fail;
34451 }
34452 {
34453 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34454 }
34455 return resultobj;
34456 fail:
34457 return NULL;
34458 }
34459
34460
34461 SWIGINTERN PyObject *_wrap_DropTarget_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34462 PyObject *resultobj = 0;
34463 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34464 bool result;
34465 void *argp1 = 0 ;
34466 int res1 = 0 ;
34467 PyObject *swig_obj[1] ;
34468
34469 if (!args) SWIG_fail;
34470 swig_obj[0] = args;
34471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34472 if (!SWIG_IsOK(res1)) {
34473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetData" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34474 }
34475 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34476 {
34477 PyThreadState* __tstate = wxPyBeginAllowThreads();
34478 result = (bool)(arg1)->GetData();
34479 wxPyEndAllowThreads(__tstate);
34480 if (PyErr_Occurred()) SWIG_fail;
34481 }
34482 {
34483 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34484 }
34485 return resultobj;
34486 fail:
34487 return NULL;
34488 }
34489
34490
34491 SWIGINTERN PyObject *_wrap_DropTarget_SetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34492 PyObject *resultobj = 0;
34493 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34494 wxDragResult arg2 ;
34495 void *argp1 = 0 ;
34496 int res1 = 0 ;
34497 int val2 ;
34498 int ecode2 = 0 ;
34499 PyObject * obj0 = 0 ;
34500 PyObject * obj1 = 0 ;
34501 char * kwnames[] = {
34502 (char *) "self",(char *) "action", NULL
34503 };
34504
34505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDefaultAction",kwnames,&obj0,&obj1)) SWIG_fail;
34506 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34507 if (!SWIG_IsOK(res1)) {
34508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34509 }
34510 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34511 ecode2 = SWIG_AsVal_int(obj1, &val2);
34512 if (!SWIG_IsOK(ecode2)) {
34513 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "2"" of type '" "wxDragResult""'");
34514 }
34515 arg2 = static_cast< wxDragResult >(val2);
34516 {
34517 PyThreadState* __tstate = wxPyBeginAllowThreads();
34518 (arg1)->SetDefaultAction(arg2);
34519 wxPyEndAllowThreads(__tstate);
34520 if (PyErr_Occurred()) SWIG_fail;
34521 }
34522 resultobj = SWIG_Py_Void();
34523 return resultobj;
34524 fail:
34525 return NULL;
34526 }
34527
34528
34529 SWIGINTERN PyObject *_wrap_DropTarget_GetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34530 PyObject *resultobj = 0;
34531 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34532 wxDragResult result;
34533 void *argp1 = 0 ;
34534 int res1 = 0 ;
34535 PyObject *swig_obj[1] ;
34536
34537 if (!args) SWIG_fail;
34538 swig_obj[0] = args;
34539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34540 if (!SWIG_IsOK(res1)) {
34541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34542 }
34543 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34544 {
34545 PyThreadState* __tstate = wxPyBeginAllowThreads();
34546 result = (wxDragResult)(arg1)->GetDefaultAction();
34547 wxPyEndAllowThreads(__tstate);
34548 if (PyErr_Occurred()) SWIG_fail;
34549 }
34550 resultobj = SWIG_From_int(static_cast< int >(result));
34551 return resultobj;
34552 fail:
34553 return NULL;
34554 }
34555
34556
34557 SWIGINTERN PyObject *DropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34558 PyObject *obj;
34559 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34560 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropTarget, SWIG_NewClientData(obj));
34561 return SWIG_Py_Void();
34562 }
34563
34564 SWIGINTERN PyObject *DropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34565 return SWIG_Python_InitShadowInstance(args);
34566 }
34567
34568 SWIGINTERN PyObject *_wrap_new_TextDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34569 PyObject *resultobj = 0;
34570 wxPyTextDropTarget *result = 0 ;
34571
34572 if (!SWIG_Python_UnpackTuple(args,"new_TextDropTarget",0,0,0)) SWIG_fail;
34573 {
34574 PyThreadState* __tstate = wxPyBeginAllowThreads();
34575 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
34576 wxPyEndAllowThreads(__tstate);
34577 if (PyErr_Occurred()) SWIG_fail;
34578 }
34579 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_NEW | 0 );
34580 return resultobj;
34581 fail:
34582 return NULL;
34583 }
34584
34585
34586 SWIGINTERN PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34587 PyObject *resultobj = 0;
34588 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34589 PyObject *arg2 = (PyObject *) 0 ;
34590 PyObject *arg3 = (PyObject *) 0 ;
34591 void *argp1 = 0 ;
34592 int res1 = 0 ;
34593 PyObject * obj0 = 0 ;
34594 PyObject * obj1 = 0 ;
34595 PyObject * obj2 = 0 ;
34596 char * kwnames[] = {
34597 (char *) "self",(char *) "self",(char *) "_class", NULL
34598 };
34599
34600 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34601 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34602 if (!SWIG_IsOK(res1)) {
34603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34604 }
34605 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34606 arg2 = obj1;
34607 arg3 = obj2;
34608 {
34609 PyThreadState* __tstate = wxPyBeginAllowThreads();
34610 (arg1)->_setCallbackInfo(arg2,arg3);
34611 wxPyEndAllowThreads(__tstate);
34612 if (PyErr_Occurred()) SWIG_fail;
34613 }
34614 resultobj = SWIG_Py_Void();
34615 return resultobj;
34616 fail:
34617 return NULL;
34618 }
34619
34620
34621 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDropText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34622 PyObject *resultobj = 0;
34623 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34624 int arg2 ;
34625 int arg3 ;
34626 wxString *arg4 = 0 ;
34627 bool result;
34628 void *argp1 = 0 ;
34629 int res1 = 0 ;
34630 int val2 ;
34631 int ecode2 = 0 ;
34632 int val3 ;
34633 int ecode3 = 0 ;
34634 bool temp4 = false ;
34635 PyObject * obj0 = 0 ;
34636 PyObject * obj1 = 0 ;
34637 PyObject * obj2 = 0 ;
34638 PyObject * obj3 = 0 ;
34639 char * kwnames[] = {
34640 (char *) "self",(char *) "x",(char *) "y",(char *) "text", NULL
34641 };
34642
34643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDropText",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34644 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34645 if (!SWIG_IsOK(res1)) {
34646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDropText" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34647 }
34648 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34649 ecode2 = SWIG_AsVal_int(obj1, &val2);
34650 if (!SWIG_IsOK(ecode2)) {
34651 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDropText" "', expected argument " "2"" of type '" "int""'");
34652 }
34653 arg2 = static_cast< int >(val2);
34654 ecode3 = SWIG_AsVal_int(obj2, &val3);
34655 if (!SWIG_IsOK(ecode3)) {
34656 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDropText" "', expected argument " "3"" of type '" "int""'");
34657 }
34658 arg3 = static_cast< int >(val3);
34659 {
34660 arg4 = wxString_in_helper(obj3);
34661 if (arg4 == NULL) SWIG_fail;
34662 temp4 = true;
34663 }
34664 {
34665 PyThreadState* __tstate = wxPyBeginAllowThreads();
34666 result = (bool)(arg1)->OnDropText(arg2,arg3,(wxString const &)*arg4);
34667 wxPyEndAllowThreads(__tstate);
34668 if (PyErr_Occurred()) SWIG_fail;
34669 }
34670 {
34671 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34672 }
34673 {
34674 if (temp4)
34675 delete arg4;
34676 }
34677 return resultobj;
34678 fail:
34679 {
34680 if (temp4)
34681 delete arg4;
34682 }
34683 return NULL;
34684 }
34685
34686
34687 SWIGINTERN PyObject *_wrap_TextDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34688 PyObject *resultobj = 0;
34689 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34690 int arg2 ;
34691 int arg3 ;
34692 wxDragResult arg4 ;
34693 wxDragResult result;
34694 void *argp1 = 0 ;
34695 int res1 = 0 ;
34696 int val2 ;
34697 int ecode2 = 0 ;
34698 int val3 ;
34699 int ecode3 = 0 ;
34700 int val4 ;
34701 int ecode4 = 0 ;
34702 PyObject * obj0 = 0 ;
34703 PyObject * obj1 = 0 ;
34704 PyObject * obj2 = 0 ;
34705 PyObject * obj3 = 0 ;
34706 char * kwnames[] = {
34707 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34708 };
34709
34710 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34711 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34712 if (!SWIG_IsOK(res1)) {
34713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34714 }
34715 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34716 ecode2 = SWIG_AsVal_int(obj1, &val2);
34717 if (!SWIG_IsOK(ecode2)) {
34718 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
34719 }
34720 arg2 = static_cast< int >(val2);
34721 ecode3 = SWIG_AsVal_int(obj2, &val3);
34722 if (!SWIG_IsOK(ecode3)) {
34723 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
34724 }
34725 arg3 = static_cast< int >(val3);
34726 ecode4 = SWIG_AsVal_int(obj3, &val4);
34727 if (!SWIG_IsOK(ecode4)) {
34728 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
34729 }
34730 arg4 = static_cast< wxDragResult >(val4);
34731 {
34732 PyThreadState* __tstate = wxPyBeginAllowThreads();
34733 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
34734 wxPyEndAllowThreads(__tstate);
34735 if (PyErr_Occurred()) SWIG_fail;
34736 }
34737 resultobj = SWIG_From_int(static_cast< int >(result));
34738 return resultobj;
34739 fail:
34740 return NULL;
34741 }
34742
34743
34744 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34745 PyObject *resultobj = 0;
34746 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34747 int arg2 ;
34748 int arg3 ;
34749 wxDragResult arg4 ;
34750 wxDragResult result;
34751 void *argp1 = 0 ;
34752 int res1 = 0 ;
34753 int val2 ;
34754 int ecode2 = 0 ;
34755 int val3 ;
34756 int ecode3 = 0 ;
34757 int val4 ;
34758 int ecode4 = 0 ;
34759 PyObject * obj0 = 0 ;
34760 PyObject * obj1 = 0 ;
34761 PyObject * obj2 = 0 ;
34762 PyObject * obj3 = 0 ;
34763 char * kwnames[] = {
34764 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34765 };
34766
34767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34769 if (!SWIG_IsOK(res1)) {
34770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34771 }
34772 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34773 ecode2 = SWIG_AsVal_int(obj1, &val2);
34774 if (!SWIG_IsOK(ecode2)) {
34775 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
34776 }
34777 arg2 = static_cast< int >(val2);
34778 ecode3 = SWIG_AsVal_int(obj2, &val3);
34779 if (!SWIG_IsOK(ecode3)) {
34780 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
34781 }
34782 arg3 = static_cast< int >(val3);
34783 ecode4 = SWIG_AsVal_int(obj3, &val4);
34784 if (!SWIG_IsOK(ecode4)) {
34785 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
34786 }
34787 arg4 = static_cast< wxDragResult >(val4);
34788 {
34789 PyThreadState* __tstate = wxPyBeginAllowThreads();
34790 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
34791 wxPyEndAllowThreads(__tstate);
34792 if (PyErr_Occurred()) SWIG_fail;
34793 }
34794 resultobj = SWIG_From_int(static_cast< int >(result));
34795 return resultobj;
34796 fail:
34797 return NULL;
34798 }
34799
34800
34801 SWIGINTERN PyObject *_wrap_TextDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34802 PyObject *resultobj = 0;
34803 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34804 void *argp1 = 0 ;
34805 int res1 = 0 ;
34806 PyObject *swig_obj[1] ;
34807
34808 if (!args) SWIG_fail;
34809 swig_obj[0] = args;
34810 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34811 if (!SWIG_IsOK(res1)) {
34812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34813 }
34814 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34815 {
34816 PyThreadState* __tstate = wxPyBeginAllowThreads();
34817 (arg1)->OnLeave();
34818 wxPyEndAllowThreads(__tstate);
34819 if (PyErr_Occurred()) SWIG_fail;
34820 }
34821 resultobj = SWIG_Py_Void();
34822 return resultobj;
34823 fail:
34824 return NULL;
34825 }
34826
34827
34828 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34829 PyObject *resultobj = 0;
34830 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34831 int arg2 ;
34832 int arg3 ;
34833 bool result;
34834 void *argp1 = 0 ;
34835 int res1 = 0 ;
34836 int val2 ;
34837 int ecode2 = 0 ;
34838 int val3 ;
34839 int ecode3 = 0 ;
34840 PyObject * obj0 = 0 ;
34841 PyObject * obj1 = 0 ;
34842 PyObject * obj2 = 0 ;
34843 char * kwnames[] = {
34844 (char *) "self",(char *) "x",(char *) "y", NULL
34845 };
34846
34847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34849 if (!SWIG_IsOK(res1)) {
34850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34851 }
34852 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34853 ecode2 = SWIG_AsVal_int(obj1, &val2);
34854 if (!SWIG_IsOK(ecode2)) {
34855 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
34856 }
34857 arg2 = static_cast< int >(val2);
34858 ecode3 = SWIG_AsVal_int(obj2, &val3);
34859 if (!SWIG_IsOK(ecode3)) {
34860 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
34861 }
34862 arg3 = static_cast< int >(val3);
34863 {
34864 PyThreadState* __tstate = wxPyBeginAllowThreads();
34865 result = (bool)(arg1)->OnDrop(arg2,arg3);
34866 wxPyEndAllowThreads(__tstate);
34867 if (PyErr_Occurred()) SWIG_fail;
34868 }
34869 {
34870 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34871 }
34872 return resultobj;
34873 fail:
34874 return NULL;
34875 }
34876
34877
34878 SWIGINTERN PyObject *_wrap_TextDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34879 PyObject *resultobj = 0;
34880 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34881 int arg2 ;
34882 int arg3 ;
34883 wxDragResult arg4 ;
34884 wxDragResult result;
34885 void *argp1 = 0 ;
34886 int res1 = 0 ;
34887 int val2 ;
34888 int ecode2 = 0 ;
34889 int val3 ;
34890 int ecode3 = 0 ;
34891 int val4 ;
34892 int ecode4 = 0 ;
34893 PyObject * obj0 = 0 ;
34894 PyObject * obj1 = 0 ;
34895 PyObject * obj2 = 0 ;
34896 PyObject * obj3 = 0 ;
34897 char * kwnames[] = {
34898 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34899 };
34900
34901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34902 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34903 if (!SWIG_IsOK(res1)) {
34904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34905 }
34906 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34907 ecode2 = SWIG_AsVal_int(obj1, &val2);
34908 if (!SWIG_IsOK(ecode2)) {
34909 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
34910 }
34911 arg2 = static_cast< int >(val2);
34912 ecode3 = SWIG_AsVal_int(obj2, &val3);
34913 if (!SWIG_IsOK(ecode3)) {
34914 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
34915 }
34916 arg3 = static_cast< int >(val3);
34917 ecode4 = SWIG_AsVal_int(obj3, &val4);
34918 if (!SWIG_IsOK(ecode4)) {
34919 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
34920 }
34921 arg4 = static_cast< wxDragResult >(val4);
34922 {
34923 PyThreadState* __tstate = wxPyBeginAllowThreads();
34924 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
34925 wxPyEndAllowThreads(__tstate);
34926 if (PyErr_Occurred()) SWIG_fail;
34927 }
34928 resultobj = SWIG_From_int(static_cast< int >(result));
34929 return resultobj;
34930 fail:
34931 return NULL;
34932 }
34933
34934
34935 SWIGINTERN PyObject *TextDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34936 PyObject *obj;
34937 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34938 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDropTarget, SWIG_NewClientData(obj));
34939 return SWIG_Py_Void();
34940 }
34941
34942 SWIGINTERN PyObject *TextDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34943 return SWIG_Python_InitShadowInstance(args);
34944 }
34945
34946 SWIGINTERN PyObject *_wrap_new_FileDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34947 PyObject *resultobj = 0;
34948 wxPyFileDropTarget *result = 0 ;
34949
34950 if (!SWIG_Python_UnpackTuple(args,"new_FileDropTarget",0,0,0)) SWIG_fail;
34951 {
34952 PyThreadState* __tstate = wxPyBeginAllowThreads();
34953 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
34954 wxPyEndAllowThreads(__tstate);
34955 if (PyErr_Occurred()) SWIG_fail;
34956 }
34957 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_NEW | 0 );
34958 return resultobj;
34959 fail:
34960 return NULL;
34961 }
34962
34963
34964 SWIGINTERN PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34965 PyObject *resultobj = 0;
34966 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
34967 PyObject *arg2 = (PyObject *) 0 ;
34968 PyObject *arg3 = (PyObject *) 0 ;
34969 void *argp1 = 0 ;
34970 int res1 = 0 ;
34971 PyObject * obj0 = 0 ;
34972 PyObject * obj1 = 0 ;
34973 PyObject * obj2 = 0 ;
34974 char * kwnames[] = {
34975 (char *) "self",(char *) "self",(char *) "_class", NULL
34976 };
34977
34978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34979 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
34980 if (!SWIG_IsOK(res1)) {
34981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
34982 }
34983 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
34984 arg2 = obj1;
34985 arg3 = obj2;
34986 {
34987 PyThreadState* __tstate = wxPyBeginAllowThreads();
34988 (arg1)->_setCallbackInfo(arg2,arg3);
34989 wxPyEndAllowThreads(__tstate);
34990 if (PyErr_Occurred()) SWIG_fail;
34991 }
34992 resultobj = SWIG_Py_Void();
34993 return resultobj;
34994 fail:
34995 return NULL;
34996 }
34997
34998
34999 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDropFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35000 PyObject *resultobj = 0;
35001 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35002 int arg2 ;
35003 int arg3 ;
35004 wxArrayString *arg4 = 0 ;
35005 bool result;
35006 void *argp1 = 0 ;
35007 int res1 = 0 ;
35008 int val2 ;
35009 int ecode2 = 0 ;
35010 int val3 ;
35011 int ecode3 = 0 ;
35012 bool temp4 = false ;
35013 PyObject * obj0 = 0 ;
35014 PyObject * obj1 = 0 ;
35015 PyObject * obj2 = 0 ;
35016 PyObject * obj3 = 0 ;
35017 char * kwnames[] = {
35018 (char *) "self",(char *) "x",(char *) "y",(char *) "filenames", NULL
35019 };
35020
35021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDropFiles",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35022 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35023 if (!SWIG_IsOK(res1)) {
35024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35025 }
35026 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35027 ecode2 = SWIG_AsVal_int(obj1, &val2);
35028 if (!SWIG_IsOK(ecode2)) {
35029 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "2"" of type '" "int""'");
35030 }
35031 arg2 = static_cast< int >(val2);
35032 ecode3 = SWIG_AsVal_int(obj2, &val3);
35033 if (!SWIG_IsOK(ecode3)) {
35034 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "3"" of type '" "int""'");
35035 }
35036 arg3 = static_cast< int >(val3);
35037 {
35038 if (! PySequence_Check(obj3)) {
35039 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
35040 SWIG_fail;
35041 }
35042 arg4 = new wxArrayString;
35043 temp4 = true;
35044 int i, len=PySequence_Length(obj3);
35045 for (i=0; i<len; i++) {
35046 PyObject* item = PySequence_GetItem(obj3, i);
35047 wxString* s = wxString_in_helper(item);
35048 if (PyErr_Occurred()) SWIG_fail;
35049 arg4->Add(*s);
35050 delete s;
35051 Py_DECREF(item);
35052 }
35053 }
35054 {
35055 PyThreadState* __tstate = wxPyBeginAllowThreads();
35056 result = (bool)(arg1)->OnDropFiles(arg2,arg3,(wxArrayString const &)*arg4);
35057 wxPyEndAllowThreads(__tstate);
35058 if (PyErr_Occurred()) SWIG_fail;
35059 }
35060 {
35061 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35062 }
35063 {
35064 if (temp4) delete arg4;
35065 }
35066 return resultobj;
35067 fail:
35068 {
35069 if (temp4) delete arg4;
35070 }
35071 return NULL;
35072 }
35073
35074
35075 SWIGINTERN PyObject *_wrap_FileDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35076 PyObject *resultobj = 0;
35077 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35078 int arg2 ;
35079 int arg3 ;
35080 wxDragResult arg4 ;
35081 wxDragResult result;
35082 void *argp1 = 0 ;
35083 int res1 = 0 ;
35084 int val2 ;
35085 int ecode2 = 0 ;
35086 int val3 ;
35087 int ecode3 = 0 ;
35088 int val4 ;
35089 int ecode4 = 0 ;
35090 PyObject * obj0 = 0 ;
35091 PyObject * obj1 = 0 ;
35092 PyObject * obj2 = 0 ;
35093 PyObject * obj3 = 0 ;
35094 char * kwnames[] = {
35095 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
35096 };
35097
35098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35099 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35100 if (!SWIG_IsOK(res1)) {
35101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35102 }
35103 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35104 ecode2 = SWIG_AsVal_int(obj1, &val2);
35105 if (!SWIG_IsOK(ecode2)) {
35106 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
35107 }
35108 arg2 = static_cast< int >(val2);
35109 ecode3 = SWIG_AsVal_int(obj2, &val3);
35110 if (!SWIG_IsOK(ecode3)) {
35111 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
35112 }
35113 arg3 = static_cast< int >(val3);
35114 ecode4 = SWIG_AsVal_int(obj3, &val4);
35115 if (!SWIG_IsOK(ecode4)) {
35116 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
35117 }
35118 arg4 = static_cast< wxDragResult >(val4);
35119 {
35120 PyThreadState* __tstate = wxPyBeginAllowThreads();
35121 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
35122 wxPyEndAllowThreads(__tstate);
35123 if (PyErr_Occurred()) SWIG_fail;
35124 }
35125 resultobj = SWIG_From_int(static_cast< int >(result));
35126 return resultobj;
35127 fail:
35128 return NULL;
35129 }
35130
35131
35132 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35133 PyObject *resultobj = 0;
35134 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35135 int arg2 ;
35136 int arg3 ;
35137 wxDragResult arg4 ;
35138 wxDragResult result;
35139 void *argp1 = 0 ;
35140 int res1 = 0 ;
35141 int val2 ;
35142 int ecode2 = 0 ;
35143 int val3 ;
35144 int ecode3 = 0 ;
35145 int val4 ;
35146 int ecode4 = 0 ;
35147 PyObject * obj0 = 0 ;
35148 PyObject * obj1 = 0 ;
35149 PyObject * obj2 = 0 ;
35150 PyObject * obj3 = 0 ;
35151 char * kwnames[] = {
35152 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
35153 };
35154
35155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35157 if (!SWIG_IsOK(res1)) {
35158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35159 }
35160 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35161 ecode2 = SWIG_AsVal_int(obj1, &val2);
35162 if (!SWIG_IsOK(ecode2)) {
35163 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
35164 }
35165 arg2 = static_cast< int >(val2);
35166 ecode3 = SWIG_AsVal_int(obj2, &val3);
35167 if (!SWIG_IsOK(ecode3)) {
35168 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
35169 }
35170 arg3 = static_cast< int >(val3);
35171 ecode4 = SWIG_AsVal_int(obj3, &val4);
35172 if (!SWIG_IsOK(ecode4)) {
35173 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
35174 }
35175 arg4 = static_cast< wxDragResult >(val4);
35176 {
35177 PyThreadState* __tstate = wxPyBeginAllowThreads();
35178 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
35179 wxPyEndAllowThreads(__tstate);
35180 if (PyErr_Occurred()) SWIG_fail;
35181 }
35182 resultobj = SWIG_From_int(static_cast< int >(result));
35183 return resultobj;
35184 fail:
35185 return NULL;
35186 }
35187
35188
35189 SWIGINTERN PyObject *_wrap_FileDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35190 PyObject *resultobj = 0;
35191 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35192 void *argp1 = 0 ;
35193 int res1 = 0 ;
35194 PyObject *swig_obj[1] ;
35195
35196 if (!args) SWIG_fail;
35197 swig_obj[0] = args;
35198 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35199 if (!SWIG_IsOK(res1)) {
35200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35201 }
35202 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35203 {
35204 PyThreadState* __tstate = wxPyBeginAllowThreads();
35205 (arg1)->OnLeave();
35206 wxPyEndAllowThreads(__tstate);
35207 if (PyErr_Occurred()) SWIG_fail;
35208 }
35209 resultobj = SWIG_Py_Void();
35210 return resultobj;
35211 fail:
35212 return NULL;
35213 }
35214
35215
35216 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35217 PyObject *resultobj = 0;
35218 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35219 int arg2 ;
35220 int arg3 ;
35221 bool result;
35222 void *argp1 = 0 ;
35223 int res1 = 0 ;
35224 int val2 ;
35225 int ecode2 = 0 ;
35226 int val3 ;
35227 int ecode3 = 0 ;
35228 PyObject * obj0 = 0 ;
35229 PyObject * obj1 = 0 ;
35230 PyObject * obj2 = 0 ;
35231 char * kwnames[] = {
35232 (char *) "self",(char *) "x",(char *) "y", NULL
35233 };
35234
35235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35236 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35237 if (!SWIG_IsOK(res1)) {
35238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35239 }
35240 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35241 ecode2 = SWIG_AsVal_int(obj1, &val2);
35242 if (!SWIG_IsOK(ecode2)) {
35243 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
35244 }
35245 arg2 = static_cast< int >(val2);
35246 ecode3 = SWIG_AsVal_int(obj2, &val3);
35247 if (!SWIG_IsOK(ecode3)) {
35248 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
35249 }
35250 arg3 = static_cast< int >(val3);
35251 {
35252 PyThreadState* __tstate = wxPyBeginAllowThreads();
35253 result = (bool)(arg1)->OnDrop(arg2,arg3);
35254 wxPyEndAllowThreads(__tstate);
35255 if (PyErr_Occurred()) SWIG_fail;
35256 }
35257 {
35258 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35259 }
35260 return resultobj;
35261 fail:
35262 return NULL;
35263 }
35264
35265
35266 SWIGINTERN PyObject *_wrap_FileDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35267 PyObject *resultobj = 0;
35268 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35269 int arg2 ;
35270 int arg3 ;
35271 wxDragResult arg4 ;
35272 wxDragResult result;
35273 void *argp1 = 0 ;
35274 int res1 = 0 ;
35275 int val2 ;
35276 int ecode2 = 0 ;
35277 int val3 ;
35278 int ecode3 = 0 ;
35279 int val4 ;
35280 int ecode4 = 0 ;
35281 PyObject * obj0 = 0 ;
35282 PyObject * obj1 = 0 ;
35283 PyObject * obj2 = 0 ;
35284 PyObject * obj3 = 0 ;
35285 char * kwnames[] = {
35286 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
35287 };
35288
35289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35291 if (!SWIG_IsOK(res1)) {
35292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35293 }
35294 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35295 ecode2 = SWIG_AsVal_int(obj1, &val2);
35296 if (!SWIG_IsOK(ecode2)) {
35297 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
35298 }
35299 arg2 = static_cast< int >(val2);
35300 ecode3 = SWIG_AsVal_int(obj2, &val3);
35301 if (!SWIG_IsOK(ecode3)) {
35302 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
35303 }
35304 arg3 = static_cast< int >(val3);
35305 ecode4 = SWIG_AsVal_int(obj3, &val4);
35306 if (!SWIG_IsOK(ecode4)) {
35307 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
35308 }
35309 arg4 = static_cast< wxDragResult >(val4);
35310 {
35311 PyThreadState* __tstate = wxPyBeginAllowThreads();
35312 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
35313 wxPyEndAllowThreads(__tstate);
35314 if (PyErr_Occurred()) SWIG_fail;
35315 }
35316 resultobj = SWIG_From_int(static_cast< int >(result));
35317 return resultobj;
35318 fail:
35319 return NULL;
35320 }
35321
35322
35323 SWIGINTERN PyObject *FileDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35324 PyObject *obj;
35325 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35326 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileDropTarget, SWIG_NewClientData(obj));
35327 return SWIG_Py_Void();
35328 }
35329
35330 SWIGINTERN PyObject *FileDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35331 return SWIG_Python_InitShadowInstance(args);
35332 }
35333
35334 SWIGINTERN PyObject *_wrap_new_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35335 PyObject *resultobj = 0;
35336 wxClipboard *result = 0 ;
35337
35338 if (!SWIG_Python_UnpackTuple(args,"new_Clipboard",0,0,0)) SWIG_fail;
35339 {
35340 PyThreadState* __tstate = wxPyBeginAllowThreads();
35341 result = (wxClipboard *)new wxClipboard();
35342 wxPyEndAllowThreads(__tstate);
35343 if (PyErr_Occurred()) SWIG_fail;
35344 }
35345 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, SWIG_POINTER_NEW | 0 );
35346 return resultobj;
35347 fail:
35348 return NULL;
35349 }
35350
35351
35352 SWIGINTERN PyObject *_wrap_delete_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35353 PyObject *resultobj = 0;
35354 wxClipboard *arg1 = (wxClipboard *) 0 ;
35355 void *argp1 = 0 ;
35356 int res1 = 0 ;
35357 PyObject *swig_obj[1] ;
35358
35359 if (!args) SWIG_fail;
35360 swig_obj[0] = args;
35361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, SWIG_POINTER_DISOWN | 0 );
35362 if (!SWIG_IsOK(res1)) {
35363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Clipboard" "', expected argument " "1"" of type '" "wxClipboard *""'");
35364 }
35365 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35366 {
35367 PyThreadState* __tstate = wxPyBeginAllowThreads();
35368 delete arg1;
35369
35370 wxPyEndAllowThreads(__tstate);
35371 if (PyErr_Occurred()) SWIG_fail;
35372 }
35373 resultobj = SWIG_Py_Void();
35374 return resultobj;
35375 fail:
35376 return NULL;
35377 }
35378
35379
35380 SWIGINTERN PyObject *_wrap_Clipboard_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35381 PyObject *resultobj = 0;
35382 wxClipboard *arg1 = (wxClipboard *) 0 ;
35383 bool result;
35384 void *argp1 = 0 ;
35385 int res1 = 0 ;
35386 PyObject *swig_obj[1] ;
35387
35388 if (!args) SWIG_fail;
35389 swig_obj[0] = args;
35390 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35391 if (!SWIG_IsOK(res1)) {
35392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Open" "', expected argument " "1"" of type '" "wxClipboard *""'");
35393 }
35394 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35395 {
35396 PyThreadState* __tstate = wxPyBeginAllowThreads();
35397 result = (bool)(arg1)->Open();
35398 wxPyEndAllowThreads(__tstate);
35399 if (PyErr_Occurred()) SWIG_fail;
35400 }
35401 {
35402 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35403 }
35404 return resultobj;
35405 fail:
35406 return NULL;
35407 }
35408
35409
35410 SWIGINTERN PyObject *_wrap_Clipboard_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35411 PyObject *resultobj = 0;
35412 wxClipboard *arg1 = (wxClipboard *) 0 ;
35413 void *argp1 = 0 ;
35414 int res1 = 0 ;
35415 PyObject *swig_obj[1] ;
35416
35417 if (!args) SWIG_fail;
35418 swig_obj[0] = args;
35419 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35420 if (!SWIG_IsOK(res1)) {
35421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Close" "', expected argument " "1"" of type '" "wxClipboard *""'");
35422 }
35423 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35424 {
35425 PyThreadState* __tstate = wxPyBeginAllowThreads();
35426 (arg1)->Close();
35427 wxPyEndAllowThreads(__tstate);
35428 if (PyErr_Occurred()) SWIG_fail;
35429 }
35430 resultobj = SWIG_Py_Void();
35431 return resultobj;
35432 fail:
35433 return NULL;
35434 }
35435
35436
35437 SWIGINTERN PyObject *_wrap_Clipboard_IsOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35438 PyObject *resultobj = 0;
35439 wxClipboard *arg1 = (wxClipboard *) 0 ;
35440 bool result;
35441 void *argp1 = 0 ;
35442 int res1 = 0 ;
35443 PyObject *swig_obj[1] ;
35444
35445 if (!args) SWIG_fail;
35446 swig_obj[0] = args;
35447 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35448 if (!SWIG_IsOK(res1)) {
35449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsOpened" "', expected argument " "1"" of type '" "wxClipboard const *""'");
35450 }
35451 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35452 {
35453 PyThreadState* __tstate = wxPyBeginAllowThreads();
35454 result = (bool)((wxClipboard const *)arg1)->IsOpened();
35455 wxPyEndAllowThreads(__tstate);
35456 if (PyErr_Occurred()) SWIG_fail;
35457 }
35458 {
35459 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35460 }
35461 return resultobj;
35462 fail:
35463 return NULL;
35464 }
35465
35466
35467 SWIGINTERN PyObject *_wrap_Clipboard_AddData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35468 PyObject *resultobj = 0;
35469 wxClipboard *arg1 = (wxClipboard *) 0 ;
35470 wxDataObject *arg2 = (wxDataObject *) 0 ;
35471 bool result;
35472 void *argp1 = 0 ;
35473 int res1 = 0 ;
35474 int res2 = 0 ;
35475 PyObject * obj0 = 0 ;
35476 PyObject * obj1 = 0 ;
35477 char * kwnames[] = {
35478 (char *) "self",(char *) "data", NULL
35479 };
35480
35481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) SWIG_fail;
35482 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35483 if (!SWIG_IsOK(res1)) {
35484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_AddData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35485 }
35486 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35487 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
35488 if (!SWIG_IsOK(res2)) {
35489 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_AddData" "', expected argument " "2"" of type '" "wxDataObject *""'");
35490 }
35491 {
35492 PyThreadState* __tstate = wxPyBeginAllowThreads();
35493 result = (bool)(arg1)->AddData(arg2);
35494 wxPyEndAllowThreads(__tstate);
35495 if (PyErr_Occurred()) SWIG_fail;
35496 }
35497 {
35498 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35499 }
35500 return resultobj;
35501 fail:
35502 return NULL;
35503 }
35504
35505
35506 SWIGINTERN PyObject *_wrap_Clipboard_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35507 PyObject *resultobj = 0;
35508 wxClipboard *arg1 = (wxClipboard *) 0 ;
35509 wxDataObject *arg2 = (wxDataObject *) 0 ;
35510 bool result;
35511 void *argp1 = 0 ;
35512 int res1 = 0 ;
35513 int res2 = 0 ;
35514 PyObject * obj0 = 0 ;
35515 PyObject * obj1 = 0 ;
35516 char * kwnames[] = {
35517 (char *) "self",(char *) "data", NULL
35518 };
35519
35520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
35521 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35522 if (!SWIG_IsOK(res1)) {
35523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_SetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35524 }
35525 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35526 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
35527 if (!SWIG_IsOK(res2)) {
35528 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_SetData" "', expected argument " "2"" of type '" "wxDataObject *""'");
35529 }
35530 {
35531 PyThreadState* __tstate = wxPyBeginAllowThreads();
35532 result = (bool)(arg1)->SetData(arg2);
35533 wxPyEndAllowThreads(__tstate);
35534 if (PyErr_Occurred()) SWIG_fail;
35535 }
35536 {
35537 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35538 }
35539 return resultobj;
35540 fail:
35541 return NULL;
35542 }
35543
35544
35545 SWIGINTERN PyObject *_wrap_Clipboard_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35546 PyObject *resultobj = 0;
35547 wxClipboard *arg1 = (wxClipboard *) 0 ;
35548 wxDataFormat *arg2 = 0 ;
35549 bool result;
35550 void *argp1 = 0 ;
35551 int res1 = 0 ;
35552 void *argp2 = 0 ;
35553 int res2 = 0 ;
35554 PyObject * obj0 = 0 ;
35555 PyObject * obj1 = 0 ;
35556 char * kwnames[] = {
35557 (char *) "self",(char *) "format", NULL
35558 };
35559
35560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) SWIG_fail;
35561 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35562 if (!SWIG_IsOK(res1)) {
35563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsSupported" "', expected argument " "1"" of type '" "wxClipboard *""'");
35564 }
35565 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35566 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
35567 if (!SWIG_IsOK(res2)) {
35568 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
35569 }
35570 if (!argp2) {
35571 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
35572 }
35573 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
35574 {
35575 PyThreadState* __tstate = wxPyBeginAllowThreads();
35576 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
35577 wxPyEndAllowThreads(__tstate);
35578 if (PyErr_Occurred()) SWIG_fail;
35579 }
35580 {
35581 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35582 }
35583 return resultobj;
35584 fail:
35585 return NULL;
35586 }
35587
35588
35589 SWIGINTERN PyObject *_wrap_Clipboard_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35590 PyObject *resultobj = 0;
35591 wxClipboard *arg1 = (wxClipboard *) 0 ;
35592 wxDataObject *arg2 = 0 ;
35593 bool result;
35594 void *argp1 = 0 ;
35595 int res1 = 0 ;
35596 void *argp2 = 0 ;
35597 int res2 = 0 ;
35598 PyObject * obj0 = 0 ;
35599 PyObject * obj1 = 0 ;
35600 char * kwnames[] = {
35601 (char *) "self",(char *) "data", NULL
35602 };
35603
35604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) SWIG_fail;
35605 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35606 if (!SWIG_IsOK(res1)) {
35607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_GetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35608 }
35609 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35610 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
35611 if (!SWIG_IsOK(res2)) {
35612 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
35613 }
35614 if (!argp2) {
35615 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
35616 }
35617 arg2 = reinterpret_cast< wxDataObject * >(argp2);
35618 {
35619 PyThreadState* __tstate = wxPyBeginAllowThreads();
35620 result = (bool)(arg1)->GetData(*arg2);
35621 wxPyEndAllowThreads(__tstate);
35622 if (PyErr_Occurred()) SWIG_fail;
35623 }
35624 {
35625 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35626 }
35627 return resultobj;
35628 fail:
35629 return NULL;
35630 }
35631
35632
35633 SWIGINTERN PyObject *_wrap_Clipboard_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35634 PyObject *resultobj = 0;
35635 wxClipboard *arg1 = (wxClipboard *) 0 ;
35636 void *argp1 = 0 ;
35637 int res1 = 0 ;
35638 PyObject *swig_obj[1] ;
35639
35640 if (!args) SWIG_fail;
35641 swig_obj[0] = args;
35642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35643 if (!SWIG_IsOK(res1)) {
35644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Clear" "', expected argument " "1"" of type '" "wxClipboard *""'");
35645 }
35646 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35647 {
35648 PyThreadState* __tstate = wxPyBeginAllowThreads();
35649 (arg1)->Clear();
35650 wxPyEndAllowThreads(__tstate);
35651 if (PyErr_Occurred()) SWIG_fail;
35652 }
35653 resultobj = SWIG_Py_Void();
35654 return resultobj;
35655 fail:
35656 return NULL;
35657 }
35658
35659
35660 SWIGINTERN PyObject *_wrap_Clipboard_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35661 PyObject *resultobj = 0;
35662 wxClipboard *arg1 = (wxClipboard *) 0 ;
35663 bool result;
35664 void *argp1 = 0 ;
35665 int res1 = 0 ;
35666 PyObject *swig_obj[1] ;
35667
35668 if (!args) SWIG_fail;
35669 swig_obj[0] = args;
35670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35671 if (!SWIG_IsOK(res1)) {
35672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Flush" "', expected argument " "1"" of type '" "wxClipboard *""'");
35673 }
35674 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35675 {
35676 PyThreadState* __tstate = wxPyBeginAllowThreads();
35677 result = (bool)(arg1)->Flush();
35678 wxPyEndAllowThreads(__tstate);
35679 if (PyErr_Occurred()) SWIG_fail;
35680 }
35681 {
35682 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35683 }
35684 return resultobj;
35685 fail:
35686 return NULL;
35687 }
35688
35689
35690 SWIGINTERN PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35691 PyObject *resultobj = 0;
35692 wxClipboard *arg1 = (wxClipboard *) 0 ;
35693 bool arg2 = (bool) true ;
35694 void *argp1 = 0 ;
35695 int res1 = 0 ;
35696 bool val2 ;
35697 int ecode2 = 0 ;
35698 PyObject * obj0 = 0 ;
35699 PyObject * obj1 = 0 ;
35700 char * kwnames[] = {
35701 (char *) "self",(char *) "primary", NULL
35702 };
35703
35704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) SWIG_fail;
35705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35706 if (!SWIG_IsOK(res1)) {
35707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "1"" of type '" "wxClipboard *""'");
35708 }
35709 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35710 if (obj1) {
35711 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35712 if (!SWIG_IsOK(ecode2)) {
35713 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "2"" of type '" "bool""'");
35714 }
35715 arg2 = static_cast< bool >(val2);
35716 }
35717 {
35718 PyThreadState* __tstate = wxPyBeginAllowThreads();
35719 (arg1)->UsePrimarySelection(arg2);
35720 wxPyEndAllowThreads(__tstate);
35721 if (PyErr_Occurred()) SWIG_fail;
35722 }
35723 resultobj = SWIG_Py_Void();
35724 return resultobj;
35725 fail:
35726 return NULL;
35727 }
35728
35729
35730 SWIGINTERN PyObject *_wrap_Clipboard_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35731 PyObject *resultobj = 0;
35732 wxClipboard *result = 0 ;
35733
35734 if (!SWIG_Python_UnpackTuple(args,"Clipboard_Get",0,0,0)) SWIG_fail;
35735 {
35736 PyThreadState* __tstate = wxPyBeginAllowThreads();
35737 result = (wxClipboard *)wxClipboard::Get();
35738 wxPyEndAllowThreads(__tstate);
35739 if (PyErr_Occurred()) SWIG_fail;
35740 }
35741 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, 0 | 0 );
35742 return resultobj;
35743 fail:
35744 return NULL;
35745 }
35746
35747
35748 SWIGINTERN PyObject *Clipboard_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35749 PyObject *obj;
35750 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35751 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboard, SWIG_NewClientData(obj));
35752 return SWIG_Py_Void();
35753 }
35754
35755 SWIGINTERN PyObject *Clipboard_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35756 return SWIG_Python_InitShadowInstance(args);
35757 }
35758
35759 SWIGINTERN PyObject *_wrap_new_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35760 PyObject *resultobj = 0;
35761 wxClipboard *arg1 = (wxClipboard *) NULL ;
35762 wxClipboardLocker *result = 0 ;
35763 void *argp1 = 0 ;
35764 int res1 = 0 ;
35765 PyObject * obj0 = 0 ;
35766 char * kwnames[] = {
35767 (char *) "clipboard", NULL
35768 };
35769
35770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) SWIG_fail;
35771 if (obj0) {
35772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35773 if (!SWIG_IsOK(res1)) {
35774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboard *""'");
35775 }
35776 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35777 }
35778 {
35779 PyThreadState* __tstate = wxPyBeginAllowThreads();
35780 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
35781 wxPyEndAllowThreads(__tstate);
35782 if (PyErr_Occurred()) SWIG_fail;
35783 }
35784 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_NEW | 0 );
35785 return resultobj;
35786 fail:
35787 return NULL;
35788 }
35789
35790
35791 SWIGINTERN PyObject *_wrap_delete_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35792 PyObject *resultobj = 0;
35793 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
35794 void *argp1 = 0 ;
35795 int res1 = 0 ;
35796 PyObject *swig_obj[1] ;
35797
35798 if (!args) SWIG_fail;
35799 swig_obj[0] = args;
35800 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_DISOWN | 0 );
35801 if (!SWIG_IsOK(res1)) {
35802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
35803 }
35804 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
35805 {
35806 PyThreadState* __tstate = wxPyBeginAllowThreads();
35807 delete arg1;
35808
35809 wxPyEndAllowThreads(__tstate);
35810 if (PyErr_Occurred()) SWIG_fail;
35811 }
35812 resultobj = SWIG_Py_Void();
35813 return resultobj;
35814 fail:
35815 return NULL;
35816 }
35817
35818
35819 SWIGINTERN PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35820 PyObject *resultobj = 0;
35821 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
35822 bool result;
35823 void *argp1 = 0 ;
35824 int res1 = 0 ;
35825 PyObject *swig_obj[1] ;
35826
35827 if (!args) SWIG_fail;
35828 swig_obj[0] = args;
35829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, 0 | 0 );
35830 if (!SWIG_IsOK(res1)) {
35831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClipboardLocker___nonzero__" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
35832 }
35833 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
35834 {
35835 PyThreadState* __tstate = wxPyBeginAllowThreads();
35836 result = (bool)wxClipboardLocker___nonzero__(arg1);
35837 wxPyEndAllowThreads(__tstate);
35838 if (PyErr_Occurred()) SWIG_fail;
35839 }
35840 {
35841 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35842 }
35843 return resultobj;
35844 fail:
35845 return NULL;
35846 }
35847
35848
35849 SWIGINTERN PyObject *ClipboardLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35850 PyObject *obj;
35851 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35852 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardLocker, SWIG_NewClientData(obj));
35853 return SWIG_Py_Void();
35854 }
35855
35856 SWIGINTERN PyObject *ClipboardLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35857 return SWIG_Python_InitShadowInstance(args);
35858 }
35859
35860 SWIGINTERN PyObject *_wrap_new_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35861 PyObject *resultobj = 0;
35862 int arg1 = (int) 0 ;
35863 int arg2 = (int) 0 ;
35864 int arg3 = (int) 0 ;
35865 int arg4 = (int) 0 ;
35866 wxVideoMode *result = 0 ;
35867 int val1 ;
35868 int ecode1 = 0 ;
35869 int val2 ;
35870 int ecode2 = 0 ;
35871 int val3 ;
35872 int ecode3 = 0 ;
35873 int val4 ;
35874 int ecode4 = 0 ;
35875 PyObject * obj0 = 0 ;
35876 PyObject * obj1 = 0 ;
35877 PyObject * obj2 = 0 ;
35878 PyObject * obj3 = 0 ;
35879 char * kwnames[] = {
35880 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
35881 };
35882
35883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35884 if (obj0) {
35885 ecode1 = SWIG_AsVal_int(obj0, &val1);
35886 if (!SWIG_IsOK(ecode1)) {
35887 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VideoMode" "', expected argument " "1"" of type '" "int""'");
35888 }
35889 arg1 = static_cast< int >(val1);
35890 }
35891 if (obj1) {
35892 ecode2 = SWIG_AsVal_int(obj1, &val2);
35893 if (!SWIG_IsOK(ecode2)) {
35894 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VideoMode" "', expected argument " "2"" of type '" "int""'");
35895 }
35896 arg2 = static_cast< int >(val2);
35897 }
35898 if (obj2) {
35899 ecode3 = SWIG_AsVal_int(obj2, &val3);
35900 if (!SWIG_IsOK(ecode3)) {
35901 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_VideoMode" "', expected argument " "3"" of type '" "int""'");
35902 }
35903 arg3 = static_cast< int >(val3);
35904 }
35905 if (obj3) {
35906 ecode4 = SWIG_AsVal_int(obj3, &val4);
35907 if (!SWIG_IsOK(ecode4)) {
35908 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_VideoMode" "', expected argument " "4"" of type '" "int""'");
35909 }
35910 arg4 = static_cast< int >(val4);
35911 }
35912 {
35913 PyThreadState* __tstate = wxPyBeginAllowThreads();
35914 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
35915 wxPyEndAllowThreads(__tstate);
35916 if (PyErr_Occurred()) SWIG_fail;
35917 }
35918 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_NEW | 0 );
35919 return resultobj;
35920 fail:
35921 return NULL;
35922 }
35923
35924
35925 SWIGINTERN PyObject *_wrap_delete_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35926 PyObject *resultobj = 0;
35927 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35928 void *argp1 = 0 ;
35929 int res1 = 0 ;
35930 PyObject *swig_obj[1] ;
35931
35932 if (!args) SWIG_fail;
35933 swig_obj[0] = args;
35934 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, SWIG_POINTER_DISOWN | 0 );
35935 if (!SWIG_IsOK(res1)) {
35936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VideoMode" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35937 }
35938 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35939 {
35940 PyThreadState* __tstate = wxPyBeginAllowThreads();
35941 delete arg1;
35942
35943 wxPyEndAllowThreads(__tstate);
35944 if (PyErr_Occurred()) SWIG_fail;
35945 }
35946 resultobj = SWIG_Py_Void();
35947 return resultobj;
35948 fail:
35949 return NULL;
35950 }
35951
35952
35953 SWIGINTERN PyObject *_wrap_VideoMode_Matches(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35954 PyObject *resultobj = 0;
35955 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35956 wxVideoMode *arg2 = 0 ;
35957 bool result;
35958 void *argp1 = 0 ;
35959 int res1 = 0 ;
35960 void *argp2 = 0 ;
35961 int res2 = 0 ;
35962 PyObject * obj0 = 0 ;
35963 PyObject * obj1 = 0 ;
35964 char * kwnames[] = {
35965 (char *) "self",(char *) "other", NULL
35966 };
35967
35968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) SWIG_fail;
35969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35970 if (!SWIG_IsOK(res1)) {
35971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_Matches" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
35972 }
35973 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35974 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
35975 if (!SWIG_IsOK(res2)) {
35976 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35977 }
35978 if (!argp2) {
35979 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35980 }
35981 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
35982 {
35983 PyThreadState* __tstate = wxPyBeginAllowThreads();
35984 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
35985 wxPyEndAllowThreads(__tstate);
35986 if (PyErr_Occurred()) SWIG_fail;
35987 }
35988 {
35989 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35990 }
35991 return resultobj;
35992 fail:
35993 return NULL;
35994 }
35995
35996
35997 SWIGINTERN PyObject *_wrap_VideoMode_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35998 PyObject *resultobj = 0;
35999 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36000 int result;
36001 void *argp1 = 0 ;
36002 int res1 = 0 ;
36003 PyObject *swig_obj[1] ;
36004
36005 if (!args) SWIG_fail;
36006 swig_obj[0] = args;
36007 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36008 if (!SWIG_IsOK(res1)) {
36009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetWidth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
36010 }
36011 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36012 {
36013 PyThreadState* __tstate = wxPyBeginAllowThreads();
36014 result = (int)((wxVideoMode const *)arg1)->GetWidth();
36015 wxPyEndAllowThreads(__tstate);
36016 if (PyErr_Occurred()) SWIG_fail;
36017 }
36018 resultobj = SWIG_From_int(static_cast< int >(result));
36019 return resultobj;
36020 fail:
36021 return NULL;
36022 }
36023
36024
36025 SWIGINTERN PyObject *_wrap_VideoMode_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36026 PyObject *resultobj = 0;
36027 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36028 int result;
36029 void *argp1 = 0 ;
36030 int res1 = 0 ;
36031 PyObject *swig_obj[1] ;
36032
36033 if (!args) SWIG_fail;
36034 swig_obj[0] = args;
36035 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36036 if (!SWIG_IsOK(res1)) {
36037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetHeight" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
36038 }
36039 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36040 {
36041 PyThreadState* __tstate = wxPyBeginAllowThreads();
36042 result = (int)((wxVideoMode const *)arg1)->GetHeight();
36043 wxPyEndAllowThreads(__tstate);
36044 if (PyErr_Occurred()) SWIG_fail;
36045 }
36046 resultobj = SWIG_From_int(static_cast< int >(result));
36047 return resultobj;
36048 fail:
36049 return NULL;
36050 }
36051
36052
36053 SWIGINTERN PyObject *_wrap_VideoMode_GetDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36054 PyObject *resultobj = 0;
36055 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36056 int result;
36057 void *argp1 = 0 ;
36058 int res1 = 0 ;
36059 PyObject *swig_obj[1] ;
36060
36061 if (!args) SWIG_fail;
36062 swig_obj[0] = args;
36063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36064 if (!SWIG_IsOK(res1)) {
36065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetDepth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
36066 }
36067 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36068 {
36069 PyThreadState* __tstate = wxPyBeginAllowThreads();
36070 result = (int)((wxVideoMode const *)arg1)->GetDepth();
36071 wxPyEndAllowThreads(__tstate);
36072 if (PyErr_Occurred()) SWIG_fail;
36073 }
36074 resultobj = SWIG_From_int(static_cast< int >(result));
36075 return resultobj;
36076 fail:
36077 return NULL;
36078 }
36079
36080
36081 SWIGINTERN PyObject *_wrap_VideoMode_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36082 PyObject *resultobj = 0;
36083 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36084 bool result;
36085 void *argp1 = 0 ;
36086 int res1 = 0 ;
36087 PyObject *swig_obj[1] ;
36088
36089 if (!args) SWIG_fail;
36090 swig_obj[0] = args;
36091 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36092 if (!SWIG_IsOK(res1)) {
36093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_IsOk" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
36094 }
36095 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36096 {
36097 PyThreadState* __tstate = wxPyBeginAllowThreads();
36098 result = (bool)((wxVideoMode const *)arg1)->IsOk();
36099 wxPyEndAllowThreads(__tstate);
36100 if (PyErr_Occurred()) SWIG_fail;
36101 }
36102 {
36103 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36104 }
36105 return resultobj;
36106 fail:
36107 return NULL;
36108 }
36109
36110
36111 SWIGINTERN PyObject *_wrap_VideoMode___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36112 PyObject *resultobj = 0;
36113 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36114 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
36115 bool result;
36116 void *argp1 = 0 ;
36117 int res1 = 0 ;
36118 void *argp2 = 0 ;
36119 int res2 = 0 ;
36120 PyObject * obj0 = 0 ;
36121 PyObject * obj1 = 0 ;
36122 char * kwnames[] = {
36123 (char *) "self",(char *) "other", NULL
36124 };
36125
36126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
36127 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36128 if (!SWIG_IsOK(res1)) {
36129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___eq__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36130 }
36131 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36132 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36133 if (!SWIG_IsOK(res2)) {
36134 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___eq__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
36135 }
36136 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36137 {
36138 PyThreadState* __tstate = wxPyBeginAllowThreads();
36139 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
36140 wxPyEndAllowThreads(__tstate);
36141 if (PyErr_Occurred()) SWIG_fail;
36142 }
36143 {
36144 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36145 }
36146 return resultobj;
36147 fail:
36148 return NULL;
36149 }
36150
36151
36152 SWIGINTERN PyObject *_wrap_VideoMode___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36153 PyObject *resultobj = 0;
36154 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36155 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
36156 bool result;
36157 void *argp1 = 0 ;
36158 int res1 = 0 ;
36159 void *argp2 = 0 ;
36160 int res2 = 0 ;
36161 PyObject * obj0 = 0 ;
36162 PyObject * obj1 = 0 ;
36163 char * kwnames[] = {
36164 (char *) "self",(char *) "other", NULL
36165 };
36166
36167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
36168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36169 if (!SWIG_IsOK(res1)) {
36170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___ne__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36171 }
36172 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36173 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36174 if (!SWIG_IsOK(res2)) {
36175 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___ne__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
36176 }
36177 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36178 {
36179 PyThreadState* __tstate = wxPyBeginAllowThreads();
36180 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
36181 wxPyEndAllowThreads(__tstate);
36182 if (PyErr_Occurred()) SWIG_fail;
36183 }
36184 {
36185 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36186 }
36187 return resultobj;
36188 fail:
36189 return NULL;
36190 }
36191
36192
36193 SWIGINTERN PyObject *_wrap_VideoMode_w_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36194 PyObject *resultobj = 0;
36195 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36196 int arg2 ;
36197 void *argp1 = 0 ;
36198 int res1 = 0 ;
36199 int val2 ;
36200 int ecode2 = 0 ;
36201 PyObject *swig_obj[2] ;
36202
36203 if (!SWIG_Python_UnpackTuple(args,"VideoMode_w_set",2,2,swig_obj)) SWIG_fail;
36204 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36205 if (!SWIG_IsOK(res1)) {
36206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36207 }
36208 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36209 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36210 if (!SWIG_IsOK(ecode2)) {
36211 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_w_set" "', expected argument " "2"" of type '" "int""'");
36212 }
36213 arg2 = static_cast< int >(val2);
36214 if (arg1) (arg1)->w = arg2;
36215
36216 resultobj = SWIG_Py_Void();
36217 return resultobj;
36218 fail:
36219 return NULL;
36220 }
36221
36222
36223 SWIGINTERN PyObject *_wrap_VideoMode_w_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36224 PyObject *resultobj = 0;
36225 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36226 int result;
36227 void *argp1 = 0 ;
36228 int res1 = 0 ;
36229 PyObject *swig_obj[1] ;
36230
36231 if (!args) SWIG_fail;
36232 swig_obj[0] = args;
36233 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36234 if (!SWIG_IsOK(res1)) {
36235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36236 }
36237 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36238 result = (int) ((arg1)->w);
36239 resultobj = SWIG_From_int(static_cast< int >(result));
36240 return resultobj;
36241 fail:
36242 return NULL;
36243 }
36244
36245
36246 SWIGINTERN PyObject *_wrap_VideoMode_h_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36247 PyObject *resultobj = 0;
36248 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36249 int arg2 ;
36250 void *argp1 = 0 ;
36251 int res1 = 0 ;
36252 int val2 ;
36253 int ecode2 = 0 ;
36254 PyObject *swig_obj[2] ;
36255
36256 if (!SWIG_Python_UnpackTuple(args,"VideoMode_h_set",2,2,swig_obj)) SWIG_fail;
36257 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36258 if (!SWIG_IsOK(res1)) {
36259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36260 }
36261 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36262 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36263 if (!SWIG_IsOK(ecode2)) {
36264 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_h_set" "', expected argument " "2"" of type '" "int""'");
36265 }
36266 arg2 = static_cast< int >(val2);
36267 if (arg1) (arg1)->h = arg2;
36268
36269 resultobj = SWIG_Py_Void();
36270 return resultobj;
36271 fail:
36272 return NULL;
36273 }
36274
36275
36276 SWIGINTERN PyObject *_wrap_VideoMode_h_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36277 PyObject *resultobj = 0;
36278 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36279 int result;
36280 void *argp1 = 0 ;
36281 int res1 = 0 ;
36282 PyObject *swig_obj[1] ;
36283
36284 if (!args) SWIG_fail;
36285 swig_obj[0] = args;
36286 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36287 if (!SWIG_IsOK(res1)) {
36288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36289 }
36290 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36291 result = (int) ((arg1)->h);
36292 resultobj = SWIG_From_int(static_cast< int >(result));
36293 return resultobj;
36294 fail:
36295 return NULL;
36296 }
36297
36298
36299 SWIGINTERN PyObject *_wrap_VideoMode_bpp_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36300 PyObject *resultobj = 0;
36301 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36302 int arg2 ;
36303 void *argp1 = 0 ;
36304 int res1 = 0 ;
36305 int val2 ;
36306 int ecode2 = 0 ;
36307 PyObject *swig_obj[2] ;
36308
36309 if (!SWIG_Python_UnpackTuple(args,"VideoMode_bpp_set",2,2,swig_obj)) SWIG_fail;
36310 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36311 if (!SWIG_IsOK(res1)) {
36312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36313 }
36314 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36315 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36316 if (!SWIG_IsOK(ecode2)) {
36317 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_bpp_set" "', expected argument " "2"" of type '" "int""'");
36318 }
36319 arg2 = static_cast< int >(val2);
36320 if (arg1) (arg1)->bpp = arg2;
36321
36322 resultobj = SWIG_Py_Void();
36323 return resultobj;
36324 fail:
36325 return NULL;
36326 }
36327
36328
36329 SWIGINTERN PyObject *_wrap_VideoMode_bpp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36330 PyObject *resultobj = 0;
36331 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36332 int result;
36333 void *argp1 = 0 ;
36334 int res1 = 0 ;
36335 PyObject *swig_obj[1] ;
36336
36337 if (!args) SWIG_fail;
36338 swig_obj[0] = args;
36339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36340 if (!SWIG_IsOK(res1)) {
36341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36342 }
36343 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36344 result = (int) ((arg1)->bpp);
36345 resultobj = SWIG_From_int(static_cast< int >(result));
36346 return resultobj;
36347 fail:
36348 return NULL;
36349 }
36350
36351
36352 SWIGINTERN PyObject *_wrap_VideoMode_refresh_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36353 PyObject *resultobj = 0;
36354 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36355 int arg2 ;
36356 void *argp1 = 0 ;
36357 int res1 = 0 ;
36358 int val2 ;
36359 int ecode2 = 0 ;
36360 PyObject *swig_obj[2] ;
36361
36362 if (!SWIG_Python_UnpackTuple(args,"VideoMode_refresh_set",2,2,swig_obj)) SWIG_fail;
36363 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36364 if (!SWIG_IsOK(res1)) {
36365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36366 }
36367 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36368 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36369 if (!SWIG_IsOK(ecode2)) {
36370 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_refresh_set" "', expected argument " "2"" of type '" "int""'");
36371 }
36372 arg2 = static_cast< int >(val2);
36373 if (arg1) (arg1)->refresh = arg2;
36374
36375 resultobj = SWIG_Py_Void();
36376 return resultobj;
36377 fail:
36378 return NULL;
36379 }
36380
36381
36382 SWIGINTERN PyObject *_wrap_VideoMode_refresh_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36383 PyObject *resultobj = 0;
36384 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36385 int result;
36386 void *argp1 = 0 ;
36387 int res1 = 0 ;
36388 PyObject *swig_obj[1] ;
36389
36390 if (!args) SWIG_fail;
36391 swig_obj[0] = args;
36392 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36393 if (!SWIG_IsOK(res1)) {
36394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36395 }
36396 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36397 result = (int) ((arg1)->refresh);
36398 resultobj = SWIG_From_int(static_cast< int >(result));
36399 return resultobj;
36400 fail:
36401 return NULL;
36402 }
36403
36404
36405 SWIGINTERN PyObject *VideoMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36406 PyObject *obj;
36407 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
36408 SWIG_TypeNewClientData(SWIGTYPE_p_wxVideoMode, SWIG_NewClientData(obj));
36409 return SWIG_Py_Void();
36410 }
36411
36412 SWIGINTERN PyObject *VideoMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36413 return SWIG_Python_InitShadowInstance(args);
36414 }
36415
36416 SWIGINTERN int DefaultVideoMode_set(PyObject *) {
36417 SWIG_Error(SWIG_AttributeError,"Variable DefaultVideoMode is read-only.");
36418 return 1;
36419 }
36420
36421
36422 SWIGINTERN PyObject *DefaultVideoMode_get(void) {
36423 PyObject *pyobj = 0;
36424
36425 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0 );
36426 return pyobj;
36427 }
36428
36429
36430 SWIGINTERN PyObject *_wrap_new_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36431 PyObject *resultobj = 0;
36432 unsigned int arg1 = (unsigned int) 0 ;
36433 wxDisplay *result = 0 ;
36434 unsigned int val1 ;
36435 int ecode1 = 0 ;
36436 PyObject * obj0 = 0 ;
36437 char * kwnames[] = {
36438 (char *) "index", NULL
36439 };
36440
36441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) SWIG_fail;
36442 if (obj0) {
36443 ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
36444 if (!SWIG_IsOK(ecode1)) {
36445 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Display" "', expected argument " "1"" of type '" "unsigned int""'");
36446 }
36447 arg1 = static_cast< unsigned int >(val1);
36448 }
36449 {
36450 PyThreadState* __tstate = wxPyBeginAllowThreads();
36451 result = (wxDisplay *)new wxDisplay(arg1);
36452 wxPyEndAllowThreads(__tstate);
36453 if (PyErr_Occurred()) SWIG_fail;
36454 }
36455 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplay, SWIG_POINTER_NEW | 0 );
36456 return resultobj;
36457 fail:
36458 return NULL;
36459 }
36460
36461
36462 SWIGINTERN PyObject *_wrap_delete_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36463 PyObject *resultobj = 0;
36464 wxDisplay *arg1 = (wxDisplay *) 0 ;
36465 void *argp1 = 0 ;
36466 int res1 = 0 ;
36467 PyObject *swig_obj[1] ;
36468
36469 if (!args) SWIG_fail;
36470 swig_obj[0] = args;
36471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, SWIG_POINTER_DISOWN | 0 );
36472 if (!SWIG_IsOK(res1)) {
36473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Display" "', expected argument " "1"" of type '" "wxDisplay *""'");
36474 }
36475 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36476 {
36477 PyThreadState* __tstate = wxPyBeginAllowThreads();
36478 delete arg1;
36479
36480 wxPyEndAllowThreads(__tstate);
36481 if (PyErr_Occurred()) SWIG_fail;
36482 }
36483 resultobj = SWIG_Py_Void();
36484 return resultobj;
36485 fail:
36486 return NULL;
36487 }
36488
36489
36490 SWIGINTERN PyObject *_wrap_Display_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36491 PyObject *resultobj = 0;
36492 unsigned int result;
36493
36494 if (!SWIG_Python_UnpackTuple(args,"Display_GetCount",0,0,0)) SWIG_fail;
36495 {
36496 PyThreadState* __tstate = wxPyBeginAllowThreads();
36497 result = (unsigned int)wxDisplay::GetCount();
36498 wxPyEndAllowThreads(__tstate);
36499 if (PyErr_Occurred()) SWIG_fail;
36500 }
36501 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
36502 return resultobj;
36503 fail:
36504 return NULL;
36505 }
36506
36507
36508 SWIGINTERN PyObject *_wrap_Display_GetFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36509 PyObject *resultobj = 0;
36510 wxPoint *arg1 = 0 ;
36511 int result;
36512 wxPoint temp1 ;
36513 PyObject * obj0 = 0 ;
36514 char * kwnames[] = {
36515 (char *) "pt", NULL
36516 };
36517
36518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) SWIG_fail;
36519 {
36520 arg1 = &temp1;
36521 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
36522 }
36523 {
36524 PyThreadState* __tstate = wxPyBeginAllowThreads();
36525 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
36526 wxPyEndAllowThreads(__tstate);
36527 if (PyErr_Occurred()) SWIG_fail;
36528 }
36529 resultobj = SWIG_From_int(static_cast< int >(result));
36530 return resultobj;
36531 fail:
36532 return NULL;
36533 }
36534
36535
36536 SWIGINTERN PyObject *_wrap_Display_GetFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36537 PyObject *resultobj = 0;
36538 wxWindow *arg1 = (wxWindow *) 0 ;
36539 int result;
36540 void *argp1 = 0 ;
36541 int res1 = 0 ;
36542 PyObject * obj0 = 0 ;
36543 char * kwnames[] = {
36544 (char *) "window", NULL
36545 };
36546
36547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) SWIG_fail;
36548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36549 if (!SWIG_IsOK(res1)) {
36550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36551 }
36552 arg1 = reinterpret_cast< wxWindow * >(argp1);
36553 {
36554 PyThreadState* __tstate = wxPyBeginAllowThreads();
36555 result = (int)wxDisplay::GetFromWindow(arg1);
36556 wxPyEndAllowThreads(__tstate);
36557 if (PyErr_Occurred()) SWIG_fail;
36558 }
36559 resultobj = SWIG_From_int(static_cast< int >(result));
36560 return resultobj;
36561 fail:
36562 return NULL;
36563 }
36564
36565
36566 SWIGINTERN PyObject *_wrap_Display_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36567 PyObject *resultobj = 0;
36568 wxDisplay *arg1 = (wxDisplay *) 0 ;
36569 bool result;
36570 void *argp1 = 0 ;
36571 int res1 = 0 ;
36572 PyObject *swig_obj[1] ;
36573
36574 if (!args) SWIG_fail;
36575 swig_obj[0] = args;
36576 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36577 if (!SWIG_IsOK(res1)) {
36578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsOk" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36579 }
36580 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36581 {
36582 PyThreadState* __tstate = wxPyBeginAllowThreads();
36583 result = (bool)((wxDisplay const *)arg1)->IsOk();
36584 wxPyEndAllowThreads(__tstate);
36585 if (PyErr_Occurred()) SWIG_fail;
36586 }
36587 {
36588 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36589 }
36590 return resultobj;
36591 fail:
36592 return NULL;
36593 }
36594
36595
36596 SWIGINTERN PyObject *_wrap_Display_GetGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36597 PyObject *resultobj = 0;
36598 wxDisplay *arg1 = (wxDisplay *) 0 ;
36599 wxRect result;
36600 void *argp1 = 0 ;
36601 int res1 = 0 ;
36602 PyObject *swig_obj[1] ;
36603
36604 if (!args) SWIG_fail;
36605 swig_obj[0] = args;
36606 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36607 if (!SWIG_IsOK(res1)) {
36608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetGeometry" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36609 }
36610 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36611 {
36612 PyThreadState* __tstate = wxPyBeginAllowThreads();
36613 result = ((wxDisplay const *)arg1)->GetGeometry();
36614 wxPyEndAllowThreads(__tstate);
36615 if (PyErr_Occurred()) SWIG_fail;
36616 }
36617 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
36618 return resultobj;
36619 fail:
36620 return NULL;
36621 }
36622
36623
36624 SWIGINTERN PyObject *_wrap_Display_GetClientArea(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36625 PyObject *resultobj = 0;
36626 wxDisplay *arg1 = (wxDisplay *) 0 ;
36627 wxRect result;
36628 void *argp1 = 0 ;
36629 int res1 = 0 ;
36630 PyObject *swig_obj[1] ;
36631
36632 if (!args) SWIG_fail;
36633 swig_obj[0] = args;
36634 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36635 if (!SWIG_IsOK(res1)) {
36636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetClientArea" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36637 }
36638 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36639 {
36640 PyThreadState* __tstate = wxPyBeginAllowThreads();
36641 result = ((wxDisplay const *)arg1)->GetClientArea();
36642 wxPyEndAllowThreads(__tstate);
36643 if (PyErr_Occurred()) SWIG_fail;
36644 }
36645 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
36646 return resultobj;
36647 fail:
36648 return NULL;
36649 }
36650
36651
36652 SWIGINTERN PyObject *_wrap_Display_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36653 PyObject *resultobj = 0;
36654 wxDisplay *arg1 = (wxDisplay *) 0 ;
36655 wxString result;
36656 void *argp1 = 0 ;
36657 int res1 = 0 ;
36658 PyObject *swig_obj[1] ;
36659
36660 if (!args) SWIG_fail;
36661 swig_obj[0] = args;
36662 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36663 if (!SWIG_IsOK(res1)) {
36664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetName" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36665 }
36666 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36667 {
36668 PyThreadState* __tstate = wxPyBeginAllowThreads();
36669 result = ((wxDisplay const *)arg1)->GetName();
36670 wxPyEndAllowThreads(__tstate);
36671 if (PyErr_Occurred()) SWIG_fail;
36672 }
36673 {
36674 #if wxUSE_UNICODE
36675 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36676 #else
36677 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36678 #endif
36679 }
36680 return resultobj;
36681 fail:
36682 return NULL;
36683 }
36684
36685
36686 SWIGINTERN PyObject *_wrap_Display_IsPrimary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36687 PyObject *resultobj = 0;
36688 wxDisplay *arg1 = (wxDisplay *) 0 ;
36689 bool result;
36690 void *argp1 = 0 ;
36691 int res1 = 0 ;
36692 PyObject *swig_obj[1] ;
36693
36694 if (!args) SWIG_fail;
36695 swig_obj[0] = args;
36696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36697 if (!SWIG_IsOK(res1)) {
36698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsPrimary" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36699 }
36700 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36701 {
36702 PyThreadState* __tstate = wxPyBeginAllowThreads();
36703 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
36704 wxPyEndAllowThreads(__tstate);
36705 if (PyErr_Occurred()) SWIG_fail;
36706 }
36707 {
36708 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36709 }
36710 return resultobj;
36711 fail:
36712 return NULL;
36713 }
36714
36715
36716 SWIGINTERN PyObject *_wrap_Display_GetModes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36717 PyObject *resultobj = 0;
36718 wxDisplay *arg1 = (wxDisplay *) 0 ;
36719 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
36720 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
36721 PyObject *result = 0 ;
36722 void *argp1 = 0 ;
36723 int res1 = 0 ;
36724 void *argp2 = 0 ;
36725 int res2 = 0 ;
36726 PyObject * obj0 = 0 ;
36727 PyObject * obj1 = 0 ;
36728 char * kwnames[] = {
36729 (char *) "self",(char *) "mode", NULL
36730 };
36731
36732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) SWIG_fail;
36733 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36734 if (!SWIG_IsOK(res1)) {
36735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetModes" "', expected argument " "1"" of type '" "wxDisplay *""'");
36736 }
36737 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36738 if (obj1) {
36739 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
36740 if (!SWIG_IsOK(res2)) {
36741 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36742 }
36743 if (!argp2) {
36744 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36745 }
36746 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36747 }
36748 {
36749 PyThreadState* __tstate = wxPyBeginAllowThreads();
36750 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
36751 wxPyEndAllowThreads(__tstate);
36752 if (PyErr_Occurred()) SWIG_fail;
36753 }
36754 resultobj = result;
36755 return resultobj;
36756 fail:
36757 return NULL;
36758 }
36759
36760
36761 SWIGINTERN PyObject *_wrap_Display_GetCurrentMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36762 PyObject *resultobj = 0;
36763 wxDisplay *arg1 = (wxDisplay *) 0 ;
36764 wxVideoMode result;
36765 void *argp1 = 0 ;
36766 int res1 = 0 ;
36767 PyObject *swig_obj[1] ;
36768
36769 if (!args) SWIG_fail;
36770 swig_obj[0] = args;
36771 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36772 if (!SWIG_IsOK(res1)) {
36773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetCurrentMode" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36774 }
36775 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36776 {
36777 PyThreadState* __tstate = wxPyBeginAllowThreads();
36778 result = wxDisplay_GetCurrentMode((wxDisplay const *)arg1);
36779 wxPyEndAllowThreads(__tstate);
36780 if (PyErr_Occurred()) SWIG_fail;
36781 }
36782 resultobj = SWIG_NewPointerObj((new wxVideoMode(static_cast< const wxVideoMode& >(result))), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_OWN | 0 );
36783 return resultobj;
36784 fail:
36785 return NULL;
36786 }
36787
36788
36789 SWIGINTERN PyObject *_wrap_Display_ChangeMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36790 PyObject *resultobj = 0;
36791 wxDisplay *arg1 = (wxDisplay *) 0 ;
36792 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
36793 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
36794 bool result;
36795 void *argp1 = 0 ;
36796 int res1 = 0 ;
36797 void *argp2 = 0 ;
36798 int res2 = 0 ;
36799 PyObject * obj0 = 0 ;
36800 PyObject * obj1 = 0 ;
36801 char * kwnames[] = {
36802 (char *) "self",(char *) "mode", NULL
36803 };
36804
36805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) SWIG_fail;
36806 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36807 if (!SWIG_IsOK(res1)) {
36808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ChangeMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
36809 }
36810 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36811 if (obj1) {
36812 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
36813 if (!SWIG_IsOK(res2)) {
36814 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36815 }
36816 if (!argp2) {
36817 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36818 }
36819 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36820 }
36821 {
36822 PyThreadState* __tstate = wxPyBeginAllowThreads();
36823 result = (bool)wxDisplay_ChangeMode(arg1,(wxVideoMode const &)*arg2);
36824 wxPyEndAllowThreads(__tstate);
36825 if (PyErr_Occurred()) SWIG_fail;
36826 }
36827 {
36828 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36829 }
36830 return resultobj;
36831 fail:
36832 return NULL;
36833 }
36834
36835
36836 SWIGINTERN PyObject *_wrap_Display_ResetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36837 PyObject *resultobj = 0;
36838 wxDisplay *arg1 = (wxDisplay *) 0 ;
36839 void *argp1 = 0 ;
36840 int res1 = 0 ;
36841 PyObject *swig_obj[1] ;
36842
36843 if (!args) SWIG_fail;
36844 swig_obj[0] = args;
36845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36846 if (!SWIG_IsOK(res1)) {
36847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ResetMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
36848 }
36849 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36850 {
36851 PyThreadState* __tstate = wxPyBeginAllowThreads();
36852 wxDisplay_ResetMode(arg1);
36853 wxPyEndAllowThreads(__tstate);
36854 if (PyErr_Occurred()) SWIG_fail;
36855 }
36856 resultobj = SWIG_Py_Void();
36857 return resultobj;
36858 fail:
36859 return NULL;
36860 }
36861
36862
36863 SWIGINTERN PyObject *Display_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36864 PyObject *obj;
36865 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
36866 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplay, SWIG_NewClientData(obj));
36867 return SWIG_Py_Void();
36868 }
36869
36870 SWIGINTERN PyObject *Display_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36871 return SWIG_Python_InitShadowInstance(args);
36872 }
36873
36874 SWIGINTERN PyObject *_wrap_StandardPaths_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36875 PyObject *resultobj = 0;
36876 wxStandardPaths *result = 0 ;
36877
36878 if (!SWIG_Python_UnpackTuple(args,"StandardPaths_Get",0,0,0)) SWIG_fail;
36879 {
36880 PyThreadState* __tstate = wxPyBeginAllowThreads();
36881 result = (wxStandardPaths *)wxStandardPaths_Get();
36882 wxPyEndAllowThreads(__tstate);
36883 if (PyErr_Occurred()) SWIG_fail;
36884 }
36885 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36886 return resultobj;
36887 fail:
36888 return NULL;
36889 }
36890
36891
36892 SWIGINTERN PyObject *_wrap_StandardPaths_GetExecutablePath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36893 PyObject *resultobj = 0;
36894 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36895 wxString result;
36896 void *argp1 = 0 ;
36897 int res1 = 0 ;
36898 PyObject *swig_obj[1] ;
36899
36900 if (!args) SWIG_fail;
36901 swig_obj[0] = args;
36902 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36903 if (!SWIG_IsOK(res1)) {
36904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetExecutablePath" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36905 }
36906 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36907 {
36908 PyThreadState* __tstate = wxPyBeginAllowThreads();
36909 result = ((wxStandardPaths const *)arg1)->GetExecutablePath();
36910 wxPyEndAllowThreads(__tstate);
36911 if (PyErr_Occurred()) SWIG_fail;
36912 }
36913 {
36914 #if wxUSE_UNICODE
36915 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36916 #else
36917 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36918 #endif
36919 }
36920 return resultobj;
36921 fail:
36922 return NULL;
36923 }
36924
36925
36926 SWIGINTERN PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36927 PyObject *resultobj = 0;
36928 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36929 wxString result;
36930 void *argp1 = 0 ;
36931 int res1 = 0 ;
36932 PyObject *swig_obj[1] ;
36933
36934 if (!args) SWIG_fail;
36935 swig_obj[0] = args;
36936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36937 if (!SWIG_IsOK(res1)) {
36938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36939 }
36940 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36941 {
36942 PyThreadState* __tstate = wxPyBeginAllowThreads();
36943 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
36944 wxPyEndAllowThreads(__tstate);
36945 if (PyErr_Occurred()) SWIG_fail;
36946 }
36947 {
36948 #if wxUSE_UNICODE
36949 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36950 #else
36951 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36952 #endif
36953 }
36954 return resultobj;
36955 fail:
36956 return NULL;
36957 }
36958
36959
36960 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36961 PyObject *resultobj = 0;
36962 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36963 wxString result;
36964 void *argp1 = 0 ;
36965 int res1 = 0 ;
36966 PyObject *swig_obj[1] ;
36967
36968 if (!args) SWIG_fail;
36969 swig_obj[0] = args;
36970 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36971 if (!SWIG_IsOK(res1)) {
36972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36973 }
36974 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36975 {
36976 PyThreadState* __tstate = wxPyBeginAllowThreads();
36977 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
36978 wxPyEndAllowThreads(__tstate);
36979 if (PyErr_Occurred()) SWIG_fail;
36980 }
36981 {
36982 #if wxUSE_UNICODE
36983 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36984 #else
36985 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36986 #endif
36987 }
36988 return resultobj;
36989 fail:
36990 return NULL;
36991 }
36992
36993
36994 SWIGINTERN PyObject *_wrap_StandardPaths_GetDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36995 PyObject *resultobj = 0;
36996 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36997 wxString result;
36998 void *argp1 = 0 ;
36999 int res1 = 0 ;
37000 PyObject *swig_obj[1] ;
37001
37002 if (!args) SWIG_fail;
37003 swig_obj[0] = args;
37004 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37005 if (!SWIG_IsOK(res1)) {
37006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37007 }
37008 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37009 {
37010 PyThreadState* __tstate = wxPyBeginAllowThreads();
37011 result = ((wxStandardPaths const *)arg1)->GetDataDir();
37012 wxPyEndAllowThreads(__tstate);
37013 if (PyErr_Occurred()) SWIG_fail;
37014 }
37015 {
37016 #if wxUSE_UNICODE
37017 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37018 #else
37019 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37020 #endif
37021 }
37022 return resultobj;
37023 fail:
37024 return NULL;
37025 }
37026
37027
37028 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37029 PyObject *resultobj = 0;
37030 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37031 wxString result;
37032 void *argp1 = 0 ;
37033 int res1 = 0 ;
37034 PyObject *swig_obj[1] ;
37035
37036 if (!args) SWIG_fail;
37037 swig_obj[0] = args;
37038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37039 if (!SWIG_IsOK(res1)) {
37040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37041 }
37042 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37043 {
37044 PyThreadState* __tstate = wxPyBeginAllowThreads();
37045 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
37046 wxPyEndAllowThreads(__tstate);
37047 if (PyErr_Occurred()) SWIG_fail;
37048 }
37049 {
37050 #if wxUSE_UNICODE
37051 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37052 #else
37053 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37054 #endif
37055 }
37056 return resultobj;
37057 fail:
37058 return NULL;
37059 }
37060
37061
37062 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37063 PyObject *resultobj = 0;
37064 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37065 wxString result;
37066 void *argp1 = 0 ;
37067 int res1 = 0 ;
37068 PyObject *swig_obj[1] ;
37069
37070 if (!args) SWIG_fail;
37071 swig_obj[0] = args;
37072 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37073 if (!SWIG_IsOK(res1)) {
37074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37075 }
37076 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37077 {
37078 PyThreadState* __tstate = wxPyBeginAllowThreads();
37079 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
37080 wxPyEndAllowThreads(__tstate);
37081 if (PyErr_Occurred()) SWIG_fail;
37082 }
37083 {
37084 #if wxUSE_UNICODE
37085 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37086 #else
37087 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37088 #endif
37089 }
37090 return resultobj;
37091 fail:
37092 return NULL;
37093 }
37094
37095
37096 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37097 PyObject *resultobj = 0;
37098 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37099 wxString result;
37100 void *argp1 = 0 ;
37101 int res1 = 0 ;
37102 PyObject *swig_obj[1] ;
37103
37104 if (!args) SWIG_fail;
37105 swig_obj[0] = args;
37106 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37107 if (!SWIG_IsOK(res1)) {
37108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37109 }
37110 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37111 {
37112 PyThreadState* __tstate = wxPyBeginAllowThreads();
37113 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
37114 wxPyEndAllowThreads(__tstate);
37115 if (PyErr_Occurred()) SWIG_fail;
37116 }
37117 {
37118 #if wxUSE_UNICODE
37119 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37120 #else
37121 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37122 #endif
37123 }
37124 return resultobj;
37125 fail:
37126 return NULL;
37127 }
37128
37129
37130 SWIGINTERN PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37131 PyObject *resultobj = 0;
37132 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37133 wxString result;
37134 void *argp1 = 0 ;
37135 int res1 = 0 ;
37136 PyObject *swig_obj[1] ;
37137
37138 if (!args) SWIG_fail;
37139 swig_obj[0] = args;
37140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37141 if (!SWIG_IsOK(res1)) {
37142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetPluginsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37143 }
37144 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37145 {
37146 PyThreadState* __tstate = wxPyBeginAllowThreads();
37147 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
37148 wxPyEndAllowThreads(__tstate);
37149 if (PyErr_Occurred()) SWIG_fail;
37150 }
37151 {
37152 #if wxUSE_UNICODE
37153 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37154 #else
37155 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37156 #endif
37157 }
37158 return resultobj;
37159 fail:
37160 return NULL;
37161 }
37162
37163
37164 SWIGINTERN PyObject *_wrap_StandardPaths_GetResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37165 PyObject *resultobj = 0;
37166 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37167 wxString result;
37168 void *argp1 = 0 ;
37169 int res1 = 0 ;
37170 PyObject *swig_obj[1] ;
37171
37172 if (!args) SWIG_fail;
37173 swig_obj[0] = args;
37174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37175 if (!SWIG_IsOK(res1)) {
37176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37177 }
37178 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37179 {
37180 PyThreadState* __tstate = wxPyBeginAllowThreads();
37181 result = ((wxStandardPaths const *)arg1)->GetResourcesDir();
37182 wxPyEndAllowThreads(__tstate);
37183 if (PyErr_Occurred()) SWIG_fail;
37184 }
37185 {
37186 #if wxUSE_UNICODE
37187 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37188 #else
37189 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37190 #endif
37191 }
37192 return resultobj;
37193 fail:
37194 return NULL;
37195 }
37196
37197
37198 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalizedResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37199 PyObject *resultobj = 0;
37200 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37201 wxString *arg2 = 0 ;
37202 wxStandardPaths::ResourceCat arg3 = (wxStandardPaths::ResourceCat) wxStandardPaths::ResourceCat_None ;
37203 wxString result;
37204 void *argp1 = 0 ;
37205 int res1 = 0 ;
37206 bool temp2 = false ;
37207 int val3 ;
37208 int ecode3 = 0 ;
37209 PyObject * obj0 = 0 ;
37210 PyObject * obj1 = 0 ;
37211 PyObject * obj2 = 0 ;
37212 char * kwnames[] = {
37213 (char *) "self",(char *) "lang",(char *) "category", NULL
37214 };
37215
37216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:StandardPaths_GetLocalizedResourcesDir",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37218 if (!SWIG_IsOK(res1)) {
37219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37220 }
37221 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37222 {
37223 arg2 = wxString_in_helper(obj1);
37224 if (arg2 == NULL) SWIG_fail;
37225 temp2 = true;
37226 }
37227 if (obj2) {
37228 ecode3 = SWIG_AsVal_int(obj2, &val3);
37229 if (!SWIG_IsOK(ecode3)) {
37230 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "3"" of type '" "wxStandardPaths::ResourceCat""'");
37231 }
37232 arg3 = static_cast< wxStandardPaths::ResourceCat >(val3);
37233 }
37234 {
37235 PyThreadState* __tstate = wxPyBeginAllowThreads();
37236 result = ((wxStandardPaths const *)arg1)->GetLocalizedResourcesDir((wxString const &)*arg2,arg3);
37237 wxPyEndAllowThreads(__tstate);
37238 if (PyErr_Occurred()) SWIG_fail;
37239 }
37240 {
37241 #if wxUSE_UNICODE
37242 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37243 #else
37244 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37245 #endif
37246 }
37247 {
37248 if (temp2)
37249 delete arg2;
37250 }
37251 return resultobj;
37252 fail:
37253 {
37254 if (temp2)
37255 delete arg2;
37256 }
37257 return NULL;
37258 }
37259
37260
37261 SWIGINTERN PyObject *_wrap_StandardPaths_GetDocumentsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37262 PyObject *resultobj = 0;
37263 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37264 wxString result;
37265 void *argp1 = 0 ;
37266 int res1 = 0 ;
37267 PyObject *swig_obj[1] ;
37268
37269 if (!args) SWIG_fail;
37270 swig_obj[0] = args;
37271 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37272 if (!SWIG_IsOK(res1)) {
37273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDocumentsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37274 }
37275 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37276 {
37277 PyThreadState* __tstate = wxPyBeginAllowThreads();
37278 result = ((wxStandardPaths const *)arg1)->GetDocumentsDir();
37279 wxPyEndAllowThreads(__tstate);
37280 if (PyErr_Occurred()) SWIG_fail;
37281 }
37282 {
37283 #if wxUSE_UNICODE
37284 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37285 #else
37286 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37287 #endif
37288 }
37289 return resultobj;
37290 fail:
37291 return NULL;
37292 }
37293
37294
37295 SWIGINTERN PyObject *_wrap_StandardPaths_GetTempDir(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_GetTempDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37308 }
37309 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37310 {
37311 PyThreadState* __tstate = wxPyBeginAllowThreads();
37312 result = ((wxStandardPaths const *)arg1)->GetTempDir();
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 *_wrap_StandardPaths_SetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37330 PyObject *resultobj = 0;
37331 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37332 wxString *arg2 = 0 ;
37333 void *argp1 = 0 ;
37334 int res1 = 0 ;
37335 bool temp2 = false ;
37336 PyObject * obj0 = 0 ;
37337 PyObject * obj1 = 0 ;
37338 char * kwnames[] = {
37339 (char *) "self",(char *) "prefix", NULL
37340 };
37341
37342 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) SWIG_fail;
37343 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37344 if (!SWIG_IsOK(res1)) {
37345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_SetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths *""'");
37346 }
37347 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37348 {
37349 arg2 = wxString_in_helper(obj1);
37350 if (arg2 == NULL) SWIG_fail;
37351 temp2 = true;
37352 }
37353 {
37354 PyThreadState* __tstate = wxPyBeginAllowThreads();
37355 (arg1)->SetInstallPrefix((wxString const &)*arg2);
37356 wxPyEndAllowThreads(__tstate);
37357 if (PyErr_Occurred()) SWIG_fail;
37358 }
37359 resultobj = SWIG_Py_Void();
37360 {
37361 if (temp2)
37362 delete arg2;
37363 }
37364 return resultobj;
37365 fail:
37366 {
37367 if (temp2)
37368 delete arg2;
37369 }
37370 return NULL;
37371 }
37372
37373
37374 SWIGINTERN PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37375 PyObject *resultobj = 0;
37376 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37377 wxString result;
37378 void *argp1 = 0 ;
37379 int res1 = 0 ;
37380 PyObject *swig_obj[1] ;
37381
37382 if (!args) SWIG_fail;
37383 swig_obj[0] = args;
37384 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37385 if (!SWIG_IsOK(res1)) {
37386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37387 }
37388 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37389 {
37390 PyThreadState* __tstate = wxPyBeginAllowThreads();
37391 result = ((wxStandardPaths const *)arg1)->GetInstallPrefix();
37392 wxPyEndAllowThreads(__tstate);
37393 if (PyErr_Occurred()) SWIG_fail;
37394 }
37395 {
37396 #if wxUSE_UNICODE
37397 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37398 #else
37399 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37400 #endif
37401 }
37402 return resultobj;
37403 fail:
37404 return NULL;
37405 }
37406
37407
37408 SWIGINTERN PyObject *StandardPaths_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37409 PyObject *obj;
37410 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37411 SWIG_TypeNewClientData(SWIGTYPE_p_wxStandardPaths, SWIG_NewClientData(obj));
37412 return SWIG_Py_Void();
37413 }
37414
37415 SWIGINTERN PyObject *_wrap_new_PowerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37416 PyObject *resultobj = 0;
37417 wxEventType arg1 ;
37418 wxPowerEvent *result = 0 ;
37419 int val1 ;
37420 int ecode1 = 0 ;
37421 PyObject * obj0 = 0 ;
37422 char * kwnames[] = {
37423 (char *) "evtType", NULL
37424 };
37425
37426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PowerEvent",kwnames,&obj0)) SWIG_fail;
37427 ecode1 = SWIG_AsVal_int(obj0, &val1);
37428 if (!SWIG_IsOK(ecode1)) {
37429 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PowerEvent" "', expected argument " "1"" of type '" "wxEventType""'");
37430 }
37431 arg1 = static_cast< wxEventType >(val1);
37432 {
37433 PyThreadState* __tstate = wxPyBeginAllowThreads();
37434 result = (wxPowerEvent *)new wxPowerEvent(arg1);
37435 wxPyEndAllowThreads(__tstate);
37436 if (PyErr_Occurred()) SWIG_fail;
37437 }
37438 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPowerEvent, SWIG_POINTER_NEW | 0 );
37439 return resultobj;
37440 fail:
37441 return NULL;
37442 }
37443
37444
37445 SWIGINTERN PyObject *_wrap_PowerEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37446 PyObject *resultobj = 0;
37447 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
37448 void *argp1 = 0 ;
37449 int res1 = 0 ;
37450 PyObject *swig_obj[1] ;
37451
37452 if (!args) SWIG_fail;
37453 swig_obj[0] = args;
37454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPowerEvent, 0 | 0 );
37455 if (!SWIG_IsOK(res1)) {
37456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_Veto" "', expected argument " "1"" of type '" "wxPowerEvent *""'");
37457 }
37458 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
37459 {
37460 PyThreadState* __tstate = wxPyBeginAllowThreads();
37461 (arg1)->Veto();
37462 wxPyEndAllowThreads(__tstate);
37463 if (PyErr_Occurred()) SWIG_fail;
37464 }
37465 resultobj = SWIG_Py_Void();
37466 return resultobj;
37467 fail:
37468 return NULL;
37469 }
37470
37471
37472 SWIGINTERN PyObject *_wrap_PowerEvent_IsVetoed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37473 PyObject *resultobj = 0;
37474 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
37475 bool result;
37476 void *argp1 = 0 ;
37477 int res1 = 0 ;
37478 PyObject *swig_obj[1] ;
37479
37480 if (!args) SWIG_fail;
37481 swig_obj[0] = args;
37482 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPowerEvent, 0 | 0 );
37483 if (!SWIG_IsOK(res1)) {
37484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_IsVetoed" "', expected argument " "1"" of type '" "wxPowerEvent const *""'");
37485 }
37486 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
37487 {
37488 PyThreadState* __tstate = wxPyBeginAllowThreads();
37489 result = (bool)((wxPowerEvent const *)arg1)->IsVetoed();
37490 wxPyEndAllowThreads(__tstate);
37491 if (PyErr_Occurred()) SWIG_fail;
37492 }
37493 {
37494 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37495 }
37496 return resultobj;
37497 fail:
37498 return NULL;
37499 }
37500
37501
37502 SWIGINTERN PyObject *PowerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37503 PyObject *obj;
37504 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37505 SWIG_TypeNewClientData(SWIGTYPE_p_wxPowerEvent, SWIG_NewClientData(obj));
37506 return SWIG_Py_Void();
37507 }
37508
37509 SWIGINTERN PyObject *PowerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37510 return SWIG_Python_InitShadowInstance(args);
37511 }
37512
37513 SWIGINTERN PyObject *_wrap_GetPowerType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37514 PyObject *resultobj = 0;
37515 wxPowerType result;
37516
37517 if (!SWIG_Python_UnpackTuple(args,"GetPowerType",0,0,0)) SWIG_fail;
37518 {
37519 PyThreadState* __tstate = wxPyBeginAllowThreads();
37520 result = (wxPowerType)wxGetPowerType();
37521 wxPyEndAllowThreads(__tstate);
37522 if (PyErr_Occurred()) SWIG_fail;
37523 }
37524 resultobj = SWIG_From_int(static_cast< int >(result));
37525 return resultobj;
37526 fail:
37527 return NULL;
37528 }
37529
37530
37531 SWIGINTERN PyObject *_wrap_GetBatteryState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37532 PyObject *resultobj = 0;
37533 wxBatteryState result;
37534
37535 if (!SWIG_Python_UnpackTuple(args,"GetBatteryState",0,0,0)) SWIG_fail;
37536 {
37537 PyThreadState* __tstate = wxPyBeginAllowThreads();
37538 result = (wxBatteryState)wxGetBatteryState();
37539 wxPyEndAllowThreads(__tstate);
37540 if (PyErr_Occurred()) SWIG_fail;
37541 }
37542 resultobj = SWIG_From_int(static_cast< int >(result));
37543 return resultobj;
37544 fail:
37545 return NULL;
37546 }
37547
37548
37549 SWIGINTERN PyObject *_wrap_new_AboutDialogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37550 PyObject *resultobj = 0;
37551 wxAboutDialogInfo *result = 0 ;
37552
37553 if (!SWIG_Python_UnpackTuple(args,"new_AboutDialogInfo",0,0,0)) SWIG_fail;
37554 {
37555 PyThreadState* __tstate = wxPyBeginAllowThreads();
37556 result = (wxAboutDialogInfo *)new wxAboutDialogInfo();
37557 wxPyEndAllowThreads(__tstate);
37558 if (PyErr_Occurred()) SWIG_fail;
37559 }
37560 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAboutDialogInfo, SWIG_POINTER_NEW | 0 );
37561 return resultobj;
37562 fail:
37563 return NULL;
37564 }
37565
37566
37567 SWIGINTERN PyObject *_wrap_delete_AboutDialogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37568 PyObject *resultobj = 0;
37569 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37570 void *argp1 = 0 ;
37571 int res1 = 0 ;
37572 PyObject *swig_obj[1] ;
37573
37574 if (!args) SWIG_fail;
37575 swig_obj[0] = args;
37576 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, SWIG_POINTER_DISOWN | 0 );
37577 if (!SWIG_IsOK(res1)) {
37578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AboutDialogInfo" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37579 }
37580 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37581 {
37582 PyThreadState* __tstate = wxPyBeginAllowThreads();
37583 delete arg1;
37584
37585 wxPyEndAllowThreads(__tstate);
37586 if (PyErr_Occurred()) SWIG_fail;
37587 }
37588 resultobj = SWIG_Py_Void();
37589 return resultobj;
37590 fail:
37591 return NULL;
37592 }
37593
37594
37595 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetName(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 *) "name", NULL
37606 };
37607
37608 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetName",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_SetName" "', 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)->SetName((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_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37641 PyObject *resultobj = 0;
37642 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37643 wxString 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_GetName" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37653 }
37654 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37655 {
37656 PyThreadState* __tstate = wxPyBeginAllowThreads();
37657 result = ((wxAboutDialogInfo const *)arg1)->GetName();
37658 wxPyEndAllowThreads(__tstate);
37659 if (PyErr_Occurred()) SWIG_fail;
37660 }
37661 {
37662 #if wxUSE_UNICODE
37663 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37664 #else
37665 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37666 #endif
37667 }
37668 return resultobj;
37669 fail:
37670 return NULL;
37671 }
37672
37673
37674 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37675 PyObject *resultobj = 0;
37676 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37677 wxString *arg2 = 0 ;
37678 void *argp1 = 0 ;
37679 int res1 = 0 ;
37680 bool temp2 = false ;
37681 PyObject * obj0 = 0 ;
37682 PyObject * obj1 = 0 ;
37683 char * kwnames[] = {
37684 (char *) "self",(char *) "version", NULL
37685 };
37686
37687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetVersion",kwnames,&obj0,&obj1)) SWIG_fail;
37688 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37689 if (!SWIG_IsOK(res1)) {
37690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetVersion" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37691 }
37692 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37693 {
37694 arg2 = wxString_in_helper(obj1);
37695 if (arg2 == NULL) SWIG_fail;
37696 temp2 = true;
37697 }
37698 {
37699 PyThreadState* __tstate = wxPyBeginAllowThreads();
37700 (arg1)->SetVersion((wxString const &)*arg2);
37701 wxPyEndAllowThreads(__tstate);
37702 if (PyErr_Occurred()) SWIG_fail;
37703 }
37704 resultobj = SWIG_Py_Void();
37705 {
37706 if (temp2)
37707 delete arg2;
37708 }
37709 return resultobj;
37710 fail:
37711 {
37712 if (temp2)
37713 delete arg2;
37714 }
37715 return NULL;
37716 }
37717
37718
37719 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37720 PyObject *resultobj = 0;
37721 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37722 bool result;
37723 void *argp1 = 0 ;
37724 int res1 = 0 ;
37725 PyObject *swig_obj[1] ;
37726
37727 if (!args) SWIG_fail;
37728 swig_obj[0] = args;
37729 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37730 if (!SWIG_IsOK(res1)) {
37731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasVersion" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37732 }
37733 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37734 {
37735 PyThreadState* __tstate = wxPyBeginAllowThreads();
37736 result = (bool)((wxAboutDialogInfo const *)arg1)->HasVersion();
37737 wxPyEndAllowThreads(__tstate);
37738 if (PyErr_Occurred()) SWIG_fail;
37739 }
37740 {
37741 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37742 }
37743 return resultobj;
37744 fail:
37745 return NULL;
37746 }
37747
37748
37749 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37750 PyObject *resultobj = 0;
37751 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37752 wxString 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_GetVersion" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37762 }
37763 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37764 {
37765 PyThreadState* __tstate = wxPyBeginAllowThreads();
37766 result = ((wxAboutDialogInfo const *)arg1)->GetVersion();
37767 wxPyEndAllowThreads(__tstate);
37768 if (PyErr_Occurred()) SWIG_fail;
37769 }
37770 {
37771 #if wxUSE_UNICODE
37772 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37773 #else
37774 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37775 #endif
37776 }
37777 return resultobj;
37778 fail:
37779 return NULL;
37780 }
37781
37782
37783 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37784 PyObject *resultobj = 0;
37785 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37786 wxString *arg2 = 0 ;
37787 void *argp1 = 0 ;
37788 int res1 = 0 ;
37789 bool temp2 = false ;
37790 PyObject * obj0 = 0 ;
37791 PyObject * obj1 = 0 ;
37792 char * kwnames[] = {
37793 (char *) "self",(char *) "desc", NULL
37794 };
37795
37796 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetDescription",kwnames,&obj0,&obj1)) SWIG_fail;
37797 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37798 if (!SWIG_IsOK(res1)) {
37799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37800 }
37801 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37802 {
37803 arg2 = wxString_in_helper(obj1);
37804 if (arg2 == NULL) SWIG_fail;
37805 temp2 = true;
37806 }
37807 {
37808 PyThreadState* __tstate = wxPyBeginAllowThreads();
37809 (arg1)->SetDescription((wxString const &)*arg2);
37810 wxPyEndAllowThreads(__tstate);
37811 if (PyErr_Occurred()) SWIG_fail;
37812 }
37813 resultobj = SWIG_Py_Void();
37814 {
37815 if (temp2)
37816 delete arg2;
37817 }
37818 return resultobj;
37819 fail:
37820 {
37821 if (temp2)
37822 delete arg2;
37823 }
37824 return NULL;
37825 }
37826
37827
37828 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37829 PyObject *resultobj = 0;
37830 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37831 bool result;
37832 void *argp1 = 0 ;
37833 int res1 = 0 ;
37834 PyObject *swig_obj[1] ;
37835
37836 if (!args) SWIG_fail;
37837 swig_obj[0] = args;
37838 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37839 if (!SWIG_IsOK(res1)) {
37840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37841 }
37842 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37843 {
37844 PyThreadState* __tstate = wxPyBeginAllowThreads();
37845 result = (bool)((wxAboutDialogInfo const *)arg1)->HasDescription();
37846 wxPyEndAllowThreads(__tstate);
37847 if (PyErr_Occurred()) SWIG_fail;
37848 }
37849 {
37850 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37851 }
37852 return resultobj;
37853 fail:
37854 return NULL;
37855 }
37856
37857
37858 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37859 PyObject *resultobj = 0;
37860 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37861 wxString 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_GetDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37871 }
37872 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37873 {
37874 PyThreadState* __tstate = wxPyBeginAllowThreads();
37875 result = ((wxAboutDialogInfo const *)arg1)->GetDescription();
37876 wxPyEndAllowThreads(__tstate);
37877 if (PyErr_Occurred()) SWIG_fail;
37878 }
37879 {
37880 #if wxUSE_UNICODE
37881 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37882 #else
37883 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37884 #endif
37885 }
37886 return resultobj;
37887 fail:
37888 return NULL;
37889 }
37890
37891
37892 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetCopyright(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37893 PyObject *resultobj = 0;
37894 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37895 wxString *arg2 = 0 ;
37896 void *argp1 = 0 ;
37897 int res1 = 0 ;
37898 bool temp2 = false ;
37899 PyObject * obj0 = 0 ;
37900 PyObject * obj1 = 0 ;
37901 char * kwnames[] = {
37902 (char *) "self",(char *) "copyright", NULL
37903 };
37904
37905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetCopyright",kwnames,&obj0,&obj1)) SWIG_fail;
37906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37907 if (!SWIG_IsOK(res1)) {
37908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetCopyright" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37909 }
37910 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37911 {
37912 arg2 = wxString_in_helper(obj1);
37913 if (arg2 == NULL) SWIG_fail;
37914 temp2 = true;
37915 }
37916 {
37917 PyThreadState* __tstate = wxPyBeginAllowThreads();
37918 (arg1)->SetCopyright((wxString const &)*arg2);
37919 wxPyEndAllowThreads(__tstate);
37920 if (PyErr_Occurred()) SWIG_fail;
37921 }
37922 resultobj = SWIG_Py_Void();
37923 {
37924 if (temp2)
37925 delete arg2;
37926 }
37927 return resultobj;
37928 fail:
37929 {
37930 if (temp2)
37931 delete arg2;
37932 }
37933 return NULL;
37934 }
37935
37936
37937 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasCopyright(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37938 PyObject *resultobj = 0;
37939 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37940 bool result;
37941 void *argp1 = 0 ;
37942 int res1 = 0 ;
37943 PyObject *swig_obj[1] ;
37944
37945 if (!args) SWIG_fail;
37946 swig_obj[0] = args;
37947 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37948 if (!SWIG_IsOK(res1)) {
37949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasCopyright" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37950 }
37951 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37952 {
37953 PyThreadState* __tstate = wxPyBeginAllowThreads();
37954 result = (bool)((wxAboutDialogInfo const *)arg1)->HasCopyright();
37955 wxPyEndAllowThreads(__tstate);
37956 if (PyErr_Occurred()) SWIG_fail;
37957 }
37958 {
37959 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37960 }
37961 return resultobj;
37962 fail:
37963 return NULL;
37964 }
37965
37966
37967 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetCopyright(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37968 PyObject *resultobj = 0;
37969 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37970 wxString result;
37971 void *argp1 = 0 ;
37972 int res1 = 0 ;
37973 PyObject *swig_obj[1] ;
37974
37975 if (!args) SWIG_fail;
37976 swig_obj[0] = args;
37977 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37978 if (!SWIG_IsOK(res1)) {
37979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetCopyright" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37980 }
37981 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37982 {
37983 PyThreadState* __tstate = wxPyBeginAllowThreads();
37984 result = ((wxAboutDialogInfo const *)arg1)->GetCopyright();
37985 wxPyEndAllowThreads(__tstate);
37986 if (PyErr_Occurred()) SWIG_fail;
37987 }
37988 {
37989 #if wxUSE_UNICODE
37990 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37991 #else
37992 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37993 #endif
37994 }
37995 return resultobj;
37996 fail:
37997 return NULL;
37998 }
37999
38000
38001 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetLicence(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38002 PyObject *resultobj = 0;
38003 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38004 wxString *arg2 = 0 ;
38005 void *argp1 = 0 ;
38006 int res1 = 0 ;
38007 bool temp2 = false ;
38008 PyObject * obj0 = 0 ;
38009 PyObject * obj1 = 0 ;
38010 char * kwnames[] = {
38011 (char *) "self",(char *) "licence", NULL
38012 };
38013
38014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetLicence",kwnames,&obj0,&obj1)) SWIG_fail;
38015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38016 if (!SWIG_IsOK(res1)) {
38017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetLicence" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38018 }
38019 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38020 {
38021 arg2 = wxString_in_helper(obj1);
38022 if (arg2 == NULL) SWIG_fail;
38023 temp2 = true;
38024 }
38025 {
38026 PyThreadState* __tstate = wxPyBeginAllowThreads();
38027 (arg1)->SetLicence((wxString const &)*arg2);
38028 wxPyEndAllowThreads(__tstate);
38029 if (PyErr_Occurred()) SWIG_fail;
38030 }
38031 resultobj = SWIG_Py_Void();
38032 {
38033 if (temp2)
38034 delete arg2;
38035 }
38036 return resultobj;
38037 fail:
38038 {
38039 if (temp2)
38040 delete arg2;
38041 }
38042 return NULL;
38043 }
38044
38045
38046 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetLicense(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38047 PyObject *resultobj = 0;
38048 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38049 wxString *arg2 = 0 ;
38050 void *argp1 = 0 ;
38051 int res1 = 0 ;
38052 bool temp2 = false ;
38053 PyObject * obj0 = 0 ;
38054 PyObject * obj1 = 0 ;
38055 char * kwnames[] = {
38056 (char *) "self",(char *) "licence", NULL
38057 };
38058
38059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetLicense",kwnames,&obj0,&obj1)) SWIG_fail;
38060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38061 if (!SWIG_IsOK(res1)) {
38062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetLicense" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38063 }
38064 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38065 {
38066 arg2 = wxString_in_helper(obj1);
38067 if (arg2 == NULL) SWIG_fail;
38068 temp2 = true;
38069 }
38070 {
38071 PyThreadState* __tstate = wxPyBeginAllowThreads();
38072 (arg1)->SetLicense((wxString const &)*arg2);
38073 wxPyEndAllowThreads(__tstate);
38074 if (PyErr_Occurred()) SWIG_fail;
38075 }
38076 resultobj = SWIG_Py_Void();
38077 {
38078 if (temp2)
38079 delete arg2;
38080 }
38081 return resultobj;
38082 fail:
38083 {
38084 if (temp2)
38085 delete arg2;
38086 }
38087 return NULL;
38088 }
38089
38090
38091 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasLicence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38092 PyObject *resultobj = 0;
38093 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38094 bool result;
38095 void *argp1 = 0 ;
38096 int res1 = 0 ;
38097 PyObject *swig_obj[1] ;
38098
38099 if (!args) SWIG_fail;
38100 swig_obj[0] = args;
38101 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38102 if (!SWIG_IsOK(res1)) {
38103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasLicence" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38104 }
38105 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38106 {
38107 PyThreadState* __tstate = wxPyBeginAllowThreads();
38108 result = (bool)((wxAboutDialogInfo const *)arg1)->HasLicence();
38109 wxPyEndAllowThreads(__tstate);
38110 if (PyErr_Occurred()) SWIG_fail;
38111 }
38112 {
38113 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38114 }
38115 return resultobj;
38116 fail:
38117 return NULL;
38118 }
38119
38120
38121 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetLicence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38122 PyObject *resultobj = 0;
38123 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38124 wxString result;
38125 void *argp1 = 0 ;
38126 int res1 = 0 ;
38127 PyObject *swig_obj[1] ;
38128
38129 if (!args) SWIG_fail;
38130 swig_obj[0] = args;
38131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38132 if (!SWIG_IsOK(res1)) {
38133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetLicence" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38134 }
38135 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38136 {
38137 PyThreadState* __tstate = wxPyBeginAllowThreads();
38138 result = ((wxAboutDialogInfo const *)arg1)->GetLicence();
38139 wxPyEndAllowThreads(__tstate);
38140 if (PyErr_Occurred()) SWIG_fail;
38141 }
38142 {
38143 #if wxUSE_UNICODE
38144 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38145 #else
38146 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38147 #endif
38148 }
38149 return resultobj;
38150 fail:
38151 return NULL;
38152 }
38153
38154
38155 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38156 PyObject *resultobj = 0;
38157 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38158 wxIcon *arg2 = 0 ;
38159 void *argp1 = 0 ;
38160 int res1 = 0 ;
38161 void *argp2 = 0 ;
38162 int res2 = 0 ;
38163 PyObject * obj0 = 0 ;
38164 PyObject * obj1 = 0 ;
38165 char * kwnames[] = {
38166 (char *) "self",(char *) "icon", NULL
38167 };
38168
38169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetIcon",kwnames,&obj0,&obj1)) SWIG_fail;
38170 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38171 if (!SWIG_IsOK(res1)) {
38172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetIcon" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38173 }
38174 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38175 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxIcon, 0 | 0);
38176 if (!SWIG_IsOK(res2)) {
38177 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AboutDialogInfo_SetIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
38178 }
38179 if (!argp2) {
38180 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AboutDialogInfo_SetIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
38181 }
38182 arg2 = reinterpret_cast< wxIcon * >(argp2);
38183 {
38184 PyThreadState* __tstate = wxPyBeginAllowThreads();
38185 (arg1)->SetIcon((wxIcon const &)*arg2);
38186 wxPyEndAllowThreads(__tstate);
38187 if (PyErr_Occurred()) SWIG_fail;
38188 }
38189 resultobj = SWIG_Py_Void();
38190 return resultobj;
38191 fail:
38192 return NULL;
38193 }
38194
38195
38196 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38197 PyObject *resultobj = 0;
38198 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38199 bool result;
38200 void *argp1 = 0 ;
38201 int res1 = 0 ;
38202 PyObject *swig_obj[1] ;
38203
38204 if (!args) SWIG_fail;
38205 swig_obj[0] = args;
38206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38207 if (!SWIG_IsOK(res1)) {
38208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasIcon" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38209 }
38210 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38211 {
38212 PyThreadState* __tstate = wxPyBeginAllowThreads();
38213 result = (bool)((wxAboutDialogInfo const *)arg1)->HasIcon();
38214 wxPyEndAllowThreads(__tstate);
38215 if (PyErr_Occurred()) SWIG_fail;
38216 }
38217 {
38218 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38219 }
38220 return resultobj;
38221 fail:
38222 return NULL;
38223 }
38224
38225
38226 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38227 PyObject *resultobj = 0;
38228 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38229 wxIcon result;
38230 void *argp1 = 0 ;
38231 int res1 = 0 ;
38232 PyObject *swig_obj[1] ;
38233
38234 if (!args) SWIG_fail;
38235 swig_obj[0] = args;
38236 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38237 if (!SWIG_IsOK(res1)) {
38238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetIcon" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38239 }
38240 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38241 {
38242 PyThreadState* __tstate = wxPyBeginAllowThreads();
38243 result = ((wxAboutDialogInfo const *)arg1)->GetIcon();
38244 wxPyEndAllowThreads(__tstate);
38245 if (PyErr_Occurred()) SWIG_fail;
38246 }
38247 resultobj = SWIG_NewPointerObj((new wxIcon(static_cast< const wxIcon& >(result))), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
38248 return resultobj;
38249 fail:
38250 return NULL;
38251 }
38252
38253
38254 SWIGINTERN PyObject *_wrap_AboutDialogInfo__SetWebSite(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38255 PyObject *resultobj = 0;
38256 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38257 wxString *arg2 = 0 ;
38258 wxString const &arg3_defvalue = wxEmptyString ;
38259 wxString *arg3 = (wxString *) &arg3_defvalue ;
38260 void *argp1 = 0 ;
38261 int res1 = 0 ;
38262 bool temp2 = false ;
38263 bool temp3 = false ;
38264 PyObject * obj0 = 0 ;
38265 PyObject * obj1 = 0 ;
38266 PyObject * obj2 = 0 ;
38267 char * kwnames[] = {
38268 (char *) "self",(char *) "url",(char *) "desc", NULL
38269 };
38270
38271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:AboutDialogInfo__SetWebSite",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38273 if (!SWIG_IsOK(res1)) {
38274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo__SetWebSite" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38275 }
38276 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38277 {
38278 arg2 = wxString_in_helper(obj1);
38279 if (arg2 == NULL) SWIG_fail;
38280 temp2 = true;
38281 }
38282 if (obj2) {
38283 {
38284 arg3 = wxString_in_helper(obj2);
38285 if (arg3 == NULL) SWIG_fail;
38286 temp3 = true;
38287 }
38288 }
38289 {
38290 PyThreadState* __tstate = wxPyBeginAllowThreads();
38291 (arg1)->SetWebSite((wxString const &)*arg2,(wxString const &)*arg3);
38292 wxPyEndAllowThreads(__tstate);
38293 if (PyErr_Occurred()) SWIG_fail;
38294 }
38295 resultobj = SWIG_Py_Void();
38296 {
38297 if (temp2)
38298 delete arg2;
38299 }
38300 {
38301 if (temp3)
38302 delete arg3;
38303 }
38304 return resultobj;
38305 fail:
38306 {
38307 if (temp2)
38308 delete arg2;
38309 }
38310 {
38311 if (temp3)
38312 delete arg3;
38313 }
38314 return NULL;
38315 }
38316
38317
38318 SWIGINTERN PyObject *_wrap_AboutDialogInfo__GetWebSiteURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38319 PyObject *resultobj = 0;
38320 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38321 wxString result;
38322 void *argp1 = 0 ;
38323 int res1 = 0 ;
38324 PyObject *swig_obj[1] ;
38325
38326 if (!args) SWIG_fail;
38327 swig_obj[0] = args;
38328 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38329 if (!SWIG_IsOK(res1)) {
38330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo__GetWebSiteURL" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38331 }
38332 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38333 {
38334 PyThreadState* __tstate = wxPyBeginAllowThreads();
38335 result = ((wxAboutDialogInfo const *)arg1)->GetWebSiteURL();
38336 wxPyEndAllowThreads(__tstate);
38337 if (PyErr_Occurred()) SWIG_fail;
38338 }
38339 {
38340 #if wxUSE_UNICODE
38341 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38342 #else
38343 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38344 #endif
38345 }
38346 return resultobj;
38347 fail:
38348 return NULL;
38349 }
38350
38351
38352 SWIGINTERN PyObject *_wrap_AboutDialogInfo__GetWebSiteDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38353 PyObject *resultobj = 0;
38354 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38355 wxString result;
38356 void *argp1 = 0 ;
38357 int res1 = 0 ;
38358 PyObject *swig_obj[1] ;
38359
38360 if (!args) SWIG_fail;
38361 swig_obj[0] = args;
38362 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38363 if (!SWIG_IsOK(res1)) {
38364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo__GetWebSiteDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38365 }
38366 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38367 {
38368 PyThreadState* __tstate = wxPyBeginAllowThreads();
38369 result = ((wxAboutDialogInfo const *)arg1)->GetWebSiteDescription();
38370 wxPyEndAllowThreads(__tstate);
38371 if (PyErr_Occurred()) SWIG_fail;
38372 }
38373 {
38374 #if wxUSE_UNICODE
38375 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38376 #else
38377 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38378 #endif
38379 }
38380 return resultobj;
38381 fail:
38382 return NULL;
38383 }
38384
38385
38386 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasWebSite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38387 PyObject *resultobj = 0;
38388 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38389 bool result;
38390 void *argp1 = 0 ;
38391 int res1 = 0 ;
38392 PyObject *swig_obj[1] ;
38393
38394 if (!args) SWIG_fail;
38395 swig_obj[0] = args;
38396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38397 if (!SWIG_IsOK(res1)) {
38398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasWebSite" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38399 }
38400 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38401 {
38402 PyThreadState* __tstate = wxPyBeginAllowThreads();
38403 result = (bool)((wxAboutDialogInfo const *)arg1)->HasWebSite();
38404 wxPyEndAllowThreads(__tstate);
38405 if (PyErr_Occurred()) SWIG_fail;
38406 }
38407 {
38408 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38409 }
38410 return resultobj;
38411 fail:
38412 return NULL;
38413 }
38414
38415
38416 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetDevelopers(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38417 PyObject *resultobj = 0;
38418 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38419 wxArrayString *arg2 = 0 ;
38420 void *argp1 = 0 ;
38421 int res1 = 0 ;
38422 bool temp2 = false ;
38423 PyObject * obj0 = 0 ;
38424 PyObject * obj1 = 0 ;
38425 char * kwnames[] = {
38426 (char *) "self",(char *) "developers", NULL
38427 };
38428
38429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetDevelopers",kwnames,&obj0,&obj1)) SWIG_fail;
38430 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38431 if (!SWIG_IsOK(res1)) {
38432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetDevelopers" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38433 }
38434 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38435 {
38436 if (! PySequence_Check(obj1)) {
38437 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38438 SWIG_fail;
38439 }
38440 arg2 = new wxArrayString;
38441 temp2 = true;
38442 int i, len=PySequence_Length(obj1);
38443 for (i=0; i<len; i++) {
38444 PyObject* item = PySequence_GetItem(obj1, i);
38445 wxString* s = wxString_in_helper(item);
38446 if (PyErr_Occurred()) SWIG_fail;
38447 arg2->Add(*s);
38448 delete s;
38449 Py_DECREF(item);
38450 }
38451 }
38452 {
38453 PyThreadState* __tstate = wxPyBeginAllowThreads();
38454 (arg1)->SetDevelopers((wxArrayString const &)*arg2);
38455 wxPyEndAllowThreads(__tstate);
38456 if (PyErr_Occurred()) SWIG_fail;
38457 }
38458 resultobj = SWIG_Py_Void();
38459 {
38460 if (temp2) delete arg2;
38461 }
38462 return resultobj;
38463 fail:
38464 {
38465 if (temp2) delete arg2;
38466 }
38467 return NULL;
38468 }
38469
38470
38471 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddDeveloper(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38472 PyObject *resultobj = 0;
38473 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38474 wxString *arg2 = 0 ;
38475 void *argp1 = 0 ;
38476 int res1 = 0 ;
38477 bool temp2 = false ;
38478 PyObject * obj0 = 0 ;
38479 PyObject * obj1 = 0 ;
38480 char * kwnames[] = {
38481 (char *) "self",(char *) "developer", NULL
38482 };
38483
38484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddDeveloper",kwnames,&obj0,&obj1)) SWIG_fail;
38485 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38486 if (!SWIG_IsOK(res1)) {
38487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddDeveloper" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38488 }
38489 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38490 {
38491 arg2 = wxString_in_helper(obj1);
38492 if (arg2 == NULL) SWIG_fail;
38493 temp2 = true;
38494 }
38495 {
38496 PyThreadState* __tstate = wxPyBeginAllowThreads();
38497 (arg1)->AddDeveloper((wxString const &)*arg2);
38498 wxPyEndAllowThreads(__tstate);
38499 if (PyErr_Occurred()) SWIG_fail;
38500 }
38501 resultobj = SWIG_Py_Void();
38502 {
38503 if (temp2)
38504 delete arg2;
38505 }
38506 return resultobj;
38507 fail:
38508 {
38509 if (temp2)
38510 delete arg2;
38511 }
38512 return NULL;
38513 }
38514
38515
38516 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasDevelopers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38517 PyObject *resultobj = 0;
38518 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38519 bool result;
38520 void *argp1 = 0 ;
38521 int res1 = 0 ;
38522 PyObject *swig_obj[1] ;
38523
38524 if (!args) SWIG_fail;
38525 swig_obj[0] = args;
38526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38527 if (!SWIG_IsOK(res1)) {
38528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasDevelopers" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38529 }
38530 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38531 {
38532 PyThreadState* __tstate = wxPyBeginAllowThreads();
38533 result = (bool)((wxAboutDialogInfo const *)arg1)->HasDevelopers();
38534 wxPyEndAllowThreads(__tstate);
38535 if (PyErr_Occurred()) SWIG_fail;
38536 }
38537 {
38538 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38539 }
38540 return resultobj;
38541 fail:
38542 return NULL;
38543 }
38544
38545
38546 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDevelopers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38547 PyObject *resultobj = 0;
38548 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38549 wxArrayString *result = 0 ;
38550 void *argp1 = 0 ;
38551 int res1 = 0 ;
38552 PyObject *swig_obj[1] ;
38553
38554 if (!args) SWIG_fail;
38555 swig_obj[0] = args;
38556 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38557 if (!SWIG_IsOK(res1)) {
38558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDevelopers" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38559 }
38560 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38561 {
38562 PyThreadState* __tstate = wxPyBeginAllowThreads();
38563 {
38564 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetDevelopers();
38565 result = (wxArrayString *) &_result_ref;
38566 }
38567 wxPyEndAllowThreads(__tstate);
38568 if (PyErr_Occurred()) SWIG_fail;
38569 }
38570 {
38571 resultobj = wxArrayString2PyList_helper(*result);
38572 }
38573 return resultobj;
38574 fail:
38575 return NULL;
38576 }
38577
38578
38579 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetDocWriters(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38580 PyObject *resultobj = 0;
38581 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38582 wxArrayString *arg2 = 0 ;
38583 void *argp1 = 0 ;
38584 int res1 = 0 ;
38585 bool temp2 = false ;
38586 PyObject * obj0 = 0 ;
38587 PyObject * obj1 = 0 ;
38588 char * kwnames[] = {
38589 (char *) "self",(char *) "docwriters", NULL
38590 };
38591
38592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetDocWriters",kwnames,&obj0,&obj1)) SWIG_fail;
38593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38594 if (!SWIG_IsOK(res1)) {
38595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetDocWriters" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38596 }
38597 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38598 {
38599 if (! PySequence_Check(obj1)) {
38600 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38601 SWIG_fail;
38602 }
38603 arg2 = new wxArrayString;
38604 temp2 = true;
38605 int i, len=PySequence_Length(obj1);
38606 for (i=0; i<len; i++) {
38607 PyObject* item = PySequence_GetItem(obj1, i);
38608 wxString* s = wxString_in_helper(item);
38609 if (PyErr_Occurred()) SWIG_fail;
38610 arg2->Add(*s);
38611 delete s;
38612 Py_DECREF(item);
38613 }
38614 }
38615 {
38616 PyThreadState* __tstate = wxPyBeginAllowThreads();
38617 (arg1)->SetDocWriters((wxArrayString const &)*arg2);
38618 wxPyEndAllowThreads(__tstate);
38619 if (PyErr_Occurred()) SWIG_fail;
38620 }
38621 resultobj = SWIG_Py_Void();
38622 {
38623 if (temp2) delete arg2;
38624 }
38625 return resultobj;
38626 fail:
38627 {
38628 if (temp2) delete arg2;
38629 }
38630 return NULL;
38631 }
38632
38633
38634 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddDocWriter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38635 PyObject *resultobj = 0;
38636 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38637 wxString *arg2 = 0 ;
38638 void *argp1 = 0 ;
38639 int res1 = 0 ;
38640 bool temp2 = false ;
38641 PyObject * obj0 = 0 ;
38642 PyObject * obj1 = 0 ;
38643 char * kwnames[] = {
38644 (char *) "self",(char *) "docwriter", NULL
38645 };
38646
38647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddDocWriter",kwnames,&obj0,&obj1)) SWIG_fail;
38648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38649 if (!SWIG_IsOK(res1)) {
38650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddDocWriter" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38651 }
38652 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38653 {
38654 arg2 = wxString_in_helper(obj1);
38655 if (arg2 == NULL) SWIG_fail;
38656 temp2 = true;
38657 }
38658 {
38659 PyThreadState* __tstate = wxPyBeginAllowThreads();
38660 (arg1)->AddDocWriter((wxString const &)*arg2);
38661 wxPyEndAllowThreads(__tstate);
38662 if (PyErr_Occurred()) SWIG_fail;
38663 }
38664 resultobj = SWIG_Py_Void();
38665 {
38666 if (temp2)
38667 delete arg2;
38668 }
38669 return resultobj;
38670 fail:
38671 {
38672 if (temp2)
38673 delete arg2;
38674 }
38675 return NULL;
38676 }
38677
38678
38679 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasDocWriters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38680 PyObject *resultobj = 0;
38681 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38682 bool result;
38683 void *argp1 = 0 ;
38684 int res1 = 0 ;
38685 PyObject *swig_obj[1] ;
38686
38687 if (!args) SWIG_fail;
38688 swig_obj[0] = args;
38689 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38690 if (!SWIG_IsOK(res1)) {
38691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasDocWriters" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38692 }
38693 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38694 {
38695 PyThreadState* __tstate = wxPyBeginAllowThreads();
38696 result = (bool)((wxAboutDialogInfo const *)arg1)->HasDocWriters();
38697 wxPyEndAllowThreads(__tstate);
38698 if (PyErr_Occurred()) SWIG_fail;
38699 }
38700 {
38701 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38702 }
38703 return resultobj;
38704 fail:
38705 return NULL;
38706 }
38707
38708
38709 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDocWriters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38710 PyObject *resultobj = 0;
38711 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38712 wxArrayString *result = 0 ;
38713 void *argp1 = 0 ;
38714 int res1 = 0 ;
38715 PyObject *swig_obj[1] ;
38716
38717 if (!args) SWIG_fail;
38718 swig_obj[0] = args;
38719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38720 if (!SWIG_IsOK(res1)) {
38721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDocWriters" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38722 }
38723 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38724 {
38725 PyThreadState* __tstate = wxPyBeginAllowThreads();
38726 {
38727 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetDocWriters();
38728 result = (wxArrayString *) &_result_ref;
38729 }
38730 wxPyEndAllowThreads(__tstate);
38731 if (PyErr_Occurred()) SWIG_fail;
38732 }
38733 {
38734 resultobj = wxArrayString2PyList_helper(*result);
38735 }
38736 return resultobj;
38737 fail:
38738 return NULL;
38739 }
38740
38741
38742 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetArtists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38743 PyObject *resultobj = 0;
38744 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38745 wxArrayString *arg2 = 0 ;
38746 void *argp1 = 0 ;
38747 int res1 = 0 ;
38748 bool temp2 = false ;
38749 PyObject * obj0 = 0 ;
38750 PyObject * obj1 = 0 ;
38751 char * kwnames[] = {
38752 (char *) "self",(char *) "artists", NULL
38753 };
38754
38755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetArtists",kwnames,&obj0,&obj1)) SWIG_fail;
38756 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38757 if (!SWIG_IsOK(res1)) {
38758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetArtists" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38759 }
38760 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38761 {
38762 if (! PySequence_Check(obj1)) {
38763 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38764 SWIG_fail;
38765 }
38766 arg2 = new wxArrayString;
38767 temp2 = true;
38768 int i, len=PySequence_Length(obj1);
38769 for (i=0; i<len; i++) {
38770 PyObject* item = PySequence_GetItem(obj1, i);
38771 wxString* s = wxString_in_helper(item);
38772 if (PyErr_Occurred()) SWIG_fail;
38773 arg2->Add(*s);
38774 delete s;
38775 Py_DECREF(item);
38776 }
38777 }
38778 {
38779 PyThreadState* __tstate = wxPyBeginAllowThreads();
38780 (arg1)->SetArtists((wxArrayString const &)*arg2);
38781 wxPyEndAllowThreads(__tstate);
38782 if (PyErr_Occurred()) SWIG_fail;
38783 }
38784 resultobj = SWIG_Py_Void();
38785 {
38786 if (temp2) delete arg2;
38787 }
38788 return resultobj;
38789 fail:
38790 {
38791 if (temp2) delete arg2;
38792 }
38793 return NULL;
38794 }
38795
38796
38797 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddArtist(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38798 PyObject *resultobj = 0;
38799 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38800 wxString *arg2 = 0 ;
38801 void *argp1 = 0 ;
38802 int res1 = 0 ;
38803 bool temp2 = false ;
38804 PyObject * obj0 = 0 ;
38805 PyObject * obj1 = 0 ;
38806 char * kwnames[] = {
38807 (char *) "self",(char *) "artist", NULL
38808 };
38809
38810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddArtist",kwnames,&obj0,&obj1)) SWIG_fail;
38811 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38812 if (!SWIG_IsOK(res1)) {
38813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddArtist" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38814 }
38815 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38816 {
38817 arg2 = wxString_in_helper(obj1);
38818 if (arg2 == NULL) SWIG_fail;
38819 temp2 = true;
38820 }
38821 {
38822 PyThreadState* __tstate = wxPyBeginAllowThreads();
38823 (arg1)->AddArtist((wxString const &)*arg2);
38824 wxPyEndAllowThreads(__tstate);
38825 if (PyErr_Occurred()) SWIG_fail;
38826 }
38827 resultobj = SWIG_Py_Void();
38828 {
38829 if (temp2)
38830 delete arg2;
38831 }
38832 return resultobj;
38833 fail:
38834 {
38835 if (temp2)
38836 delete arg2;
38837 }
38838 return NULL;
38839 }
38840
38841
38842 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasArtists(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38843 PyObject *resultobj = 0;
38844 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38845 bool result;
38846 void *argp1 = 0 ;
38847 int res1 = 0 ;
38848 PyObject *swig_obj[1] ;
38849
38850 if (!args) SWIG_fail;
38851 swig_obj[0] = args;
38852 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38853 if (!SWIG_IsOK(res1)) {
38854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasArtists" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38855 }
38856 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38857 {
38858 PyThreadState* __tstate = wxPyBeginAllowThreads();
38859 result = (bool)((wxAboutDialogInfo const *)arg1)->HasArtists();
38860 wxPyEndAllowThreads(__tstate);
38861 if (PyErr_Occurred()) SWIG_fail;
38862 }
38863 {
38864 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38865 }
38866 return resultobj;
38867 fail:
38868 return NULL;
38869 }
38870
38871
38872 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetArtists(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38873 PyObject *resultobj = 0;
38874 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38875 wxArrayString *result = 0 ;
38876 void *argp1 = 0 ;
38877 int res1 = 0 ;
38878 PyObject *swig_obj[1] ;
38879
38880 if (!args) SWIG_fail;
38881 swig_obj[0] = args;
38882 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38883 if (!SWIG_IsOK(res1)) {
38884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetArtists" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38885 }
38886 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38887 {
38888 PyThreadState* __tstate = wxPyBeginAllowThreads();
38889 {
38890 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetArtists();
38891 result = (wxArrayString *) &_result_ref;
38892 }
38893 wxPyEndAllowThreads(__tstate);
38894 if (PyErr_Occurred()) SWIG_fail;
38895 }
38896 {
38897 resultobj = wxArrayString2PyList_helper(*result);
38898 }
38899 return resultobj;
38900 fail:
38901 return NULL;
38902 }
38903
38904
38905 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetTranslators(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38906 PyObject *resultobj = 0;
38907 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38908 wxArrayString *arg2 = 0 ;
38909 void *argp1 = 0 ;
38910 int res1 = 0 ;
38911 bool temp2 = false ;
38912 PyObject * obj0 = 0 ;
38913 PyObject * obj1 = 0 ;
38914 char * kwnames[] = {
38915 (char *) "self",(char *) "translators", NULL
38916 };
38917
38918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetTranslators",kwnames,&obj0,&obj1)) SWIG_fail;
38919 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38920 if (!SWIG_IsOK(res1)) {
38921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetTranslators" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38922 }
38923 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38924 {
38925 if (! PySequence_Check(obj1)) {
38926 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38927 SWIG_fail;
38928 }
38929 arg2 = new wxArrayString;
38930 temp2 = true;
38931 int i, len=PySequence_Length(obj1);
38932 for (i=0; i<len; i++) {
38933 PyObject* item = PySequence_GetItem(obj1, i);
38934 wxString* s = wxString_in_helper(item);
38935 if (PyErr_Occurred()) SWIG_fail;
38936 arg2->Add(*s);
38937 delete s;
38938 Py_DECREF(item);
38939 }
38940 }
38941 {
38942 PyThreadState* __tstate = wxPyBeginAllowThreads();
38943 (arg1)->SetTranslators((wxArrayString const &)*arg2);
38944 wxPyEndAllowThreads(__tstate);
38945 if (PyErr_Occurred()) SWIG_fail;
38946 }
38947 resultobj = SWIG_Py_Void();
38948 {
38949 if (temp2) delete arg2;
38950 }
38951 return resultobj;
38952 fail:
38953 {
38954 if (temp2) delete arg2;
38955 }
38956 return NULL;
38957 }
38958
38959
38960 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddTranslator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38961 PyObject *resultobj = 0;
38962 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38963 wxString *arg2 = 0 ;
38964 void *argp1 = 0 ;
38965 int res1 = 0 ;
38966 bool temp2 = false ;
38967 PyObject * obj0 = 0 ;
38968 PyObject * obj1 = 0 ;
38969 char * kwnames[] = {
38970 (char *) "self",(char *) "translator", NULL
38971 };
38972
38973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddTranslator",kwnames,&obj0,&obj1)) SWIG_fail;
38974 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38975 if (!SWIG_IsOK(res1)) {
38976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddTranslator" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38977 }
38978 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38979 {
38980 arg2 = wxString_in_helper(obj1);
38981 if (arg2 == NULL) SWIG_fail;
38982 temp2 = true;
38983 }
38984 {
38985 PyThreadState* __tstate = wxPyBeginAllowThreads();
38986 (arg1)->AddTranslator((wxString const &)*arg2);
38987 wxPyEndAllowThreads(__tstate);
38988 if (PyErr_Occurred()) SWIG_fail;
38989 }
38990 resultobj = SWIG_Py_Void();
38991 {
38992 if (temp2)
38993 delete arg2;
38994 }
38995 return resultobj;
38996 fail:
38997 {
38998 if (temp2)
38999 delete arg2;
39000 }
39001 return NULL;
39002 }
39003
39004
39005 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasTranslators(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39006 PyObject *resultobj = 0;
39007 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
39008 bool result;
39009 void *argp1 = 0 ;
39010 int res1 = 0 ;
39011 PyObject *swig_obj[1] ;
39012
39013 if (!args) SWIG_fail;
39014 swig_obj[0] = args;
39015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
39016 if (!SWIG_IsOK(res1)) {
39017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasTranslators" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
39018 }
39019 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39020 {
39021 PyThreadState* __tstate = wxPyBeginAllowThreads();
39022 result = (bool)((wxAboutDialogInfo const *)arg1)->HasTranslators();
39023 wxPyEndAllowThreads(__tstate);
39024 if (PyErr_Occurred()) SWIG_fail;
39025 }
39026 {
39027 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39028 }
39029 return resultobj;
39030 fail:
39031 return NULL;
39032 }
39033
39034
39035 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetTranslators(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39036 PyObject *resultobj = 0;
39037 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
39038 wxArrayString *result = 0 ;
39039 void *argp1 = 0 ;
39040 int res1 = 0 ;
39041 PyObject *swig_obj[1] ;
39042
39043 if (!args) SWIG_fail;
39044 swig_obj[0] = args;
39045 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
39046 if (!SWIG_IsOK(res1)) {
39047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetTranslators" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
39048 }
39049 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39050 {
39051 PyThreadState* __tstate = wxPyBeginAllowThreads();
39052 {
39053 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetTranslators();
39054 result = (wxArrayString *) &_result_ref;
39055 }
39056 wxPyEndAllowThreads(__tstate);
39057 if (PyErr_Occurred()) SWIG_fail;
39058 }
39059 {
39060 resultobj = wxArrayString2PyList_helper(*result);
39061 }
39062 return resultobj;
39063 fail:
39064 return NULL;
39065 }
39066
39067
39068 SWIGINTERN PyObject *_wrap_AboutDialogInfo_IsSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39069 PyObject *resultobj = 0;
39070 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
39071 bool result;
39072 void *argp1 = 0 ;
39073 int res1 = 0 ;
39074 PyObject *swig_obj[1] ;
39075
39076 if (!args) SWIG_fail;
39077 swig_obj[0] = args;
39078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
39079 if (!SWIG_IsOK(res1)) {
39080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_IsSimple" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
39081 }
39082 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39083 {
39084 PyThreadState* __tstate = wxPyBeginAllowThreads();
39085 result = (bool)((wxAboutDialogInfo const *)arg1)->IsSimple();
39086 wxPyEndAllowThreads(__tstate);
39087 if (PyErr_Occurred()) SWIG_fail;
39088 }
39089 {
39090 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39091 }
39092 return resultobj;
39093 fail:
39094 return NULL;
39095 }
39096
39097
39098 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDescriptionAndCredits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39099 PyObject *resultobj = 0;
39100 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
39101 wxString result;
39102 void *argp1 = 0 ;
39103 int res1 = 0 ;
39104 PyObject *swig_obj[1] ;
39105
39106 if (!args) SWIG_fail;
39107 swig_obj[0] = args;
39108 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
39109 if (!SWIG_IsOK(res1)) {
39110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDescriptionAndCredits" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
39111 }
39112 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39113 {
39114 PyThreadState* __tstate = wxPyBeginAllowThreads();
39115 result = ((wxAboutDialogInfo const *)arg1)->GetDescriptionAndCredits();
39116 wxPyEndAllowThreads(__tstate);
39117 if (PyErr_Occurred()) SWIG_fail;
39118 }
39119 {
39120 #if wxUSE_UNICODE
39121 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
39122 #else
39123 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
39124 #endif
39125 }
39126 return resultobj;
39127 fail:
39128 return NULL;
39129 }
39130
39131
39132 SWIGINTERN PyObject *AboutDialogInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39133 PyObject *obj;
39134 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
39135 SWIG_TypeNewClientData(SWIGTYPE_p_wxAboutDialogInfo, SWIG_NewClientData(obj));
39136 return SWIG_Py_Void();
39137 }
39138
39139 SWIGINTERN PyObject *AboutDialogInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39140 return SWIG_Python_InitShadowInstance(args);
39141 }
39142
39143 SWIGINTERN PyObject *_wrap_AboutBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39144 PyObject *resultobj = 0;
39145 wxAboutDialogInfo *arg1 = 0 ;
39146 void *argp1 = 0 ;
39147 int res1 = 0 ;
39148 PyObject * obj0 = 0 ;
39149 char * kwnames[] = {
39150 (char *) "info", NULL
39151 };
39152
39153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AboutBox",kwnames,&obj0)) SWIG_fail;
39154 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxAboutDialogInfo, 0 | 0);
39155 if (!SWIG_IsOK(res1)) {
39156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutBox" "', expected argument " "1"" of type '" "wxAboutDialogInfo const &""'");
39157 }
39158 if (!argp1) {
39159 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AboutBox" "', expected argument " "1"" of type '" "wxAboutDialogInfo const &""'");
39160 }
39161 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39162 {
39163 PyThreadState* __tstate = wxPyBeginAllowThreads();
39164 wxAboutBox((wxAboutDialogInfo const &)*arg1);
39165 wxPyEndAllowThreads(__tstate);
39166 if (PyErr_Occurred()) SWIG_fail;
39167 }
39168 resultobj = SWIG_Py_Void();
39169 return resultobj;
39170 fail:
39171 return NULL;
39172 }
39173
39174
39175 static PyMethodDef SwigMethods[] = {
39176 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
39177 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
39178 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
39179 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
39180 { (char *)"SystemSettings_GetScreenType", (PyCFunction)_wrap_SystemSettings_GetScreenType, METH_NOARGS, NULL},
39181 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
39182 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
39183 { (char *)"new_SystemOptions", (PyCFunction)_wrap_new_SystemOptions, METH_NOARGS, NULL},
39184 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
39185 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
39186 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
39187 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
39188 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
39189 { (char *)"SystemOptions_IsFalse", (PyCFunction) _wrap_SystemOptions_IsFalse, METH_VARARGS | METH_KEYWORDS, NULL},
39190 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
39191 { (char *)"SystemOptions_swiginit", SystemOptions_swiginit, METH_VARARGS, NULL},
39192 { (char *)"NewId", (PyCFunction)_wrap_NewId, METH_NOARGS, NULL},
39193 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
39194 { (char *)"GetCurrentId", (PyCFunction)_wrap_GetCurrentId, METH_NOARGS, NULL},
39195 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
39196 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
39197 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
39198 { (char *)"GetStockHelpString", (PyCFunction) _wrap_GetStockHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
39199 { (char *)"Bell", (PyCFunction)_wrap_Bell, METH_NOARGS, NULL},
39200 { (char *)"EndBusyCursor", (PyCFunction)_wrap_EndBusyCursor, METH_NOARGS, NULL},
39201 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
39202 { (char *)"IsBusy", (PyCFunction)_wrap_IsBusy, METH_NOARGS, NULL},
39203 { (char *)"Now", (PyCFunction)_wrap_Now, METH_NOARGS, NULL},
39204 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
39205 { (char *)"StartTimer", (PyCFunction)_wrap_StartTimer, METH_NOARGS, NULL},
39206 { (char *)"GetOsVersion", (PyCFunction)_wrap_GetOsVersion, METH_NOARGS, NULL},
39207 { (char *)"GetOsDescription", (PyCFunction)_wrap_GetOsDescription, METH_NOARGS, NULL},
39208 { (char *)"IsPlatformLittleEndian", (PyCFunction)_wrap_IsPlatformLittleEndian, METH_NOARGS, NULL},
39209 { (char *)"IsPlatform64Bit", (PyCFunction)_wrap_IsPlatform64Bit, METH_NOARGS, NULL},
39210 { (char *)"GetFreeMemory", (PyCFunction)_wrap_GetFreeMemory, METH_NOARGS, NULL},
39211 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
39212 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
39213 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
39214 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
39215 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
39216 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
39217 { (char *)"GetEmailAddress", (PyCFunction)_wrap_GetEmailAddress, METH_NOARGS, NULL},
39218 { (char *)"GetHostName", (PyCFunction)_wrap_GetHostName, METH_NOARGS, NULL},
39219 { (char *)"GetFullHostName", (PyCFunction)_wrap_GetFullHostName, METH_NOARGS, NULL},
39220 { (char *)"GetUserId", (PyCFunction)_wrap_GetUserId, METH_NOARGS, NULL},
39221 { (char *)"GetUserName", (PyCFunction)_wrap_GetUserName, METH_NOARGS, NULL},
39222 { (char *)"GetHomeDir", (PyCFunction)_wrap_GetHomeDir, METH_NOARGS, NULL},
39223 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
39224 { (char *)"GetProcessId", (PyCFunction)_wrap_GetProcessId, METH_NOARGS, NULL},
39225 { (char *)"Trap", (PyCFunction)_wrap_Trap, METH_NOARGS, NULL},
39226 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39227 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39228 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39229 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39230 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
39231 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
39232 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
39233 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
39234 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
39235 { (char *)"GetNumberFromUser", (PyCFunction) _wrap_GetNumberFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
39236 { (char *)"ColourDisplay", (PyCFunction)_wrap_ColourDisplay, METH_NOARGS, NULL},
39237 { (char *)"DisplayDepth", (PyCFunction)_wrap_DisplayDepth, METH_NOARGS, NULL},
39238 { (char *)"GetDisplayDepth", (PyCFunction)_wrap_GetDisplayDepth, METH_NOARGS, NULL},
39239 { (char *)"DisplaySize", (PyCFunction)_wrap_DisplaySize, METH_NOARGS, NULL},
39240 { (char *)"GetDisplaySize", (PyCFunction)_wrap_GetDisplaySize, METH_NOARGS, NULL},
39241 { (char *)"DisplaySizeMM", (PyCFunction)_wrap_DisplaySizeMM, METH_NOARGS, NULL},
39242 { (char *)"GetDisplaySizeMM", (PyCFunction)_wrap_GetDisplaySizeMM, METH_NOARGS, NULL},
39243 { (char *)"ClientDisplayRect", (PyCFunction)_wrap_ClientDisplayRect, METH_NOARGS, NULL},
39244 { (char *)"GetClientDisplayRect", (PyCFunction)_wrap_GetClientDisplayRect, METH_NOARGS, NULL},
39245 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
39246 { (char *)"GetXDisplay", (PyCFunction)_wrap_GetXDisplay, METH_NOARGS, NULL},
39247 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
39248 { (char *)"GetMousePosition", (PyCFunction)_wrap_GetMousePosition, METH_NOARGS, NULL},
39249 { (char *)"FindWindowAtPointer", (PyCFunction)_wrap_FindWindowAtPointer, METH_NOARGS, NULL},
39250 { (char *)"GetActiveWindow", (PyCFunction)_wrap_GetActiveWindow, METH_NOARGS, NULL},
39251 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
39252 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
39253 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
39254 { (char *)"LaunchDefaultBrowser", (PyCFunction) _wrap_LaunchDefaultBrowser, METH_VARARGS | METH_KEYWORDS, NULL},
39255 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
39256 { (char *)"new_MouseState", (PyCFunction)_wrap_new_MouseState, METH_NOARGS, NULL},
39257 { (char *)"delete_MouseState", (PyCFunction)_wrap_delete_MouseState, METH_O, NULL},
39258 { (char *)"MouseState_GetX", (PyCFunction)_wrap_MouseState_GetX, METH_O, NULL},
39259 { (char *)"MouseState_GetY", (PyCFunction)_wrap_MouseState_GetY, METH_O, NULL},
39260 { (char *)"MouseState_LeftDown", (PyCFunction)_wrap_MouseState_LeftDown, METH_O, NULL},
39261 { (char *)"MouseState_MiddleDown", (PyCFunction)_wrap_MouseState_MiddleDown, METH_O, NULL},
39262 { (char *)"MouseState_RightDown", (PyCFunction)_wrap_MouseState_RightDown, METH_O, NULL},
39263 { (char *)"MouseState_ControlDown", (PyCFunction)_wrap_MouseState_ControlDown, METH_O, NULL},
39264 { (char *)"MouseState_ShiftDown", (PyCFunction)_wrap_MouseState_ShiftDown, METH_O, NULL},
39265 { (char *)"MouseState_AltDown", (PyCFunction)_wrap_MouseState_AltDown, METH_O, NULL},
39266 { (char *)"MouseState_MetaDown", (PyCFunction)_wrap_MouseState_MetaDown, METH_O, NULL},
39267 { (char *)"MouseState_CmdDown", (PyCFunction)_wrap_MouseState_CmdDown, METH_O, NULL},
39268 { (char *)"MouseState_SetX", (PyCFunction) _wrap_MouseState_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
39269 { (char *)"MouseState_SetY", (PyCFunction) _wrap_MouseState_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
39270 { (char *)"MouseState_SetLeftDown", (PyCFunction) _wrap_MouseState_SetLeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
39271 { (char *)"MouseState_SetMiddleDown", (PyCFunction) _wrap_MouseState_SetMiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
39272 { (char *)"MouseState_SetRightDown", (PyCFunction) _wrap_MouseState_SetRightDown, METH_VARARGS | METH_KEYWORDS, NULL},
39273 { (char *)"MouseState_SetControlDown", (PyCFunction) _wrap_MouseState_SetControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
39274 { (char *)"MouseState_SetShiftDown", (PyCFunction) _wrap_MouseState_SetShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
39275 { (char *)"MouseState_SetAltDown", (PyCFunction) _wrap_MouseState_SetAltDown, METH_VARARGS | METH_KEYWORDS, NULL},
39276 { (char *)"MouseState_SetMetaDown", (PyCFunction) _wrap_MouseState_SetMetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
39277 { (char *)"MouseState_swigregister", MouseState_swigregister, METH_VARARGS, NULL},
39278 { (char *)"MouseState_swiginit", MouseState_swiginit, METH_VARARGS, NULL},
39279 { (char *)"GetMouseState", (PyCFunction)_wrap_GetMouseState, METH_NOARGS, NULL},
39280 { (char *)"WakeUpMainThread", (PyCFunction)_wrap_WakeUpMainThread, METH_NOARGS, NULL},
39281 { (char *)"MutexGuiEnter", (PyCFunction)_wrap_MutexGuiEnter, METH_NOARGS, NULL},
39282 { (char *)"MutexGuiLeave", (PyCFunction)_wrap_MutexGuiLeave, METH_NOARGS, NULL},
39283 { (char *)"new_MutexGuiLocker", (PyCFunction)_wrap_new_MutexGuiLocker, METH_NOARGS, NULL},
39284 { (char *)"delete_MutexGuiLocker", (PyCFunction)_wrap_delete_MutexGuiLocker, METH_O, NULL},
39285 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
39286 { (char *)"MutexGuiLocker_swiginit", MutexGuiLocker_swiginit, METH_VARARGS, NULL},
39287 { (char *)"Thread_IsMain", (PyCFunction)_wrap_Thread_IsMain, METH_NOARGS, NULL},
39288 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
39289 { (char *)"delete_ToolTip", (PyCFunction)_wrap_delete_ToolTip, METH_O, NULL},
39290 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
39291 { (char *)"ToolTip_GetTip", (PyCFunction)_wrap_ToolTip_GetTip, METH_O, NULL},
39292 { (char *)"ToolTip_GetWindow", (PyCFunction)_wrap_ToolTip_GetWindow, METH_O, NULL},
39293 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
39294 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
39295 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
39296 { (char *)"ToolTip_swiginit", ToolTip_swiginit, METH_VARARGS, NULL},
39297 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
39298 { (char *)"delete_Caret", (PyCFunction)_wrap_delete_Caret, METH_O, NULL},
39299 { (char *)"Caret_Destroy", (PyCFunction)_wrap_Caret_Destroy, METH_O, NULL},
39300 { (char *)"Caret_IsOk", (PyCFunction)_wrap_Caret_IsOk, METH_O, NULL},
39301 { (char *)"Caret_IsVisible", (PyCFunction)_wrap_Caret_IsVisible, METH_O, NULL},
39302 { (char *)"Caret_GetPosition", (PyCFunction)_wrap_Caret_GetPosition, METH_O, NULL},
39303 { (char *)"Caret_GetPositionTuple", (PyCFunction)_wrap_Caret_GetPositionTuple, METH_O, NULL},
39304 { (char *)"Caret_GetSize", (PyCFunction)_wrap_Caret_GetSize, METH_O, NULL},
39305 { (char *)"Caret_GetSizeTuple", (PyCFunction)_wrap_Caret_GetSizeTuple, METH_O, NULL},
39306 { (char *)"Caret_GetWindow", (PyCFunction)_wrap_Caret_GetWindow, METH_O, NULL},
39307 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
39308 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
39309 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
39310 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
39311 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
39312 { (char *)"Caret_Hide", (PyCFunction)_wrap_Caret_Hide, METH_O, NULL},
39313 { (char *)"Caret_GetBlinkTime", (PyCFunction)_wrap_Caret_GetBlinkTime, METH_NOARGS, NULL},
39314 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
39315 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
39316 { (char *)"Caret_swiginit", Caret_swiginit, METH_VARARGS, NULL},
39317 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
39318 { (char *)"delete_BusyCursor", (PyCFunction)_wrap_delete_BusyCursor, METH_O, NULL},
39319 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
39320 { (char *)"BusyCursor_swiginit", BusyCursor_swiginit, METH_VARARGS, NULL},
39321 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
39322 { (char *)"delete_WindowDisabler", (PyCFunction)_wrap_delete_WindowDisabler, METH_O, NULL},
39323 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
39324 { (char *)"WindowDisabler_swiginit", WindowDisabler_swiginit, METH_VARARGS, NULL},
39325 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39326 { (char *)"delete_BusyInfo", (PyCFunction)_wrap_delete_BusyInfo, METH_O, NULL},
39327 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
39328 { (char *)"BusyInfo_swiginit", BusyInfo_swiginit, METH_VARARGS, NULL},
39329 { (char *)"new_StopWatch", (PyCFunction)_wrap_new_StopWatch, METH_NOARGS, NULL},
39330 { (char *)"delete_StopWatch", (PyCFunction)_wrap_delete_StopWatch, METH_O, NULL},
39331 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
39332 { (char *)"StopWatch_Pause", (PyCFunction)_wrap_StopWatch_Pause, METH_O, NULL},
39333 { (char *)"StopWatch_Resume", (PyCFunction)_wrap_StopWatch_Resume, METH_O, NULL},
39334 { (char *)"StopWatch_Time", (PyCFunction)_wrap_StopWatch_Time, METH_O, NULL},
39335 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
39336 { (char *)"StopWatch_swiginit", StopWatch_swiginit, METH_VARARGS, NULL},
39337 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
39338 { (char *)"delete_FileHistory", (PyCFunction)_wrap_delete_FileHistory, METH_O, NULL},
39339 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
39340 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
39341 { (char *)"FileHistory_GetMaxFiles", (PyCFunction)_wrap_FileHistory_GetMaxFiles, METH_O, NULL},
39342 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
39343 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
39344 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
39345 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
39346 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction)_wrap_FileHistory_AddFilesToMenu, METH_O, NULL},
39347 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
39348 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
39349 { (char *)"FileHistory_GetCount", (PyCFunction)_wrap_FileHistory_GetCount, METH_O, NULL},
39350 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
39351 { (char *)"FileHistory_swiginit", FileHistory_swiginit, METH_VARARGS, NULL},
39352 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
39353 { (char *)"new_PreSingleInstanceChecker", (PyCFunction)_wrap_new_PreSingleInstanceChecker, METH_NOARGS, NULL},
39354 { (char *)"delete_SingleInstanceChecker", (PyCFunction)_wrap_delete_SingleInstanceChecker, METH_O, NULL},
39355 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
39356 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction)_wrap_SingleInstanceChecker_IsAnotherRunning, METH_O, NULL},
39357 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
39358 { (char *)"SingleInstanceChecker_swiginit", SingleInstanceChecker_swiginit, METH_VARARGS, NULL},
39359 { (char *)"new_PlatformInformation", (PyCFunction)_wrap_new_PlatformInformation, METH_NOARGS, NULL},
39360 { (char *)"PlatformInformation___eq__", (PyCFunction) _wrap_PlatformInformation___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39361 { (char *)"PlatformInformation___ne__", (PyCFunction) _wrap_PlatformInformation___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39362 { (char *)"PlatformInformation_GetOSMajorVersion", (PyCFunction)_wrap_PlatformInformation_GetOSMajorVersion, METH_O, NULL},
39363 { (char *)"PlatformInformation_GetOSMinorVersion", (PyCFunction)_wrap_PlatformInformation_GetOSMinorVersion, METH_O, NULL},
39364 { (char *)"PlatformInformation_CheckOSVersion", (PyCFunction) _wrap_PlatformInformation_CheckOSVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39365 { (char *)"PlatformInformation_GetToolkitMajorVersion", (PyCFunction)_wrap_PlatformInformation_GetToolkitMajorVersion, METH_O, NULL},
39366 { (char *)"PlatformInformation_GetToolkitMinorVersion", (PyCFunction)_wrap_PlatformInformation_GetToolkitMinorVersion, METH_O, NULL},
39367 { (char *)"PlatformInformation_CheckToolkitVersion", (PyCFunction) _wrap_PlatformInformation_CheckToolkitVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39368 { (char *)"PlatformInformation_IsUsingUniversalWidgets", (PyCFunction)_wrap_PlatformInformation_IsUsingUniversalWidgets, METH_O, NULL},
39369 { (char *)"PlatformInformation_GetOperatingSystemId", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemId, METH_O, NULL},
39370 { (char *)"PlatformInformation_GetPortId", (PyCFunction)_wrap_PlatformInformation_GetPortId, METH_O, NULL},
39371 { (char *)"PlatformInformation_GetArchitecture", (PyCFunction)_wrap_PlatformInformation_GetArchitecture, METH_O, NULL},
39372 { (char *)"PlatformInformation_GetEndianness", (PyCFunction)_wrap_PlatformInformation_GetEndianness, METH_O, NULL},
39373 { (char *)"PlatformInformation_GetOperatingSystemFamilyName", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemFamilyName, METH_O, NULL},
39374 { (char *)"PlatformInformation_GetOperatingSystemIdName", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemIdName, METH_O, NULL},
39375 { (char *)"PlatformInformation_GetPortIdName", (PyCFunction)_wrap_PlatformInformation_GetPortIdName, METH_O, NULL},
39376 { (char *)"PlatformInformation_GetPortIdShortName", (PyCFunction)_wrap_PlatformInformation_GetPortIdShortName, METH_O, NULL},
39377 { (char *)"PlatformInformation_GetArchName", (PyCFunction)_wrap_PlatformInformation_GetArchName, METH_O, NULL},
39378 { (char *)"PlatformInformation_GetEndiannessName", (PyCFunction)_wrap_PlatformInformation_GetEndiannessName, METH_O, NULL},
39379 { (char *)"PlatformInformation_SetOSVersion", (PyCFunction) _wrap_PlatformInformation_SetOSVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39380 { (char *)"PlatformInformation_SetToolkitVersion", (PyCFunction) _wrap_PlatformInformation_SetToolkitVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39381 { (char *)"PlatformInformation_SetOperatingSystemId", (PyCFunction) _wrap_PlatformInformation_SetOperatingSystemId, METH_VARARGS | METH_KEYWORDS, NULL},
39382 { (char *)"PlatformInformation_SetPortId", (PyCFunction) _wrap_PlatformInformation_SetPortId, METH_VARARGS | METH_KEYWORDS, NULL},
39383 { (char *)"PlatformInformation_SetArchitecture", (PyCFunction) _wrap_PlatformInformation_SetArchitecture, METH_VARARGS | METH_KEYWORDS, NULL},
39384 { (char *)"PlatformInformation_SetEndianness", (PyCFunction) _wrap_PlatformInformation_SetEndianness, METH_VARARGS | METH_KEYWORDS, NULL},
39385 { (char *)"PlatformInformation_IsOk", (PyCFunction)_wrap_PlatformInformation_IsOk, METH_O, NULL},
39386 { (char *)"PlatformInformation_swigregister", PlatformInformation_swigregister, METH_VARARGS, NULL},
39387 { (char *)"PlatformInformation_swiginit", PlatformInformation_swiginit, METH_VARARGS, NULL},
39388 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
39389 { (char *)"delete_TipProvider", (PyCFunction)_wrap_delete_TipProvider, METH_O, NULL},
39390 { (char *)"TipProvider_GetTip", (PyCFunction)_wrap_TipProvider_GetTip, METH_O, NULL},
39391 { (char *)"TipProvider_GetCurrentTip", (PyCFunction)_wrap_TipProvider_GetCurrentTip, METH_O, NULL},
39392 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
39393 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
39394 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
39395 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39396 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
39397 { (char *)"PyTipProvider_swiginit", PyTipProvider_swiginit, METH_VARARGS, NULL},
39398 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
39399 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
39400 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
39401 { (char *)"delete_Timer", (PyCFunction)_wrap_delete_Timer, METH_O, NULL},
39402 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39403 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
39404 { (char *)"Timer_GetOwner", (PyCFunction)_wrap_Timer_GetOwner, METH_O, NULL},
39405 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
39406 { (char *)"Timer_Stop", (PyCFunction)_wrap_Timer_Stop, METH_O, NULL},
39407 { (char *)"Timer_Notify", (PyCFunction)_wrap_Timer_Notify, METH_O, NULL},
39408 { (char *)"Timer_IsRunning", (PyCFunction)_wrap_Timer_IsRunning, METH_O, NULL},
39409 { (char *)"Timer_GetInterval", (PyCFunction)_wrap_Timer_GetInterval, METH_O, NULL},
39410 { (char *)"Timer_GetId", (PyCFunction)_wrap_Timer_GetId, METH_O, NULL},
39411 { (char *)"Timer_IsOneShot", (PyCFunction)_wrap_Timer_IsOneShot, METH_O, NULL},
39412 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
39413 { (char *)"Timer_swiginit", Timer_swiginit, METH_VARARGS, NULL},
39414 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
39415 { (char *)"TimerEvent_GetInterval", (PyCFunction)_wrap_TimerEvent_GetInterval, METH_O, NULL},
39416 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
39417 { (char *)"TimerEvent_swiginit", TimerEvent_swiginit, METH_VARARGS, NULL},
39418 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
39419 { (char *)"delete_TimerRunner", (PyCFunction)_wrap_delete_TimerRunner, METH_O, NULL},
39420 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
39421 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
39422 { (char *)"TimerRunner_swiginit", TimerRunner_swiginit, METH_VARARGS, NULL},
39423 { (char *)"new_Log", (PyCFunction)_wrap_new_Log, METH_NOARGS, NULL},
39424 { (char *)"delete_Log", (PyCFunction)_wrap_delete_Log, METH_O, NULL},
39425 { (char *)"Log_IsEnabled", (PyCFunction)_wrap_Log_IsEnabled, METH_NOARGS, NULL},
39426 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
39427 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
39428 { (char *)"Log_Flush", (PyCFunction)_wrap_Log_Flush, METH_O, NULL},
39429 { (char *)"Log_FlushActive", (PyCFunction)_wrap_Log_FlushActive, METH_NOARGS, NULL},
39430 { (char *)"Log_GetActiveTarget", (PyCFunction)_wrap_Log_GetActiveTarget, METH_NOARGS, NULL},
39431 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
39432 { (char *)"Log_Suspend", (PyCFunction)_wrap_Log_Suspend, METH_NOARGS, NULL},
39433 { (char *)"Log_Resume", (PyCFunction)_wrap_Log_Resume, METH_NOARGS, NULL},
39434 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
39435 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
39436 { (char *)"Log_DontCreateOnDemand", (PyCFunction)_wrap_Log_DontCreateOnDemand, METH_NOARGS, NULL},
39437 { (char *)"Log_SetRepetitionCounting", (PyCFunction) _wrap_Log_SetRepetitionCounting, METH_VARARGS | METH_KEYWORDS, NULL},
39438 { (char *)"Log_GetRepetitionCounting", (PyCFunction)_wrap_Log_GetRepetitionCounting, METH_NOARGS, NULL},
39439 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39440 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39441 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39442 { (char *)"Log_ClearTraceMasks", (PyCFunction)_wrap_Log_ClearTraceMasks, METH_NOARGS, NULL},
39443 { (char *)"Log_GetTraceMasks", (PyCFunction)_wrap_Log_GetTraceMasks, METH_NOARGS, NULL},
39444 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
39445 { (char *)"Log_GetVerbose", (PyCFunction)_wrap_Log_GetVerbose, METH_NOARGS, NULL},
39446 { (char *)"Log_GetTraceMask", (PyCFunction)_wrap_Log_GetTraceMask, METH_NOARGS, NULL},
39447 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39448 { (char *)"Log_GetLogLevel", (PyCFunction)_wrap_Log_GetLogLevel, METH_NOARGS, NULL},
39449 { (char *)"Log_GetTimestamp", (PyCFunction)_wrap_Log_GetTimestamp, METH_NOARGS, NULL},
39450 { (char *)"Log_TimeStamp", (PyCFunction)_wrap_Log_TimeStamp, METH_NOARGS, NULL},
39451 { (char *)"Log_Destroy", (PyCFunction)_wrap_Log_Destroy, METH_O, NULL},
39452 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
39453 { (char *)"Log_swiginit", Log_swiginit, METH_VARARGS, NULL},
39454 { (char *)"new_LogStderr", (PyCFunction)_wrap_new_LogStderr, METH_NOARGS, NULL},
39455 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
39456 { (char *)"LogStderr_swiginit", LogStderr_swiginit, METH_VARARGS, NULL},
39457 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
39458 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
39459 { (char *)"LogTextCtrl_swiginit", LogTextCtrl_swiginit, METH_VARARGS, NULL},
39460 { (char *)"new_LogGui", (PyCFunction)_wrap_new_LogGui, METH_NOARGS, NULL},
39461 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
39462 { (char *)"LogGui_swiginit", LogGui_swiginit, METH_VARARGS, NULL},
39463 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
39464 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
39465 { (char *)"LogWindow_GetFrame", (PyCFunction)_wrap_LogWindow_GetFrame, METH_O, NULL},
39466 { (char *)"LogWindow_GetOldLog", (PyCFunction)_wrap_LogWindow_GetOldLog, METH_O, NULL},
39467 { (char *)"LogWindow_IsPassingMessages", (PyCFunction)_wrap_LogWindow_IsPassingMessages, METH_O, NULL},
39468 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
39469 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
39470 { (char *)"LogWindow_swiginit", LogWindow_swiginit, METH_VARARGS, NULL},
39471 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
39472 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
39473 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
39474 { (char *)"LogChain_IsPassingMessages", (PyCFunction)_wrap_LogChain_IsPassingMessages, METH_O, NULL},
39475 { (char *)"LogChain_GetOldLog", (PyCFunction)_wrap_LogChain_GetOldLog, METH_O, NULL},
39476 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
39477 { (char *)"LogChain_swiginit", LogChain_swiginit, METH_VARARGS, NULL},
39478 { (char *)"new_LogBuffer", (PyCFunction)_wrap_new_LogBuffer, METH_NOARGS, NULL},
39479 { (char *)"LogBuffer_GetBuffer", (PyCFunction)_wrap_LogBuffer_GetBuffer, METH_O, NULL},
39480 { (char *)"LogBuffer_swigregister", LogBuffer_swigregister, METH_VARARGS, NULL},
39481 { (char *)"LogBuffer_swiginit", LogBuffer_swiginit, METH_VARARGS, NULL},
39482 { (char *)"SysErrorCode", (PyCFunction)_wrap_SysErrorCode, METH_NOARGS, NULL},
39483 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
39484 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
39485 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
39486 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
39487 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
39488 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39489 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
39490 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
39491 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
39492 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
39493 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
39494 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
39495 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
39496 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
39497 { (char *)"new_LogNull", (PyCFunction)_wrap_new_LogNull, METH_NOARGS, NULL},
39498 { (char *)"delete_LogNull", (PyCFunction)_wrap_delete_LogNull, METH_O, NULL},
39499 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
39500 { (char *)"LogNull_swiginit", LogNull_swiginit, METH_VARARGS, NULL},
39501 { (char *)"new_PyLog", (PyCFunction)_wrap_new_PyLog, METH_NOARGS, NULL},
39502 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39503 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
39504 { (char *)"PyLog_swiginit", PyLog_swiginit, METH_VARARGS, NULL},
39505 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
39506 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
39507 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
39508 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
39509 { (char *)"delete_Process", (PyCFunction)_wrap_delete_Process, METH_O, NULL},
39510 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39511 { (char *)"Process_GetPid", (PyCFunction)_wrap_Process_GetPid, METH_O, NULL},
39512 { (char *)"Process_OnTerminate", (PyCFunction) _wrap_Process_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
39513 { (char *)"Process_Redirect", (PyCFunction)_wrap_Process_Redirect, METH_O, NULL},
39514 { (char *)"Process_IsRedirected", (PyCFunction)_wrap_Process_IsRedirected, METH_O, NULL},
39515 { (char *)"Process_Detach", (PyCFunction)_wrap_Process_Detach, METH_O, NULL},
39516 { (char *)"Process_GetInputStream", (PyCFunction)_wrap_Process_GetInputStream, METH_O, NULL},
39517 { (char *)"Process_GetErrorStream", (PyCFunction)_wrap_Process_GetErrorStream, METH_O, NULL},
39518 { (char *)"Process_GetOutputStream", (PyCFunction)_wrap_Process_GetOutputStream, METH_O, NULL},
39519 { (char *)"Process_CloseOutput", (PyCFunction)_wrap_Process_CloseOutput, METH_O, NULL},
39520 { (char *)"Process_IsInputOpened", (PyCFunction)_wrap_Process_IsInputOpened, METH_O, NULL},
39521 { (char *)"Process_IsInputAvailable", (PyCFunction)_wrap_Process_IsInputAvailable, METH_O, NULL},
39522 { (char *)"Process_IsErrorAvailable", (PyCFunction)_wrap_Process_IsErrorAvailable, METH_O, NULL},
39523 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
39524 { (char *)"Process_swiginit", Process_swiginit, METH_VARARGS, NULL},
39525 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
39526 { (char *)"ProcessEvent_GetPid", (PyCFunction)_wrap_ProcessEvent_GetPid, METH_O, NULL},
39527 { (char *)"ProcessEvent_GetExitCode", (PyCFunction)_wrap_ProcessEvent_GetExitCode, METH_O, NULL},
39528 { (char *)"ProcessEvent_m_pid_set", _wrap_ProcessEvent_m_pid_set, METH_VARARGS, NULL},
39529 { (char *)"ProcessEvent_m_pid_get", (PyCFunction)_wrap_ProcessEvent_m_pid_get, METH_O, NULL},
39530 { (char *)"ProcessEvent_m_exitcode_set", _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS, NULL},
39531 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction)_wrap_ProcessEvent_m_exitcode_get, METH_O, NULL},
39532 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
39533 { (char *)"ProcessEvent_swiginit", ProcessEvent_swiginit, METH_VARARGS, NULL},
39534 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
39535 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
39536 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
39537 { (char *)"delete_Joystick", (PyCFunction)_wrap_delete_Joystick, METH_O, NULL},
39538 { (char *)"Joystick_GetPosition", (PyCFunction)_wrap_Joystick_GetPosition, METH_O, NULL},
39539 { (char *)"Joystick_GetZPosition", (PyCFunction)_wrap_Joystick_GetZPosition, METH_O, NULL},
39540 { (char *)"Joystick_GetButtonState", (PyCFunction)_wrap_Joystick_GetButtonState, METH_O, NULL},
39541 { (char *)"Joystick_GetPOVPosition", (PyCFunction)_wrap_Joystick_GetPOVPosition, METH_O, NULL},
39542 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction)_wrap_Joystick_GetPOVCTSPosition, METH_O, NULL},
39543 { (char *)"Joystick_GetRudderPosition", (PyCFunction)_wrap_Joystick_GetRudderPosition, METH_O, NULL},
39544 { (char *)"Joystick_GetUPosition", (PyCFunction)_wrap_Joystick_GetUPosition, METH_O, NULL},
39545 { (char *)"Joystick_GetVPosition", (PyCFunction)_wrap_Joystick_GetVPosition, METH_O, NULL},
39546 { (char *)"Joystick_GetMovementThreshold", (PyCFunction)_wrap_Joystick_GetMovementThreshold, METH_O, NULL},
39547 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
39548 { (char *)"Joystick_IsOk", (PyCFunction)_wrap_Joystick_IsOk, METH_O, NULL},
39549 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction)_wrap_Joystick_GetNumberJoysticks, METH_O, NULL},
39550 { (char *)"Joystick_GetManufacturerId", (PyCFunction)_wrap_Joystick_GetManufacturerId, METH_O, NULL},
39551 { (char *)"Joystick_GetProductId", (PyCFunction)_wrap_Joystick_GetProductId, METH_O, NULL},
39552 { (char *)"Joystick_GetProductName", (PyCFunction)_wrap_Joystick_GetProductName, METH_O, NULL},
39553 { (char *)"Joystick_GetXMin", (PyCFunction)_wrap_Joystick_GetXMin, METH_O, NULL},
39554 { (char *)"Joystick_GetYMin", (PyCFunction)_wrap_Joystick_GetYMin, METH_O, NULL},
39555 { (char *)"Joystick_GetZMin", (PyCFunction)_wrap_Joystick_GetZMin, METH_O, NULL},
39556 { (char *)"Joystick_GetXMax", (PyCFunction)_wrap_Joystick_GetXMax, METH_O, NULL},
39557 { (char *)"Joystick_GetYMax", (PyCFunction)_wrap_Joystick_GetYMax, METH_O, NULL},
39558 { (char *)"Joystick_GetZMax", (PyCFunction)_wrap_Joystick_GetZMax, METH_O, NULL},
39559 { (char *)"Joystick_GetNumberButtons", (PyCFunction)_wrap_Joystick_GetNumberButtons, METH_O, NULL},
39560 { (char *)"Joystick_GetNumberAxes", (PyCFunction)_wrap_Joystick_GetNumberAxes, METH_O, NULL},
39561 { (char *)"Joystick_GetMaxButtons", (PyCFunction)_wrap_Joystick_GetMaxButtons, METH_O, NULL},
39562 { (char *)"Joystick_GetMaxAxes", (PyCFunction)_wrap_Joystick_GetMaxAxes, METH_O, NULL},
39563 { (char *)"Joystick_GetPollingMin", (PyCFunction)_wrap_Joystick_GetPollingMin, METH_O, NULL},
39564 { (char *)"Joystick_GetPollingMax", (PyCFunction)_wrap_Joystick_GetPollingMax, METH_O, NULL},
39565 { (char *)"Joystick_GetRudderMin", (PyCFunction)_wrap_Joystick_GetRudderMin, METH_O, NULL},
39566 { (char *)"Joystick_GetRudderMax", (PyCFunction)_wrap_Joystick_GetRudderMax, METH_O, NULL},
39567 { (char *)"Joystick_GetUMin", (PyCFunction)_wrap_Joystick_GetUMin, METH_O, NULL},
39568 { (char *)"Joystick_GetUMax", (PyCFunction)_wrap_Joystick_GetUMax, METH_O, NULL},
39569 { (char *)"Joystick_GetVMin", (PyCFunction)_wrap_Joystick_GetVMin, METH_O, NULL},
39570 { (char *)"Joystick_GetVMax", (PyCFunction)_wrap_Joystick_GetVMax, METH_O, NULL},
39571 { (char *)"Joystick_HasRudder", (PyCFunction)_wrap_Joystick_HasRudder, METH_O, NULL},
39572 { (char *)"Joystick_HasZ", (PyCFunction)_wrap_Joystick_HasZ, METH_O, NULL},
39573 { (char *)"Joystick_HasU", (PyCFunction)_wrap_Joystick_HasU, METH_O, NULL},
39574 { (char *)"Joystick_HasV", (PyCFunction)_wrap_Joystick_HasV, METH_O, NULL},
39575 { (char *)"Joystick_HasPOV", (PyCFunction)_wrap_Joystick_HasPOV, METH_O, NULL},
39576 { (char *)"Joystick_HasPOV4Dir", (PyCFunction)_wrap_Joystick_HasPOV4Dir, METH_O, NULL},
39577 { (char *)"Joystick_HasPOVCTS", (PyCFunction)_wrap_Joystick_HasPOVCTS, METH_O, NULL},
39578 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
39579 { (char *)"Joystick_ReleaseCapture", (PyCFunction)_wrap_Joystick_ReleaseCapture, METH_O, NULL},
39580 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
39581 { (char *)"Joystick_swiginit", Joystick_swiginit, METH_VARARGS, NULL},
39582 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
39583 { (char *)"JoystickEvent_GetPosition", (PyCFunction)_wrap_JoystickEvent_GetPosition, METH_O, NULL},
39584 { (char *)"JoystickEvent_GetZPosition", (PyCFunction)_wrap_JoystickEvent_GetZPosition, METH_O, NULL},
39585 { (char *)"JoystickEvent_GetButtonState", (PyCFunction)_wrap_JoystickEvent_GetButtonState, METH_O, NULL},
39586 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction)_wrap_JoystickEvent_GetButtonChange, METH_O, NULL},
39587 { (char *)"JoystickEvent_GetJoystick", (PyCFunction)_wrap_JoystickEvent_GetJoystick, METH_O, NULL},
39588 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
39589 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
39590 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
39591 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
39592 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
39593 { (char *)"JoystickEvent_IsButton", (PyCFunction)_wrap_JoystickEvent_IsButton, METH_O, NULL},
39594 { (char *)"JoystickEvent_IsMove", (PyCFunction)_wrap_JoystickEvent_IsMove, METH_O, NULL},
39595 { (char *)"JoystickEvent_IsZMove", (PyCFunction)_wrap_JoystickEvent_IsZMove, METH_O, NULL},
39596 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
39597 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
39598 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
39599 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
39600 { (char *)"JoystickEvent_swiginit", JoystickEvent_swiginit, METH_VARARGS, NULL},
39601 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
39602 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
39603 { (char *)"delete_Sound", (PyCFunction)_wrap_delete_Sound, METH_O, NULL},
39604 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
39605 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
39606 { (char *)"Sound_IsOk", (PyCFunction)_wrap_Sound_IsOk, METH_O, NULL},
39607 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
39608 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
39609 { (char *)"Sound_Stop", (PyCFunction)_wrap_Sound_Stop, METH_NOARGS, NULL},
39610 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
39611 { (char *)"Sound_swiginit", Sound_swiginit, METH_VARARGS, NULL},
39612 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39613 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
39614 { (char *)"new_NullFileTypeInfo", (PyCFunction)_wrap_new_NullFileTypeInfo, METH_NOARGS, NULL},
39615 { (char *)"FileTypeInfo_IsValid", (PyCFunction)_wrap_FileTypeInfo_IsValid, METH_O, NULL},
39616 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
39617 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
39618 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction)_wrap_FileTypeInfo_GetMimeType, METH_O, NULL},
39619 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction)_wrap_FileTypeInfo_GetOpenCommand, METH_O, NULL},
39620 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction)_wrap_FileTypeInfo_GetPrintCommand, METH_O, NULL},
39621 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction)_wrap_FileTypeInfo_GetShortDesc, METH_O, NULL},
39622 { (char *)"FileTypeInfo_GetDescription", (PyCFunction)_wrap_FileTypeInfo_GetDescription, METH_O, NULL},
39623 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction)_wrap_FileTypeInfo_GetExtensions, METH_O, NULL},
39624 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction)_wrap_FileTypeInfo_GetExtensionsCount, METH_O, NULL},
39625 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction)_wrap_FileTypeInfo_GetIconFile, METH_O, NULL},
39626 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction)_wrap_FileTypeInfo_GetIconIndex, METH_O, NULL},
39627 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
39628 { (char *)"FileTypeInfo_swiginit", FileTypeInfo_swiginit, METH_VARARGS, NULL},
39629 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
39630 { (char *)"delete_FileType", (PyCFunction)_wrap_delete_FileType, METH_O, NULL},
39631 { (char *)"FileType_GetMimeType", (PyCFunction)_wrap_FileType_GetMimeType, METH_O, NULL},
39632 { (char *)"FileType_GetMimeTypes", (PyCFunction)_wrap_FileType_GetMimeTypes, METH_O, NULL},
39633 { (char *)"FileType_GetExtensions", (PyCFunction)_wrap_FileType_GetExtensions, METH_O, NULL},
39634 { (char *)"FileType_GetIcon", (PyCFunction)_wrap_FileType_GetIcon, METH_O, NULL},
39635 { (char *)"FileType_GetIconInfo", (PyCFunction)_wrap_FileType_GetIconInfo, METH_O, NULL},
39636 { (char *)"FileType_GetDescription", (PyCFunction)_wrap_FileType_GetDescription, METH_O, NULL},
39637 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39638 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39639 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
39640 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39641 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
39642 { (char *)"FileType_Unassociate", (PyCFunction)_wrap_FileType_Unassociate, METH_O, NULL},
39643 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39644 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
39645 { (char *)"FileType_swiginit", FileType_swiginit, METH_VARARGS, NULL},
39646 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
39647 { (char *)"new_MimeTypesManager", (PyCFunction)_wrap_new_MimeTypesManager, METH_NOARGS, NULL},
39648 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
39649 { (char *)"MimeTypesManager_ClearData", (PyCFunction)_wrap_MimeTypesManager_ClearData, METH_O, NULL},
39650 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
39651 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
39652 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
39653 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
39654 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction)_wrap_MimeTypesManager_EnumAllFileTypes, METH_O, NULL},
39655 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
39656 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
39657 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
39658 { (char *)"delete_MimeTypesManager", (PyCFunction)_wrap_delete_MimeTypesManager, METH_O, NULL},
39659 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
39660 { (char *)"MimeTypesManager_swiginit", MimeTypesManager_swiginit, METH_VARARGS, NULL},
39661 { (char *)"new_ArtProvider", (PyCFunction)_wrap_new_ArtProvider, METH_NOARGS, NULL},
39662 { (char *)"delete_ArtProvider", (PyCFunction)_wrap_delete_ArtProvider, METH_O, NULL},
39663 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39664 { (char *)"ArtProvider_Push", (PyCFunction) _wrap_ArtProvider_Push, METH_VARARGS | METH_KEYWORDS, NULL},
39665 { (char *)"ArtProvider_Insert", (PyCFunction) _wrap_ArtProvider_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
39666 { (char *)"ArtProvider_Pop", (PyCFunction)_wrap_ArtProvider_Pop, METH_NOARGS, NULL},
39667 { (char *)"ArtProvider_Delete", (PyCFunction) _wrap_ArtProvider_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
39668 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
39669 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
39670 { (char *)"ArtProvider_GetSizeHint", (PyCFunction) _wrap_ArtProvider_GetSizeHint, METH_VARARGS | METH_KEYWORDS, NULL},
39671 { (char *)"ArtProvider_Destroy", (PyCFunction)_wrap_ArtProvider_Destroy, METH_O, NULL},
39672 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
39673 { (char *)"ArtProvider_swiginit", ArtProvider_swiginit, METH_VARARGS, NULL},
39674 { (char *)"delete_ConfigBase", (PyCFunction)_wrap_delete_ConfigBase, METH_O, NULL},
39675 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
39676 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
39677 { (char *)"ConfigBase_Create", (PyCFunction)_wrap_ConfigBase_Create, METH_NOARGS, NULL},
39678 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction)_wrap_ConfigBase_DontCreateOnDemand, METH_NOARGS, NULL},
39679 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
39680 { (char *)"ConfigBase_GetPath", (PyCFunction)_wrap_ConfigBase_GetPath, METH_O, NULL},
39681 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction)_wrap_ConfigBase_GetFirstGroup, METH_O, NULL},
39682 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39683 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction)_wrap_ConfigBase_GetFirstEntry, METH_O, NULL},
39684 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39685 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
39686 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
39687 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39688 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39689 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
39690 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
39691 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
39692 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
39693 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
39694 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
39695 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
39696 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
39697 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
39698 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
39699 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
39700 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39701 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39702 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39703 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39704 { (char *)"ConfigBase_DeleteAll", (PyCFunction)_wrap_ConfigBase_DeleteAll, METH_O, NULL},
39705 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
39706 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction)_wrap_ConfigBase_IsExpandingEnvVars, METH_O, NULL},
39707 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
39708 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction)_wrap_ConfigBase_IsRecordingDefaults, METH_O, NULL},
39709 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
39710 { (char *)"ConfigBase_GetAppName", (PyCFunction)_wrap_ConfigBase_GetAppName, METH_O, NULL},
39711 { (char *)"ConfigBase_GetVendorName", (PyCFunction)_wrap_ConfigBase_GetVendorName, METH_O, NULL},
39712 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
39713 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
39714 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
39715 { (char *)"ConfigBase_GetStyle", (PyCFunction)_wrap_ConfigBase_GetStyle, METH_O, NULL},
39716 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
39717 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
39718 { (char *)"delete_Config", (PyCFunction)_wrap_delete_Config, METH_O, NULL},
39719 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
39720 { (char *)"Config_swiginit", Config_swiginit, METH_VARARGS, NULL},
39721 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
39722 { (char *)"delete_FileConfig", (PyCFunction)_wrap_delete_FileConfig, METH_O, NULL},
39723 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
39724 { (char *)"FileConfig_swiginit", FileConfig_swiginit, METH_VARARGS, NULL},
39725 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
39726 { (char *)"delete_ConfigPathChanger", (PyCFunction)_wrap_delete_ConfigPathChanger, METH_O, NULL},
39727 { (char *)"ConfigPathChanger_Name", (PyCFunction)_wrap_ConfigPathChanger_Name, METH_O, NULL},
39728 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
39729 { (char *)"ConfigPathChanger_swiginit", ConfigPathChanger_swiginit, METH_VARARGS, NULL},
39730 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
39731 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
39732 { (char *)"DateTime_GetCountry", (PyCFunction)_wrap_DateTime_GetCountry, METH_NOARGS, NULL},
39733 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
39734 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
39735 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
39736 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39737 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
39738 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
39739 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
39740 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39741 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
39742 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
39743 { (char *)"DateTime_GetAmPmStrings", (PyCFunction)_wrap_DateTime_GetAmPmStrings, METH_NOARGS, NULL},
39744 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
39745 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
39746 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
39747 { (char *)"DateTime_Now", (PyCFunction)_wrap_DateTime_Now, METH_NOARGS, NULL},
39748 { (char *)"DateTime_UNow", (PyCFunction)_wrap_DateTime_UNow, METH_NOARGS, NULL},
39749 { (char *)"DateTime_Today", (PyCFunction)_wrap_DateTime_Today, METH_NOARGS, NULL},
39750 { (char *)"new_DateTime", (PyCFunction)_wrap_new_DateTime, METH_NOARGS, NULL},
39751 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
39752 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
39753 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
39754 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
39755 { (char *)"new_DateTimeFromDateTime", (PyCFunction) _wrap_new_DateTimeFromDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
39756 { (char *)"delete_DateTime", (PyCFunction)_wrap_delete_DateTime, METH_O, NULL},
39757 { (char *)"DateTime_SetToCurrent", (PyCFunction)_wrap_DateTime_SetToCurrent, METH_O, NULL},
39758 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
39759 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
39760 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
39761 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
39762 { (char *)"DateTime_ResetTime", (PyCFunction)_wrap_DateTime_ResetTime, METH_O, NULL},
39763 { (char *)"DateTime_GetDateOnly", (PyCFunction)_wrap_DateTime_GetDateOnly, METH_O, NULL},
39764 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
39765 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39766 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
39767 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
39768 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
39769 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
39770 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
39771 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
39772 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
39773 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39774 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39775 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39776 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39777 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39778 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39779 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39780 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
39781 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
39782 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
39783 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
39784 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
39785 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
39786 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
39787 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction)_wrap_DateTime_GetJulianDayNumber, METH_O, NULL},
39788 { (char *)"DateTime_GetJDN", (PyCFunction)_wrap_DateTime_GetJDN, METH_O, NULL},
39789 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction)_wrap_DateTime_GetModifiedJulianDayNumber, METH_O, NULL},
39790 { (char *)"DateTime_GetMJD", (PyCFunction)_wrap_DateTime_GetMJD, METH_O, NULL},
39791 { (char *)"DateTime_GetRataDie", (PyCFunction)_wrap_DateTime_GetRataDie, METH_O, NULL},
39792 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39793 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39794 { (char *)"DateTime_FromTimezone", (PyCFunction) _wrap_DateTime_FromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39795 { (char *)"DateTime_MakeFromTimezone", (PyCFunction) _wrap_DateTime_MakeFromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39796 { (char *)"DateTime_ToUTC", (PyCFunction) _wrap_DateTime_ToUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39797 { (char *)"DateTime_MakeUTC", (PyCFunction) _wrap_DateTime_MakeUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39798 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
39799 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
39800 { (char *)"DateTime_FromUTC", (PyCFunction) _wrap_DateTime_FromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39801 { (char *)"DateTime_MakeFromUTC", (PyCFunction) _wrap_DateTime_MakeFromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39802 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
39803 { (char *)"DateTime_IsValid", (PyCFunction)_wrap_DateTime_IsValid, METH_O, NULL},
39804 { (char *)"DateTime_GetTicks", (PyCFunction)_wrap_DateTime_GetTicks, METH_O, NULL},
39805 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
39806 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39807 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
39808 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39809 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
39810 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
39811 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
39812 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
39813 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
39814 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
39815 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39816 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
39817 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
39818 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
39819 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
39820 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
39821 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
39822 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
39823 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
39824 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
39825 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
39826 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
39827 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
39828 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
39829 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
39830 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
39831 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
39832 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
39833 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
39834 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
39835 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
39836 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
39837 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
39838 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39839 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39840 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
39841 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39842 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
39843 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
39844 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
39845 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
39846 { (char *)"DateTime_FormatDate", (PyCFunction)_wrap_DateTime_FormatDate, METH_O, NULL},
39847 { (char *)"DateTime_FormatTime", (PyCFunction)_wrap_DateTime_FormatTime, METH_O, NULL},
39848 { (char *)"DateTime_FormatISODate", (PyCFunction)_wrap_DateTime_FormatISODate, METH_O, NULL},
39849 { (char *)"DateTime_FormatISOTime", (PyCFunction)_wrap_DateTime_FormatISOTime, METH_O, NULL},
39850 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
39851 { (char *)"DateTime_swiginit", DateTime_swiginit, METH_VARARGS, NULL},
39852 { (char *)"TimeSpan_Milliseconds", (PyCFunction) _wrap_TimeSpan_Milliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
39853 { (char *)"TimeSpan_Millisecond", (PyCFunction)_wrap_TimeSpan_Millisecond, METH_NOARGS, NULL},
39854 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
39855 { (char *)"TimeSpan_Second", (PyCFunction)_wrap_TimeSpan_Second, METH_NOARGS, NULL},
39856 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
39857 { (char *)"TimeSpan_Minute", (PyCFunction)_wrap_TimeSpan_Minute, METH_NOARGS, NULL},
39858 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
39859 { (char *)"TimeSpan_Hour", (PyCFunction)_wrap_TimeSpan_Hour, METH_NOARGS, NULL},
39860 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
39861 { (char *)"TimeSpan_Day", (PyCFunction)_wrap_TimeSpan_Day, METH_NOARGS, NULL},
39862 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
39863 { (char *)"TimeSpan_Week", (PyCFunction)_wrap_TimeSpan_Week, METH_NOARGS, NULL},
39864 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
39865 { (char *)"delete_TimeSpan", (PyCFunction)_wrap_delete_TimeSpan, METH_O, NULL},
39866 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
39867 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
39868 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
39869 { (char *)"TimeSpan_Neg", (PyCFunction)_wrap_TimeSpan_Neg, METH_O, NULL},
39870 { (char *)"TimeSpan_Abs", (PyCFunction)_wrap_TimeSpan_Abs, METH_O, NULL},
39871 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
39872 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
39873 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
39874 { (char *)"TimeSpan___neg__", (PyCFunction)_wrap_TimeSpan___neg__, METH_O, NULL},
39875 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
39876 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
39877 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
39878 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
39879 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
39880 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
39881 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
39882 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
39883 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39884 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39885 { (char *)"TimeSpan_IsNull", (PyCFunction)_wrap_TimeSpan_IsNull, METH_O, NULL},
39886 { (char *)"TimeSpan_IsPositive", (PyCFunction)_wrap_TimeSpan_IsPositive, METH_O, NULL},
39887 { (char *)"TimeSpan_IsNegative", (PyCFunction)_wrap_TimeSpan_IsNegative, METH_O, NULL},
39888 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
39889 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
39890 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
39891 { (char *)"TimeSpan_GetWeeks", (PyCFunction)_wrap_TimeSpan_GetWeeks, METH_O, NULL},
39892 { (char *)"TimeSpan_GetDays", (PyCFunction)_wrap_TimeSpan_GetDays, METH_O, NULL},
39893 { (char *)"TimeSpan_GetHours", (PyCFunction)_wrap_TimeSpan_GetHours, METH_O, NULL},
39894 { (char *)"TimeSpan_GetMinutes", (PyCFunction)_wrap_TimeSpan_GetMinutes, METH_O, NULL},
39895 { (char *)"TimeSpan_GetSeconds", (PyCFunction)_wrap_TimeSpan_GetSeconds, METH_O, NULL},
39896 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction)_wrap_TimeSpan_GetMilliseconds, METH_O, NULL},
39897 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
39898 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
39899 { (char *)"TimeSpan_swiginit", TimeSpan_swiginit, METH_VARARGS, NULL},
39900 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
39901 { (char *)"delete_DateSpan", (PyCFunction)_wrap_delete_DateSpan, METH_O, NULL},
39902 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
39903 { (char *)"DateSpan_Day", (PyCFunction)_wrap_DateSpan_Day, METH_NOARGS, NULL},
39904 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
39905 { (char *)"DateSpan_Week", (PyCFunction)_wrap_DateSpan_Week, METH_NOARGS, NULL},
39906 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
39907 { (char *)"DateSpan_Month", (PyCFunction)_wrap_DateSpan_Month, METH_NOARGS, NULL},
39908 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
39909 { (char *)"DateSpan_Year", (PyCFunction)_wrap_DateSpan_Year, METH_NOARGS, NULL},
39910 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
39911 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
39912 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
39913 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
39914 { (char *)"DateSpan_GetYears", (PyCFunction)_wrap_DateSpan_GetYears, METH_O, NULL},
39915 { (char *)"DateSpan_GetMonths", (PyCFunction)_wrap_DateSpan_GetMonths, METH_O, NULL},
39916 { (char *)"DateSpan_GetWeeks", (PyCFunction)_wrap_DateSpan_GetWeeks, METH_O, NULL},
39917 { (char *)"DateSpan_GetDays", (PyCFunction)_wrap_DateSpan_GetDays, METH_O, NULL},
39918 { (char *)"DateSpan_GetTotalDays", (PyCFunction)_wrap_DateSpan_GetTotalDays, METH_O, NULL},
39919 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
39920 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
39921 { (char *)"DateSpan_Neg", (PyCFunction)_wrap_DateSpan_Neg, METH_O, NULL},
39922 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
39923 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
39924 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
39925 { (char *)"DateSpan___neg__", (PyCFunction)_wrap_DateSpan___neg__, METH_O, NULL},
39926 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
39927 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
39928 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
39929 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
39930 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
39931 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39932 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39933 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
39934 { (char *)"DateSpan_swiginit", DateSpan_swiginit, METH_VARARGS, NULL},
39935 { (char *)"GetLocalTime", (PyCFunction)_wrap_GetLocalTime, METH_NOARGS, NULL},
39936 { (char *)"GetUTCTime", (PyCFunction)_wrap_GetUTCTime, METH_NOARGS, NULL},
39937 { (char *)"GetCurrentTime", (PyCFunction)_wrap_GetCurrentTime, METH_NOARGS, NULL},
39938 { (char *)"GetLocalTimeMillis", (PyCFunction)_wrap_GetLocalTimeMillis, METH_NOARGS, NULL},
39939 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39940 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39941 { (char *)"delete_DataFormat", (PyCFunction)_wrap_delete_DataFormat, METH_O, NULL},
39942 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
39943 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
39944 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
39945 { (char *)"DataFormat_GetType", (PyCFunction)_wrap_DataFormat_GetType, METH_O, NULL},
39946 { (char *)"DataFormat__GetId", (PyCFunction)_wrap_DataFormat__GetId, METH_O, NULL},
39947 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
39948 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
39949 { (char *)"DataFormat_swiginit", DataFormat_swiginit, METH_VARARGS, NULL},
39950 { (char *)"delete_DataObject", (PyCFunction)_wrap_delete_DataObject, METH_O, NULL},
39951 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39952 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
39953 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
39954 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
39955 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
39956 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
39957 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
39958 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
39959 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
39960 { (char *)"DataObjectSimple_GetFormat", (PyCFunction)_wrap_DataObjectSimple_GetFormat, METH_O, NULL},
39961 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39962 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction)_wrap_DataObjectSimple_GetDataSize, METH_O, NULL},
39963 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction)_wrap_DataObjectSimple_GetDataHere, METH_O, NULL},
39964 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
39965 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
39966 { (char *)"DataObjectSimple_swiginit", DataObjectSimple_swiginit, METH_VARARGS, NULL},
39967 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
39968 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39969 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
39970 { (char *)"PyDataObjectSimple_swiginit", PyDataObjectSimple_swiginit, METH_VARARGS, NULL},
39971 { (char *)"new_DataObjectComposite", (PyCFunction)_wrap_new_DataObjectComposite, METH_NOARGS, NULL},
39972 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
39973 { (char *)"DataObjectComposite_GetReceivedFormat", (PyCFunction)_wrap_DataObjectComposite_GetReceivedFormat, METH_O, NULL},
39974 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
39975 { (char *)"DataObjectComposite_swiginit", DataObjectComposite_swiginit, METH_VARARGS, NULL},
39976 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
39977 { (char *)"TextDataObject_GetTextLength", (PyCFunction)_wrap_TextDataObject_GetTextLength, METH_O, NULL},
39978 { (char *)"TextDataObject_GetText", (PyCFunction)_wrap_TextDataObject_GetText, METH_O, NULL},
39979 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
39980 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
39981 { (char *)"TextDataObject_swiginit", TextDataObject_swiginit, METH_VARARGS, NULL},
39982 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
39983 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39984 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
39985 { (char *)"PyTextDataObject_swiginit", PyTextDataObject_swiginit, METH_VARARGS, NULL},
39986 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
39987 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction)_wrap_BitmapDataObject_GetBitmap, METH_O, NULL},
39988 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
39989 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
39990 { (char *)"BitmapDataObject_swiginit", BitmapDataObject_swiginit, METH_VARARGS, NULL},
39991 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
39992 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39993 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
39994 { (char *)"PyBitmapDataObject_swiginit", PyBitmapDataObject_swiginit, METH_VARARGS, NULL},
39995 { (char *)"new_FileDataObject", (PyCFunction)_wrap_new_FileDataObject, METH_NOARGS, NULL},
39996 { (char *)"FileDataObject_GetFilenames", (PyCFunction)_wrap_FileDataObject_GetFilenames, METH_O, NULL},
39997 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
39998 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
39999 { (char *)"FileDataObject_swiginit", FileDataObject_swiginit, METH_VARARGS, NULL},
40000 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
40001 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
40002 { (char *)"CustomDataObject_GetSize", (PyCFunction)_wrap_CustomDataObject_GetSize, METH_O, NULL},
40003 { (char *)"CustomDataObject_GetData", (PyCFunction)_wrap_CustomDataObject_GetData, METH_O, NULL},
40004 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
40005 { (char *)"CustomDataObject_swiginit", CustomDataObject_swiginit, METH_VARARGS, NULL},
40006 { (char *)"new_URLDataObject", (PyCFunction) _wrap_new_URLDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
40007 { (char *)"URLDataObject_GetURL", (PyCFunction)_wrap_URLDataObject_GetURL, METH_O, NULL},
40008 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
40009 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
40010 { (char *)"URLDataObject_swiginit", URLDataObject_swiginit, METH_VARARGS, NULL},
40011 { (char *)"new_MetafileDataObject", (PyCFunction)_wrap_new_MetafileDataObject, METH_NOARGS, NULL},
40012 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
40013 { (char *)"MetafileDataObject_swiginit", MetafileDataObject_swiginit, METH_VARARGS, NULL},
40014 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
40015 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
40016 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
40017 { (char *)"delete_DropSource", (PyCFunction)_wrap_delete_DropSource, METH_O, NULL},
40018 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
40019 { (char *)"DropSource_GetDataObject", (PyCFunction)_wrap_DropSource_GetDataObject, METH_O, NULL},
40020 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
40021 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
40022 { (char *)"DropSource_GiveFeedback", (PyCFunction) _wrap_DropSource_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
40023 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
40024 { (char *)"DropSource_swiginit", DropSource_swiginit, METH_VARARGS, NULL},
40025 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
40026 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
40027 { (char *)"delete_DropTarget", (PyCFunction)_wrap_delete_DropTarget, METH_O, NULL},
40028 { (char *)"DropTarget_GetDataObject", (PyCFunction)_wrap_DropTarget_GetDataObject, METH_O, NULL},
40029 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
40030 { (char *)"DropTarget_OnEnter", (PyCFunction) _wrap_DropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
40031 { (char *)"DropTarget_OnDragOver", (PyCFunction) _wrap_DropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
40032 { (char *)"DropTarget_OnLeave", (PyCFunction)_wrap_DropTarget_OnLeave, METH_O, NULL},
40033 { (char *)"DropTarget_OnDrop", (PyCFunction) _wrap_DropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
40034 { (char *)"DropTarget_GetData", (PyCFunction)_wrap_DropTarget_GetData, METH_O, NULL},
40035 { (char *)"DropTarget_SetDefaultAction", (PyCFunction) _wrap_DropTarget_SetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
40036 { (char *)"DropTarget_GetDefaultAction", (PyCFunction)_wrap_DropTarget_GetDefaultAction, METH_O, NULL},
40037 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
40038 { (char *)"DropTarget_swiginit", DropTarget_swiginit, METH_VARARGS, NULL},
40039 { (char *)"new_TextDropTarget", (PyCFunction)_wrap_new_TextDropTarget, METH_NOARGS, NULL},
40040 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
40041 { (char *)"TextDropTarget_OnDropText", (PyCFunction) _wrap_TextDropTarget_OnDropText, METH_VARARGS | METH_KEYWORDS, NULL},
40042 { (char *)"TextDropTarget_OnEnter", (PyCFunction) _wrap_TextDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
40043 { (char *)"TextDropTarget_OnDragOver", (PyCFunction) _wrap_TextDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
40044 { (char *)"TextDropTarget_OnLeave", (PyCFunction)_wrap_TextDropTarget_OnLeave, METH_O, NULL},
40045 { (char *)"TextDropTarget_OnDrop", (PyCFunction) _wrap_TextDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
40046 { (char *)"TextDropTarget_OnData", (PyCFunction) _wrap_TextDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
40047 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
40048 { (char *)"TextDropTarget_swiginit", TextDropTarget_swiginit, METH_VARARGS, NULL},
40049 { (char *)"new_FileDropTarget", (PyCFunction)_wrap_new_FileDropTarget, METH_NOARGS, NULL},
40050 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
40051 { (char *)"FileDropTarget_OnDropFiles", (PyCFunction) _wrap_FileDropTarget_OnDropFiles, METH_VARARGS | METH_KEYWORDS, NULL},
40052 { (char *)"FileDropTarget_OnEnter", (PyCFunction) _wrap_FileDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
40053 { (char *)"FileDropTarget_OnDragOver", (PyCFunction) _wrap_FileDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
40054 { (char *)"FileDropTarget_OnLeave", (PyCFunction)_wrap_FileDropTarget_OnLeave, METH_O, NULL},
40055 { (char *)"FileDropTarget_OnDrop", (PyCFunction) _wrap_FileDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
40056 { (char *)"FileDropTarget_OnData", (PyCFunction) _wrap_FileDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
40057 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
40058 { (char *)"FileDropTarget_swiginit", FileDropTarget_swiginit, METH_VARARGS, NULL},
40059 { (char *)"new_Clipboard", (PyCFunction)_wrap_new_Clipboard, METH_NOARGS, NULL},
40060 { (char *)"delete_Clipboard", (PyCFunction)_wrap_delete_Clipboard, METH_O, NULL},
40061 { (char *)"Clipboard_Open", (PyCFunction)_wrap_Clipboard_Open, METH_O, NULL},
40062 { (char *)"Clipboard_Close", (PyCFunction)_wrap_Clipboard_Close, METH_O, NULL},
40063 { (char *)"Clipboard_IsOpened", (PyCFunction)_wrap_Clipboard_IsOpened, METH_O, NULL},
40064 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
40065 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
40066 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
40067 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
40068 { (char *)"Clipboard_Clear", (PyCFunction)_wrap_Clipboard_Clear, METH_O, NULL},
40069 { (char *)"Clipboard_Flush", (PyCFunction)_wrap_Clipboard_Flush, METH_O, NULL},
40070 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
40071 { (char *)"Clipboard_Get", (PyCFunction)_wrap_Clipboard_Get, METH_NOARGS, NULL},
40072 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
40073 { (char *)"Clipboard_swiginit", Clipboard_swiginit, METH_VARARGS, NULL},
40074 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
40075 { (char *)"delete_ClipboardLocker", (PyCFunction)_wrap_delete_ClipboardLocker, METH_O, NULL},
40076 { (char *)"ClipboardLocker___nonzero__", (PyCFunction)_wrap_ClipboardLocker___nonzero__, METH_O, NULL},
40077 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
40078 { (char *)"ClipboardLocker_swiginit", ClipboardLocker_swiginit, METH_VARARGS, NULL},
40079 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
40080 { (char *)"delete_VideoMode", (PyCFunction)_wrap_delete_VideoMode, METH_O, NULL},
40081 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
40082 { (char *)"VideoMode_GetWidth", (PyCFunction)_wrap_VideoMode_GetWidth, METH_O, NULL},
40083 { (char *)"VideoMode_GetHeight", (PyCFunction)_wrap_VideoMode_GetHeight, METH_O, NULL},
40084 { (char *)"VideoMode_GetDepth", (PyCFunction)_wrap_VideoMode_GetDepth, METH_O, NULL},
40085 { (char *)"VideoMode_IsOk", (PyCFunction)_wrap_VideoMode_IsOk, METH_O, NULL},
40086 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
40087 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
40088 { (char *)"VideoMode_w_set", _wrap_VideoMode_w_set, METH_VARARGS, NULL},
40089 { (char *)"VideoMode_w_get", (PyCFunction)_wrap_VideoMode_w_get, METH_O, NULL},
40090 { (char *)"VideoMode_h_set", _wrap_VideoMode_h_set, METH_VARARGS, NULL},
40091 { (char *)"VideoMode_h_get", (PyCFunction)_wrap_VideoMode_h_get, METH_O, NULL},
40092 { (char *)"VideoMode_bpp_set", _wrap_VideoMode_bpp_set, METH_VARARGS, NULL},
40093 { (char *)"VideoMode_bpp_get", (PyCFunction)_wrap_VideoMode_bpp_get, METH_O, NULL},
40094 { (char *)"VideoMode_refresh_set", _wrap_VideoMode_refresh_set, METH_VARARGS, NULL},
40095 { (char *)"VideoMode_refresh_get", (PyCFunction)_wrap_VideoMode_refresh_get, METH_O, NULL},
40096 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
40097 { (char *)"VideoMode_swiginit", VideoMode_swiginit, METH_VARARGS, NULL},
40098 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
40099 { (char *)"delete_Display", (PyCFunction)_wrap_delete_Display, METH_O, NULL},
40100 { (char *)"Display_GetCount", (PyCFunction)_wrap_Display_GetCount, METH_NOARGS, NULL},
40101 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
40102 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
40103 { (char *)"Display_IsOk", (PyCFunction)_wrap_Display_IsOk, METH_O, NULL},
40104 { (char *)"Display_GetGeometry", (PyCFunction)_wrap_Display_GetGeometry, METH_O, NULL},
40105 { (char *)"Display_GetClientArea", (PyCFunction)_wrap_Display_GetClientArea, METH_O, NULL},
40106 { (char *)"Display_GetName", (PyCFunction)_wrap_Display_GetName, METH_O, NULL},
40107 { (char *)"Display_IsPrimary", (PyCFunction)_wrap_Display_IsPrimary, METH_O, NULL},
40108 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
40109 { (char *)"Display_GetCurrentMode", (PyCFunction)_wrap_Display_GetCurrentMode, METH_O, NULL},
40110 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
40111 { (char *)"Display_ResetMode", (PyCFunction)_wrap_Display_ResetMode, METH_O, NULL},
40112 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
40113 { (char *)"Display_swiginit", Display_swiginit, METH_VARARGS, NULL},
40114 { (char *)"StandardPaths_Get", (PyCFunction)_wrap_StandardPaths_Get, METH_NOARGS, NULL},
40115 { (char *)"StandardPaths_GetExecutablePath", (PyCFunction)_wrap_StandardPaths_GetExecutablePath, METH_O, NULL},
40116 { (char *)"StandardPaths_GetConfigDir", (PyCFunction)_wrap_StandardPaths_GetConfigDir, METH_O, NULL},
40117 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction)_wrap_StandardPaths_GetUserConfigDir, METH_O, NULL},
40118 { (char *)"StandardPaths_GetDataDir", (PyCFunction)_wrap_StandardPaths_GetDataDir, METH_O, NULL},
40119 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetLocalDataDir, METH_O, NULL},
40120 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction)_wrap_StandardPaths_GetUserDataDir, METH_O, NULL},
40121 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetUserLocalDataDir, METH_O, NULL},
40122 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction)_wrap_StandardPaths_GetPluginsDir, METH_O, NULL},
40123 { (char *)"StandardPaths_GetResourcesDir", (PyCFunction)_wrap_StandardPaths_GetResourcesDir, METH_O, NULL},
40124 { (char *)"StandardPaths_GetLocalizedResourcesDir", (PyCFunction) _wrap_StandardPaths_GetLocalizedResourcesDir, METH_VARARGS | METH_KEYWORDS, NULL},
40125 { (char *)"StandardPaths_GetDocumentsDir", (PyCFunction)_wrap_StandardPaths_GetDocumentsDir, METH_O, NULL},
40126 { (char *)"StandardPaths_GetTempDir", (PyCFunction)_wrap_StandardPaths_GetTempDir, METH_O, NULL},
40127 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
40128 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction)_wrap_StandardPaths_GetInstallPrefix, METH_O, NULL},
40129 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
40130 { (char *)"new_PowerEvent", (PyCFunction) _wrap_new_PowerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
40131 { (char *)"PowerEvent_Veto", (PyCFunction)_wrap_PowerEvent_Veto, METH_O, NULL},
40132 { (char *)"PowerEvent_IsVetoed", (PyCFunction)_wrap_PowerEvent_IsVetoed, METH_O, NULL},
40133 { (char *)"PowerEvent_swigregister", PowerEvent_swigregister, METH_VARARGS, NULL},
40134 { (char *)"PowerEvent_swiginit", PowerEvent_swiginit, METH_VARARGS, NULL},
40135 { (char *)"GetPowerType", (PyCFunction)_wrap_GetPowerType, METH_NOARGS, NULL},
40136 { (char *)"GetBatteryState", (PyCFunction)_wrap_GetBatteryState, METH_NOARGS, NULL},
40137 { (char *)"new_AboutDialogInfo", (PyCFunction)_wrap_new_AboutDialogInfo, METH_NOARGS, NULL},
40138 { (char *)"delete_AboutDialogInfo", (PyCFunction)_wrap_delete_AboutDialogInfo, METH_O, NULL},
40139 { (char *)"AboutDialogInfo_SetName", (PyCFunction) _wrap_AboutDialogInfo_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
40140 { (char *)"AboutDialogInfo_GetName", (PyCFunction)_wrap_AboutDialogInfo_GetName, METH_O, NULL},
40141 { (char *)"AboutDialogInfo_SetVersion", (PyCFunction) _wrap_AboutDialogInfo_SetVersion, METH_VARARGS | METH_KEYWORDS, NULL},
40142 { (char *)"AboutDialogInfo_HasVersion", (PyCFunction)_wrap_AboutDialogInfo_HasVersion, METH_O, NULL},
40143 { (char *)"AboutDialogInfo_GetVersion", (PyCFunction)_wrap_AboutDialogInfo_GetVersion, METH_O, NULL},
40144 { (char *)"AboutDialogInfo_SetDescription", (PyCFunction) _wrap_AboutDialogInfo_SetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
40145 { (char *)"AboutDialogInfo_HasDescription", (PyCFunction)_wrap_AboutDialogInfo_HasDescription, METH_O, NULL},
40146 { (char *)"AboutDialogInfo_GetDescription", (PyCFunction)_wrap_AboutDialogInfo_GetDescription, METH_O, NULL},
40147 { (char *)"AboutDialogInfo_SetCopyright", (PyCFunction) _wrap_AboutDialogInfo_SetCopyright, METH_VARARGS | METH_KEYWORDS, NULL},
40148 { (char *)"AboutDialogInfo_HasCopyright", (PyCFunction)_wrap_AboutDialogInfo_HasCopyright, METH_O, NULL},
40149 { (char *)"AboutDialogInfo_GetCopyright", (PyCFunction)_wrap_AboutDialogInfo_GetCopyright, METH_O, NULL},
40150 { (char *)"AboutDialogInfo_SetLicence", (PyCFunction) _wrap_AboutDialogInfo_SetLicence, METH_VARARGS | METH_KEYWORDS, NULL},
40151 { (char *)"AboutDialogInfo_SetLicense", (PyCFunction) _wrap_AboutDialogInfo_SetLicense, METH_VARARGS | METH_KEYWORDS, NULL},
40152 { (char *)"AboutDialogInfo_HasLicence", (PyCFunction)_wrap_AboutDialogInfo_HasLicence, METH_O, NULL},
40153 { (char *)"AboutDialogInfo_GetLicence", (PyCFunction)_wrap_AboutDialogInfo_GetLicence, METH_O, NULL},
40154 { (char *)"AboutDialogInfo_SetIcon", (PyCFunction) _wrap_AboutDialogInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
40155 { (char *)"AboutDialogInfo_HasIcon", (PyCFunction)_wrap_AboutDialogInfo_HasIcon, METH_O, NULL},
40156 { (char *)"AboutDialogInfo_GetIcon", (PyCFunction)_wrap_AboutDialogInfo_GetIcon, METH_O, NULL},
40157 { (char *)"AboutDialogInfo__SetWebSite", (PyCFunction) _wrap_AboutDialogInfo__SetWebSite, METH_VARARGS | METH_KEYWORDS, NULL},
40158 { (char *)"AboutDialogInfo__GetWebSiteURL", (PyCFunction)_wrap_AboutDialogInfo__GetWebSiteURL, METH_O, NULL},
40159 { (char *)"AboutDialogInfo__GetWebSiteDescription", (PyCFunction)_wrap_AboutDialogInfo__GetWebSiteDescription, METH_O, NULL},
40160 { (char *)"AboutDialogInfo_HasWebSite", (PyCFunction)_wrap_AboutDialogInfo_HasWebSite, METH_O, NULL},
40161 { (char *)"AboutDialogInfo_SetDevelopers", (PyCFunction) _wrap_AboutDialogInfo_SetDevelopers, METH_VARARGS | METH_KEYWORDS, NULL},
40162 { (char *)"AboutDialogInfo_AddDeveloper", (PyCFunction) _wrap_AboutDialogInfo_AddDeveloper, METH_VARARGS | METH_KEYWORDS, NULL},
40163 { (char *)"AboutDialogInfo_HasDevelopers", (PyCFunction)_wrap_AboutDialogInfo_HasDevelopers, METH_O, NULL},
40164 { (char *)"AboutDialogInfo_GetDevelopers", (PyCFunction)_wrap_AboutDialogInfo_GetDevelopers, METH_O, NULL},
40165 { (char *)"AboutDialogInfo_SetDocWriters", (PyCFunction) _wrap_AboutDialogInfo_SetDocWriters, METH_VARARGS | METH_KEYWORDS, NULL},
40166 { (char *)"AboutDialogInfo_AddDocWriter", (PyCFunction) _wrap_AboutDialogInfo_AddDocWriter, METH_VARARGS | METH_KEYWORDS, NULL},
40167 { (char *)"AboutDialogInfo_HasDocWriters", (PyCFunction)_wrap_AboutDialogInfo_HasDocWriters, METH_O, NULL},
40168 { (char *)"AboutDialogInfo_GetDocWriters", (PyCFunction)_wrap_AboutDialogInfo_GetDocWriters, METH_O, NULL},
40169 { (char *)"AboutDialogInfo_SetArtists", (PyCFunction) _wrap_AboutDialogInfo_SetArtists, METH_VARARGS | METH_KEYWORDS, NULL},
40170 { (char *)"AboutDialogInfo_AddArtist", (PyCFunction) _wrap_AboutDialogInfo_AddArtist, METH_VARARGS | METH_KEYWORDS, NULL},
40171 { (char *)"AboutDialogInfo_HasArtists", (PyCFunction)_wrap_AboutDialogInfo_HasArtists, METH_O, NULL},
40172 { (char *)"AboutDialogInfo_GetArtists", (PyCFunction)_wrap_AboutDialogInfo_GetArtists, METH_O, NULL},
40173 { (char *)"AboutDialogInfo_SetTranslators", (PyCFunction) _wrap_AboutDialogInfo_SetTranslators, METH_VARARGS | METH_KEYWORDS, NULL},
40174 { (char *)"AboutDialogInfo_AddTranslator", (PyCFunction) _wrap_AboutDialogInfo_AddTranslator, METH_VARARGS | METH_KEYWORDS, NULL},
40175 { (char *)"AboutDialogInfo_HasTranslators", (PyCFunction)_wrap_AboutDialogInfo_HasTranslators, METH_O, NULL},
40176 { (char *)"AboutDialogInfo_GetTranslators", (PyCFunction)_wrap_AboutDialogInfo_GetTranslators, METH_O, NULL},
40177 { (char *)"AboutDialogInfo_IsSimple", (PyCFunction)_wrap_AboutDialogInfo_IsSimple, METH_O, NULL},
40178 { (char *)"AboutDialogInfo_GetDescriptionAndCredits", (PyCFunction)_wrap_AboutDialogInfo_GetDescriptionAndCredits, METH_O, NULL},
40179 { (char *)"AboutDialogInfo_swigregister", AboutDialogInfo_swigregister, METH_VARARGS, NULL},
40180 { (char *)"AboutDialogInfo_swiginit", AboutDialogInfo_swiginit, METH_VARARGS, NULL},
40181 { (char *)"AboutBox", (PyCFunction) _wrap_AboutBox, METH_VARARGS | METH_KEYWORDS, NULL},
40182 { NULL, NULL, 0, NULL }
40183 };
40184
40185
40186 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
40187
40188 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
40189 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
40190 }
40191 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
40192 return (void *)((wxEvent *) ((wxMenuEvent *) x));
40193 }
40194 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
40195 return (void *)((wxEvent *) ((wxCloseEvent *) x));
40196 }
40197 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
40198 return (void *)((wxEvent *) ((wxMouseEvent *) x));
40199 }
40200 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
40201 return (void *)((wxEvent *) ((wxEraseEvent *) x));
40202 }
40203 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
40204 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
40205 }
40206 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
40207 return (void *)((wxEvent *) ((wxTimerEvent *) x));
40208 }
40209 static void *_p_wxPowerEventTo_p_wxEvent(void *x) {
40210 return (void *)((wxEvent *) ((wxPowerEvent *) x));
40211 }
40212 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
40213 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
40214 }
40215 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
40216 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
40217 }
40218 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
40219 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
40220 }
40221 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
40222 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
40223 }
40224 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
40225 return (void *)((wxEvent *) ((wxPyEvent *) x));
40226 }
40227 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
40228 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
40229 }
40230 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
40231 return (void *)((wxEvent *) ((wxIdleEvent *) x));
40232 }
40233 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
40234 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
40235 }
40236 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
40237 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
40238 }
40239 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
40240 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
40241 }
40242 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
40243 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
40244 }
40245 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
40246 return (void *)((wxEvent *) ((wxActivateEvent *) x));
40247 }
40248 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
40249 return (void *)((wxEvent *) ((wxSizeEvent *) x));
40250 }
40251 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
40252 return (void *)((wxEvent *) ((wxMoveEvent *) x));
40253 }
40254 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
40255 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
40256 }
40257 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
40258 return (void *)((wxEvent *) ((wxPaintEvent *) x));
40259 }
40260 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
40261 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
40262 }
40263 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
40264 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
40265 }
40266 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
40267 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
40268 }
40269 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
40270 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
40271 }
40272 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
40273 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
40274 }
40275 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
40276 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
40277 }
40278 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
40279 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
40280 }
40281 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
40282 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
40283 }
40284 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
40285 return (void *)((wxEvent *) ((wxFocusEvent *) x));
40286 }
40287 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
40288 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
40289 }
40290 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
40291 return (void *)((wxEvent *) ((wxProcessEvent *) x));
40292 }
40293 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
40294 return (void *)((wxEvent *) ((wxShowEvent *) x));
40295 }
40296 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
40297 return (void *)((wxEvent *) ((wxCommandEvent *) x));
40298 }
40299 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
40300 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
40301 }
40302 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
40303 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
40304 }
40305 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
40306 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
40307 }
40308 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
40309 return (void *)((wxEvent *) ((wxKeyEvent *) x));
40310 }
40311 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
40312 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
40313 }
40314 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
40315 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
40316 }
40317 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
40318 return (void *)((wxConfigBase *) ((wxConfig *) x));
40319 }
40320 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
40321 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
40322 }
40323 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
40324 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
40325 }
40326 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
40327 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
40328 }
40329 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
40330 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
40331 }
40332 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
40333 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
40334 }
40335 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
40336 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
40337 }
40338 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
40339 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
40340 }
40341 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
40342 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
40343 }
40344 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
40345 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
40346 }
40347 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
40348 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
40349 }
40350 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
40351 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
40352 }
40353 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
40354 return (void *)((wxDataObject *) ((wxURLDataObject *) x));
40355 }
40356 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
40357 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
40358 }
40359 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
40360 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
40361 }
40362 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
40363 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
40364 }
40365 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
40366 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
40367 }
40368 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
40369 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
40370 }
40371 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
40372 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
40373 }
40374 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
40375 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
40376 }
40377 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
40378 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
40379 }
40380 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
40381 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
40382 }
40383 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
40384 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
40385 }
40386 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
40387 return (void *)((wxEvtHandler *) ((wxWindow *) x));
40388 }
40389 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
40390 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
40391 }
40392 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
40393 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
40394 }
40395 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
40396 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
40397 }
40398 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
40399 return (void *)((wxEvtHandler *) ((wxValidator *) x));
40400 }
40401 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
40402 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
40403 }
40404 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
40405 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
40406 }
40407 static void *_p_wxEventBlockerTo_p_wxEvtHandler(void *x) {
40408 return (void *)((wxEvtHandler *) ((wxEventBlocker *) x));
40409 }
40410 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
40411 return (void *)((wxEvtHandler *) ((wxMenu *) x));
40412 }
40413 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
40414 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
40415 }
40416 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
40417 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
40418 }
40419 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
40420 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
40421 }
40422 static void *_p_wxEventBlockerTo_p_wxObject(void *x) {
40423 return (void *)((wxObject *) (wxEvtHandler *) ((wxEventBlocker *) x));
40424 }
40425 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
40426 return (void *)((wxObject *) ((wxSizerItem *) x));
40427 }
40428 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
40429 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
40430 }
40431 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
40432 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
40433 }
40434 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
40435 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
40436 }
40437 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
40438 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
40439 }
40440 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
40441 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
40442 }
40443 static void *_p_wxSizerTo_p_wxObject(void *x) {
40444 return (void *)((wxObject *) ((wxSizer *) x));
40445 }
40446 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
40447 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
40448 }
40449 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
40450 return (void *)((wxObject *) ((wxFileHistory *) x));
40451 }
40452 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
40453 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
40454 }
40455 static void *_p_wxEventTo_p_wxObject(void *x) {
40456 return (void *)((wxObject *) ((wxEvent *) x));
40457 }
40458 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
40459 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
40460 }
40461 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
40462 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
40463 }
40464 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
40465 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
40466 }
40467 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
40468 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
40469 }
40470 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
40471 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
40472 }
40473 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
40474 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
40475 }
40476 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
40477 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
40478 }
40479 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
40480 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
40481 }
40482 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
40483 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
40484 }
40485 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
40486 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
40487 }
40488 static void *_p_wxControlTo_p_wxObject(void *x) {
40489 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
40490 }
40491 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
40492 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
40493 }
40494 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
40495 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
40496 }
40497 static void *_p_wxPowerEventTo_p_wxObject(void *x) {
40498 return (void *)((wxObject *) (wxEvent *) ((wxPowerEvent *) x));
40499 }
40500 static void *_p_wxFSFileTo_p_wxObject(void *x) {
40501 return (void *)((wxObject *) ((wxFSFile *) x));
40502 }
40503 static void *_p_wxClipboardTo_p_wxObject(void *x) {
40504 return (void *)((wxObject *) ((wxClipboard *) x));
40505 }
40506 static void *_p_wxPySizerTo_p_wxObject(void *x) {
40507 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
40508 }
40509 static void *_p_wxPyEventTo_p_wxObject(void *x) {
40510 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
40511 }
40512 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
40513 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
40514 }
40515 static void *_p_wxShowEventTo_p_wxObject(void *x) {
40516 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
40517 }
40518 static void *_p_wxToolTipTo_p_wxObject(void *x) {
40519 return (void *)((wxObject *) ((wxToolTip *) x));
40520 }
40521 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
40522 return (void *)((wxObject *) ((wxMenuItem *) x));
40523 }
40524 static void *_p_wxDateEventTo_p_wxObject(void *x) {
40525 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
40526 }
40527 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
40528 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
40529 }
40530 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
40531 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
40532 }
40533 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
40534 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
40535 }
40536 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
40537 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
40538 }
40539 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
40540 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
40541 }
40542 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
40543 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
40544 }
40545 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
40546 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
40547 }
40548 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
40549 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
40550 }
40551 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
40552 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
40553 }
40554 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
40555 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
40556 }
40557 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
40558 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
40559 }
40560 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
40561 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
40562 }
40563 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
40564 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
40565 }
40566 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
40567 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
40568 }
40569 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
40570 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
40571 }
40572 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
40573 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
40574 }
40575 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
40576 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
40577 }
40578 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
40579 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
40580 }
40581 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
40582 return (void *)((wxObject *) ((wxImageHandler *) x));
40583 }
40584 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
40585 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
40586 }
40587 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
40588 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
40589 }
40590 static void *_p_wxTGAHandlerTo_p_wxObject(void *x) {
40591 return (void *)((wxObject *) (wxImageHandler *) ((wxTGAHandler *) x));
40592 }
40593 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
40594 return (void *)((wxObject *) ((wxEvtHandler *) x));
40595 }
40596 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
40597 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
40598 }
40599 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
40600 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
40601 }
40602 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
40603 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
40604 }
40605 static void *_p_wxImageTo_p_wxObject(void *x) {
40606 return (void *)((wxObject *) ((wxImage *) x));
40607 }
40608 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
40609 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
40610 }
40611 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
40612 return (void *)((wxObject *) ((wxSystemOptions *) x));
40613 }
40614 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
40615 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
40616 }
40617 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
40618 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
40619 }
40620 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
40621 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
40622 }
40623 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
40624 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
40625 }
40626 static void *_p_wxWindowTo_p_wxObject(void *x) {
40627 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
40628 }
40629 static void *_p_wxMenuTo_p_wxObject(void *x) {
40630 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
40631 }
40632 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
40633 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
40634 }
40635 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
40636 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
40637 }
40638 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
40639 return (void *)((wxObject *) ((wxFileSystem *) x));
40640 }
40641 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
40642 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
40643 }
40644 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
40645 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
40646 }
40647 static void *_p_wxPyAppTo_p_wxObject(void *x) {
40648 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
40649 }
40650 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
40651 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
40652 }
40653 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
40654 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
40655 }
40656 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
40657 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
40658 }
40659 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
40660 return (void *)((wxObject *) ((wxBusyInfo *) x));
40661 }
40662 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
40663 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
40664 }
40665 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
40666 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
40667 }
40668 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
40669 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
40670 }
40671 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
40672 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
40673 }
40674 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
40675 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
40676 }
40677 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
40678 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
40679 }
40680 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
40681 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
40682 }
40683 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
40684 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
40685 }
40686 static void *_p_wxValidatorTo_p_wxObject(void *x) {
40687 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
40688 }
40689 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
40690 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
40691 }
40692 static void *_p_wxLogBufferTo_p_wxLog(void *x) {
40693 return (void *)((wxLog *) ((wxLogBuffer *) x));
40694 }
40695 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
40696 return (void *)((wxLog *) ((wxLogStderr *) x));
40697 }
40698 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
40699 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
40700 }
40701 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
40702 return (void *)((wxLog *) ((wxLogWindow *) x));
40703 }
40704 static void *_p_wxLogChainTo_p_wxLog(void *x) {
40705 return (void *)((wxLog *) ((wxLogChain *) x));
40706 }
40707 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
40708 return (void *)((wxLog *) ((wxLogGui *) x));
40709 }
40710 static void *_p_wxPyLogTo_p_wxLog(void *x) {
40711 return (void *)((wxLog *) ((wxPyLog *) x));
40712 }
40713 static void *_p_wxControlTo_p_wxWindow(void *x) {
40714 return (void *)((wxWindow *) ((wxControl *) x));
40715 }
40716 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
40717 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
40718 }
40719 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
40720 return (void *)((wxWindow *) ((wxMenuBar *) x));
40721 }
40722 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
40723 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
40724 }
40725 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
40726 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
40727 }
40728 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
40729 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};
40730 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
40731 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
40732 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
40733 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxLogLevel *", 0, 0, (void*)0, 0};
40734 static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
40735 static swig_type_info _swigt__p_wxAboutDialogInfo = {"_p_wxAboutDialogInfo", "wxAboutDialogInfo *", 0, 0, (void*)0, 0};
40736 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
40737 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
40738 static swig_type_info _swigt__p_wxBitmapDataObject = {"_p_wxBitmapDataObject", "wxBitmapDataObject *", 0, 0, (void*)0, 0};
40739 static swig_type_info _swigt__p_wxBusyCursor = {"_p_wxBusyCursor", "wxBusyCursor *", 0, 0, (void*)0, 0};
40740 static swig_type_info _swigt__p_wxBusyInfo = {"_p_wxBusyInfo", "wxBusyInfo *", 0, 0, (void*)0, 0};
40741 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
40742 static swig_type_info _swigt__p_wxChar = {"_p_wxChar", "wxChar *", 0, 0, (void*)0, 0};
40743 static swig_type_info _swigt__p_wxClipboard = {"_p_wxClipboard", "wxClipboard *", 0, 0, (void*)0, 0};
40744 static swig_type_info _swigt__p_wxClipboardLocker = {"_p_wxClipboardLocker", "wxClipboardLocker *", 0, 0, (void*)0, 0};
40745 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
40746 static swig_type_info _swigt__p_wxConfig = {"_p_wxConfig", "wxConfig *", 0, 0, (void*)0, 0};
40747 static swig_type_info _swigt__p_wxConfigBase = {"_p_wxConfigBase", "wxConfigBase *", 0, 0, (void*)0, 0};
40748 static swig_type_info _swigt__p_wxConfigPathChanger = {"_p_wxConfigPathChanger", "wxConfigPathChanger *", 0, 0, (void*)0, 0};
40749 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
40750 static swig_type_info _swigt__p_wxCustomDataObject = {"_p_wxCustomDataObject", "wxCustomDataObject *", 0, 0, (void*)0, 0};
40751 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
40752 static swig_type_info _swigt__p_wxDataFormat = {"_p_wxDataFormat", "wxDataFormat *", 0, 0, (void*)0, 0};
40753 static swig_type_info _swigt__p_wxDataObject = {"_p_wxDataObject", "wxDataObject *", 0, 0, (void*)0, 0};
40754 static swig_type_info _swigt__p_wxDataObjectComposite = {"_p_wxDataObjectComposite", "wxDataObjectComposite *", 0, 0, (void*)0, 0};
40755 static swig_type_info _swigt__p_wxDataObjectSimple = {"_p_wxDataObjectSimple", "wxDataObjectSimple *", 0, 0, (void*)0, 0};
40756 static swig_type_info _swigt__p_wxDateSpan = {"_p_wxDateSpan", "wxDateSpan *", 0, 0, (void*)0, 0};
40757 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
40758 static swig_type_info _swigt__p_wxDateTime__TimeZone = {"_p_wxDateTime__TimeZone", "wxDateTime::TimeZone *", 0, 0, (void*)0, 0};
40759 static swig_type_info _swigt__p_wxDisplay = {"_p_wxDisplay", "wxDisplay *", 0, 0, (void*)0, 0};
40760 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
40761 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
40762 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0, 0};
40763 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0, 0};
40764 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0, 0};
40765 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0, 0};
40766 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0, 0};
40767 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0, 0};
40768 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0, 0};
40769 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0, 0};
40770 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", 0, 0, 0, 0, 0};
40771 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0, 0};
40772 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", 0, 0, 0, 0, 0};
40773 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0, 0};
40774 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0};
40775 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0};
40776 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0, 0};
40777 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0, 0};
40778 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0, 0};
40779 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0, 0};
40780 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0, 0};
40781 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0, 0};
40782 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0, 0};
40783 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0, 0};
40784 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", 0, 0, 0, 0, 0};
40785 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0};
40786 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0};
40787 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0};
40788 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0};
40789 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0};
40790 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0, 0};
40791 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0, 0};
40792 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0, 0};
40793 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0, 0};
40794 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", 0, 0, 0, 0, 0};
40795 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0, 0};
40796 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0};
40797 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0};
40798 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", 0, 0, 0, 0, 0};
40799 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0, 0};
40800 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
40801 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", 0, 0, 0, 0, 0};
40802 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0, 0};
40803 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0, 0};
40804 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0, 0};
40805 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0, 0};
40806 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0, 0};
40807 static swig_type_info _swigt__p_wxEventBlocker = {"_p_wxEventBlocker", 0, 0, 0, 0, 0};
40808 static swig_type_info _swigt__p_wxFileConfig = {"_p_wxFileConfig", "wxFileConfig *", 0, 0, (void*)0, 0};
40809 static swig_type_info _swigt__p_wxFileDataObject = {"_p_wxFileDataObject", "wxFileDataObject *", 0, 0, (void*)0, 0};
40810 static swig_type_info _swigt__p_wxFileHistory = {"_p_wxFileHistory", "wxFileHistory *", 0, 0, (void*)0, 0};
40811 static swig_type_info _swigt__p_wxFileType = {"_p_wxFileType", "wxFileType *", 0, 0, (void*)0, 0};
40812 static swig_type_info _swigt__p_wxFileTypeInfo = {"_p_wxFileTypeInfo", "wxFileTypeInfo *", 0, 0, (void*)0, 0};
40813 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
40814 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
40815 static swig_type_info _swigt__p_wxIcon = {"_p_wxIcon", "wxIcon *", 0, 0, (void*)0, 0};
40816 static swig_type_info _swigt__p_wxJoystick = {"_p_wxJoystick", "wxJoystick *", 0, 0, (void*)0, 0};
40817 static swig_type_info _swigt__p_wxJoystickEvent = {"_p_wxJoystickEvent", "wxJoystickEvent *", 0, 0, (void*)0, 0};
40818 static swig_type_info _swigt__p_wxKillError = {"_p_wxKillError", "enum wxKillError *|wxKillError *", 0, 0, (void*)0, 0};
40819 static swig_type_info _swigt__p_wxLog = {"_p_wxLog", "wxLog *", 0, 0, (void*)0, 0};
40820 static swig_type_info _swigt__p_wxLogBuffer = {"_p_wxLogBuffer", "wxLogBuffer *", 0, 0, (void*)0, 0};
40821 static swig_type_info _swigt__p_wxLogChain = {"_p_wxLogChain", "wxLogChain *", 0, 0, (void*)0, 0};
40822 static swig_type_info _swigt__p_wxLogGui = {"_p_wxLogGui", "wxLogGui *", 0, 0, (void*)0, 0};
40823 static swig_type_info _swigt__p_wxLogNull = {"_p_wxLogNull", "wxLogNull *", 0, 0, (void*)0, 0};
40824 static swig_type_info _swigt__p_wxLogStderr = {"_p_wxLogStderr", "wxLogStderr *", 0, 0, (void*)0, 0};
40825 static swig_type_info _swigt__p_wxLogTextCtrl = {"_p_wxLogTextCtrl", "wxLogTextCtrl *", 0, 0, (void*)0, 0};
40826 static swig_type_info _swigt__p_wxLogWindow = {"_p_wxLogWindow", "wxLogWindow *", 0, 0, (void*)0, 0};
40827 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
40828 static swig_type_info _swigt__p_wxMetafileDataObject = {"_p_wxMetafileDataObject", "wxMetafileDataObject *", 0, 0, (void*)0, 0};
40829 static swig_type_info _swigt__p_wxMimeTypesManager = {"_p_wxMimeTypesManager", "wxMimeTypesManager *", 0, 0, (void*)0, 0};
40830 static swig_type_info _swigt__p_wxMouseState = {"_p_wxMouseState", "wxMouseState *", 0, 0, (void*)0, 0};
40831 static swig_type_info _swigt__p_wxMutexGuiLocker = {"_p_wxMutexGuiLocker", "wxMutexGuiLocker *", 0, 0, (void*)0, 0};
40832 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
40833 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0, 0};
40834 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0, 0};
40835 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0, 0};
40836 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0};
40837 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0};
40838 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0, 0};
40839 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0, 0};
40840 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0, 0};
40841 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0, 0};
40842 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0, 0};
40843 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0, 0};
40844 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0, 0};
40845 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0, 0};
40846 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0, 0};
40847 static swig_type_info _swigt__p_wxTGAHandler = {"_p_wxTGAHandler", 0, 0, 0, 0, 0};
40848 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0, 0};
40849 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0, 0};
40850 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0, 0};
40851 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0, 0};
40852 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0, 0};
40853 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0, 0};
40854 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0, 0};
40855 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0, 0};
40856 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0, 0};
40857 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0, 0};
40858 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0, 0};
40859 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0, 0};
40860 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0};
40861 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0, 0};
40862 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", 0, 0, 0, 0, 0};
40863 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0, 0};
40864 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
40865 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
40866 static swig_type_info _swigt__p_wxPlatformInfo = {"_p_wxPlatformInfo", "wxPlatformInfo *", 0, 0, (void*)0, 0};
40867 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
40868 static swig_type_info _swigt__p_wxPowerEvent = {"_p_wxPowerEvent", "wxPowerEvent *", 0, 0, (void*)0, 0};
40869 static swig_type_info _swigt__p_wxProcessEvent = {"_p_wxProcessEvent", "wxProcessEvent *", 0, 0, (void*)0, 0};
40870 static swig_type_info _swigt__p_wxPyArtProvider = {"_p_wxPyArtProvider", "wxPyArtProvider *", 0, 0, (void*)0, 0};
40871 static swig_type_info _swigt__p_wxPyBitmapDataObject = {"_p_wxPyBitmapDataObject", "wxPyBitmapDataObject *", 0, 0, (void*)0, 0};
40872 static swig_type_info _swigt__p_wxPyDataObjectSimple = {"_p_wxPyDataObjectSimple", "wxPyDataObjectSimple *", 0, 0, (void*)0, 0};
40873 static swig_type_info _swigt__p_wxPyDropSource = {"_p_wxPyDropSource", "wxPyDropSource *", 0, 0, (void*)0, 0};
40874 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
40875 static swig_type_info _swigt__p_wxPyFileDropTarget = {"_p_wxPyFileDropTarget", "wxPyFileDropTarget *", 0, 0, (void*)0, 0};
40876 static swig_type_info _swigt__p_wxPyLog = {"_p_wxPyLog", "wxPyLog *", 0, 0, (void*)0, 0};
40877 static swig_type_info _swigt__p_wxPyProcess = {"_p_wxPyProcess", "wxPyProcess *", 0, 0, (void*)0, 0};
40878 static swig_type_info _swigt__p_wxPyTextDataObject = {"_p_wxPyTextDataObject", "wxPyTextDataObject *", 0, 0, (void*)0, 0};
40879 static swig_type_info _swigt__p_wxPyTextDropTarget = {"_p_wxPyTextDropTarget", "wxPyTextDropTarget *", 0, 0, (void*)0, 0};
40880 static swig_type_info _swigt__p_wxPyTimer = {"_p_wxPyTimer", "wxPyTimer *", 0, 0, (void*)0, 0};
40881 static swig_type_info _swigt__p_wxPyTipProvider = {"_p_wxPyTipProvider", "wxPyTipProvider *", 0, 0, (void*)0, 0};
40882 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
40883 static swig_type_info _swigt__p_wxSingleInstanceChecker = {"_p_wxSingleInstanceChecker", "wxSingleInstanceChecker *", 0, 0, (void*)0, 0};
40884 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
40885 static swig_type_info _swigt__p_wxSound = {"_p_wxSound", "wxSound *", 0, 0, (void*)0, 0};
40886 static swig_type_info _swigt__p_wxStandardPaths = {"_p_wxStandardPaths", "wxStandardPaths *", 0, 0, (void*)0, 0};
40887 static swig_type_info _swigt__p_wxStopWatch = {"_p_wxStopWatch", "wxStopWatch *", 0, 0, (void*)0, 0};
40888 static swig_type_info _swigt__p_wxString = {"_p_wxString", "wxString *", 0, 0, (void*)0, 0};
40889 static swig_type_info _swigt__p_wxSystemOptions = {"_p_wxSystemOptions", "wxSystemOptions *", 0, 0, (void*)0, 0};
40890 static swig_type_info _swigt__p_wxSystemSettings = {"_p_wxSystemSettings", "wxSystemSettings *", 0, 0, (void*)0, 0};
40891 static swig_type_info _swigt__p_wxTextCtrl = {"_p_wxTextCtrl", "wxTextCtrl *", 0, 0, (void*)0, 0};
40892 static swig_type_info _swigt__p_wxTextDataObject = {"_p_wxTextDataObject", "wxTextDataObject *", 0, 0, (void*)0, 0};
40893 static swig_type_info _swigt__p_wxTimeSpan = {"_p_wxTimeSpan", "wxTimeSpan *", 0, 0, (void*)0, 0};
40894 static swig_type_info _swigt__p_wxTimer = {"_p_wxTimer", "wxTimer *", 0, 0, (void*)0, 0};
40895 static swig_type_info _swigt__p_wxTimerEvent = {"_p_wxTimerEvent", "wxTimerEvent *", 0, 0, (void*)0, 0};
40896 static swig_type_info _swigt__p_wxTimerRunner = {"_p_wxTimerRunner", "wxTimerRunner *", 0, 0, (void*)0, 0};
40897 static swig_type_info _swigt__p_wxTipProvider = {"_p_wxTipProvider", "wxTipProvider *", 0, 0, (void*)0, 0};
40898 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
40899 static swig_type_info _swigt__p_wxURLDataObject = {"_p_wxURLDataObject", "wxURLDataObject *", 0, 0, (void*)0, 0};
40900 static swig_type_info _swigt__p_wxVideoMode = {"_p_wxVideoMode", "wxVideoMode *", 0, 0, (void*)0, 0};
40901 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
40902 static swig_type_info _swigt__p_wxWindowDisabler = {"_p_wxWindowDisabler", "wxWindowDisabler *", 0, 0, (void*)0, 0};
40903
40904 static swig_type_info *swig_type_initial[] = {
40905 &_swigt__p_char,
40906 &_swigt__p_form_ops_t,
40907 &_swigt__p_int,
40908 &_swigt__p_unsigned_char,
40909 &_swigt__p_unsigned_int,
40910 &_swigt__p_unsigned_long,
40911 &_swigt__p_void,
40912 &_swigt__p_wxANIHandler,
40913 &_swigt__p_wxAboutDialogInfo,
40914 &_swigt__p_wxAcceleratorTable,
40915 &_swigt__p_wxActivateEvent,
40916 &_swigt__p_wxArrayString,
40917 &_swigt__p_wxBMPHandler,
40918 &_swigt__p_wxBitmap,
40919 &_swigt__p_wxBitmapDataObject,
40920 &_swigt__p_wxBoxSizer,
40921 &_swigt__p_wxBusyCursor,
40922 &_swigt__p_wxBusyInfo,
40923 &_swigt__p_wxCURHandler,
40924 &_swigt__p_wxCaret,
40925 &_swigt__p_wxChar,
40926 &_swigt__p_wxChildFocusEvent,
40927 &_swigt__p_wxClipboard,
40928 &_swigt__p_wxClipboardLocker,
40929 &_swigt__p_wxClipboardTextEvent,
40930 &_swigt__p_wxCloseEvent,
40931 &_swigt__p_wxColour,
40932 &_swigt__p_wxCommandEvent,
40933 &_swigt__p_wxConfig,
40934 &_swigt__p_wxConfigBase,
40935 &_swigt__p_wxConfigPathChanger,
40936 &_swigt__p_wxContextMenuEvent,
40937 &_swigt__p_wxControl,
40938 &_swigt__p_wxControlWithItems,
40939 &_swigt__p_wxCursor,
40940 &_swigt__p_wxCustomDataObject,
40941 &_swigt__p_wxDC,
40942 &_swigt__p_wxDataFormat,
40943 &_swigt__p_wxDataObject,
40944 &_swigt__p_wxDataObjectComposite,
40945 &_swigt__p_wxDataObjectSimple,
40946 &_swigt__p_wxDateEvent,
40947 &_swigt__p_wxDateSpan,
40948 &_swigt__p_wxDateTime,
40949 &_swigt__p_wxDateTime__TimeZone,
40950 &_swigt__p_wxDisplay,
40951 &_swigt__p_wxDisplayChangedEvent,
40952 &_swigt__p_wxDropFilesEvent,
40953 &_swigt__p_wxDuplexMode,
40954 &_swigt__p_wxEraseEvent,
40955 &_swigt__p_wxEvent,
40956 &_swigt__p_wxEventBlocker,
40957 &_swigt__p_wxEvtHandler,
40958 &_swigt__p_wxFSFile,
40959 &_swigt__p_wxFileConfig,
40960 &_swigt__p_wxFileDataObject,
40961 &_swigt__p_wxFileHistory,
40962 &_swigt__p_wxFileSystem,
40963 &_swigt__p_wxFileType,
40964 &_swigt__p_wxFileTypeInfo,
40965 &_swigt__p_wxFlexGridSizer,
40966 &_swigt__p_wxFocusEvent,
40967 &_swigt__p_wxFont,
40968 &_swigt__p_wxFrame,
40969 &_swigt__p_wxGBSizerItem,
40970 &_swigt__p_wxGIFHandler,
40971 &_swigt__p_wxGridBagSizer,
40972 &_swigt__p_wxGridSizer,
40973 &_swigt__p_wxICOHandler,
40974 &_swigt__p_wxIcon,
40975 &_swigt__p_wxIconizeEvent,
40976 &_swigt__p_wxIdleEvent,
40977 &_swigt__p_wxImage,
40978 &_swigt__p_wxImageHandler,
40979 &_swigt__p_wxIndividualLayoutConstraint,
40980 &_swigt__p_wxInitDialogEvent,
40981 &_swigt__p_wxJPEGHandler,
40982 &_swigt__p_wxJoystick,
40983 &_swigt__p_wxJoystickEvent,
40984 &_swigt__p_wxKeyEvent,
40985 &_swigt__p_wxKillError,
40986 &_swigt__p_wxLayoutConstraints,
40987 &_swigt__p_wxLog,
40988 &_swigt__p_wxLogBuffer,
40989 &_swigt__p_wxLogChain,
40990 &_swigt__p_wxLogGui,
40991 &_swigt__p_wxLogNull,
40992 &_swigt__p_wxLogStderr,
40993 &_swigt__p_wxLogTextCtrl,
40994 &_swigt__p_wxLogWindow,
40995 &_swigt__p_wxMaximizeEvent,
40996 &_swigt__p_wxMenu,
40997 &_swigt__p_wxMenuBar,
40998 &_swigt__p_wxMenuEvent,
40999 &_swigt__p_wxMenuItem,
41000 &_swigt__p_wxMetafileDataObject,
41001 &_swigt__p_wxMimeTypesManager,
41002 &_swigt__p_wxMouseCaptureChangedEvent,
41003 &_swigt__p_wxMouseCaptureLostEvent,
41004 &_swigt__p_wxMouseEvent,
41005 &_swigt__p_wxMouseState,
41006 &_swigt__p_wxMoveEvent,
41007 &_swigt__p_wxMutexGuiLocker,
41008 &_swigt__p_wxNavigationKeyEvent,
41009 &_swigt__p_wxNcPaintEvent,
41010 &_swigt__p_wxNotifyEvent,
41011 &_swigt__p_wxObject,
41012 &_swigt__p_wxOutputStream,
41013 &_swigt__p_wxPCXHandler,
41014 &_swigt__p_wxPNGHandler,
41015 &_swigt__p_wxPNMHandler,
41016 &_swigt__p_wxPaintEvent,
41017 &_swigt__p_wxPaletteChangedEvent,
41018 &_swigt__p_wxPaperSize,
41019 &_swigt__p_wxPlatformInfo,
41020 &_swigt__p_wxPoint,
41021 &_swigt__p_wxPowerEvent,
41022 &_swigt__p_wxProcessEvent,
41023 &_swigt__p_wxPyApp,
41024 &_swigt__p_wxPyArtProvider,
41025 &_swigt__p_wxPyBitmapDataObject,
41026 &_swigt__p_wxPyCommandEvent,
41027 &_swigt__p_wxPyDataObjectSimple,
41028 &_swigt__p_wxPyDropSource,
41029 &_swigt__p_wxPyDropTarget,
41030 &_swigt__p_wxPyEvent,
41031 &_swigt__p_wxPyFileDropTarget,
41032 &_swigt__p_wxPyImageHandler,
41033 &_swigt__p_wxPyLog,
41034 &_swigt__p_wxPyProcess,
41035 &_swigt__p_wxPySizer,
41036 &_swigt__p_wxPyTextDataObject,
41037 &_swigt__p_wxPyTextDropTarget,
41038 &_swigt__p_wxPyTimer,
41039 &_swigt__p_wxPyTipProvider,
41040 &_swigt__p_wxPyValidator,
41041 &_swigt__p_wxQueryNewPaletteEvent,
41042 &_swigt__p_wxRect,
41043 &_swigt__p_wxScrollEvent,
41044 &_swigt__p_wxScrollWinEvent,
41045 &_swigt__p_wxSetCursorEvent,
41046 &_swigt__p_wxShowEvent,
41047 &_swigt__p_wxSingleInstanceChecker,
41048 &_swigt__p_wxSize,
41049 &_swigt__p_wxSizeEvent,
41050 &_swigt__p_wxSizer,
41051 &_swigt__p_wxSizerItem,
41052 &_swigt__p_wxSound,
41053 &_swigt__p_wxStandardPaths,
41054 &_swigt__p_wxStaticBoxSizer,
41055 &_swigt__p_wxStdDialogButtonSizer,
41056 &_swigt__p_wxStopWatch,
41057 &_swigt__p_wxString,
41058 &_swigt__p_wxSysColourChangedEvent,
41059 &_swigt__p_wxSystemOptions,
41060 &_swigt__p_wxSystemSettings,
41061 &_swigt__p_wxTGAHandler,
41062 &_swigt__p_wxTIFFHandler,
41063 &_swigt__p_wxTextCtrl,
41064 &_swigt__p_wxTextDataObject,
41065 &_swigt__p_wxTimeSpan,
41066 &_swigt__p_wxTimer,
41067 &_swigt__p_wxTimerEvent,
41068 &_swigt__p_wxTimerRunner,
41069 &_swigt__p_wxTipProvider,
41070 &_swigt__p_wxToolTip,
41071 &_swigt__p_wxURLDataObject,
41072 &_swigt__p_wxUpdateUIEvent,
41073 &_swigt__p_wxValidator,
41074 &_swigt__p_wxVideoMode,
41075 &_swigt__p_wxWindow,
41076 &_swigt__p_wxWindowCreateEvent,
41077 &_swigt__p_wxWindowDestroyEvent,
41078 &_swigt__p_wxWindowDisabler,
41079 &_swigt__p_wxXPMHandler,
41080 };
41081
41082 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
41083 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
41084 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
41085 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
41086 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
41087 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
41088 static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
41089 static swig_cast_info _swigc__p_wxAboutDialogInfo[] = { {&_swigt__p_wxAboutDialogInfo, 0, 0, 0},{0, 0, 0, 0}};
41090 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
41091 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
41092 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}};
41093 static swig_cast_info _swigc__p_wxBusyCursor[] = { {&_swigt__p_wxBusyCursor, 0, 0, 0},{0, 0, 0, 0}};
41094 static swig_cast_info _swigc__p_wxBusyInfo[] = { {&_swigt__p_wxBusyInfo, 0, 0, 0},{0, 0, 0, 0}};
41095 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
41096 static swig_cast_info _swigc__p_wxChar[] = { {&_swigt__p_wxChar, 0, 0, 0},{0, 0, 0, 0}};
41097 static swig_cast_info _swigc__p_wxClipboard[] = { {&_swigt__p_wxClipboard, 0, 0, 0},{0, 0, 0, 0}};
41098 static swig_cast_info _swigc__p_wxClipboardLocker[] = { {&_swigt__p_wxClipboardLocker, 0, 0, 0},{0, 0, 0, 0}};
41099 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
41100 static swig_cast_info _swigc__p_wxConfig[] = { {&_swigt__p_wxConfig, 0, 0, 0},{0, 0, 0, 0}};
41101 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}};
41102 static swig_cast_info _swigc__p_wxConfigPathChanger[] = { {&_swigt__p_wxConfigPathChanger, 0, 0, 0},{0, 0, 0, 0}};
41103 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
41104 static swig_cast_info _swigc__p_wxCustomDataObject[] = { {&_swigt__p_wxCustomDataObject, 0, 0, 0},{0, 0, 0, 0}};
41105 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
41106 static swig_cast_info _swigc__p_wxDataFormat[] = { {&_swigt__p_wxDataFormat, 0, 0, 0},{0, 0, 0, 0}};
41107 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}};
41108 static swig_cast_info _swigc__p_wxDataObjectComposite[] = { {&_swigt__p_wxDataObjectComposite, 0, 0, 0},{0, 0, 0, 0}};
41109 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}};
41110 static swig_cast_info _swigc__p_wxDateSpan[] = { {&_swigt__p_wxDateSpan, 0, 0, 0},{0, 0, 0, 0}};
41111 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
41112 static swig_cast_info _swigc__p_wxDateTime__TimeZone[] = { {&_swigt__p_wxDateTime__TimeZone, 0, 0, 0},{0, 0, 0, 0}};
41113 static swig_cast_info _swigc__p_wxDisplay[] = { {&_swigt__p_wxDisplay, 0, 0, 0},{0, 0, 0, 0}};
41114 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
41115 static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
41116 static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
41117 static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
41118 static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
41119 static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
41120 static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
41121 static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
41122 static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
41123 static swig_cast_info _swigc__p_wxNotifyEvent[] = {{&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
41124 static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
41125 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = {{&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
41126 static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
41127 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
41128 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
41129 static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
41130 static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
41131 static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
41132 static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
41133 static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
41134 static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
41135 static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
41136 static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
41137 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = {{&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
41138 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
41139 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
41140 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
41141 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
41142 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
41143 static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
41144 static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
41145 static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
41146 static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
41147 static swig_cast_info _swigc__p_wxCommandEvent[] = {{&_swigt__p_wxCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
41148 static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
41149 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
41150 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
41151 static swig_cast_info _swigc__p_wxKeyEvent[] = {{&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
41152 static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
41153 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}};
41154 static swig_cast_info _swigc__p_wxControl[] = {{&_swigt__p_wxControl, 0, 0, 0},{0, 0, 0, 0}};
41155 static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
41156 static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
41157 static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
41158 static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};
41159 static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
41160 static swig_cast_info _swigc__p_wxEventBlocker[] = {{&_swigt__p_wxEventBlocker, 0, 0, 0},{0, 0, 0, 0}};
41161 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_wxEventBlocker, _p_wxEventBlockerTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyProcess, _p_wxPyProcessTo_p_wxEvtHandler, 0, 0},{0, 0, 0, 0}};
41162 static swig_cast_info _swigc__p_wxFileConfig[] = { {&_swigt__p_wxFileConfig, 0, 0, 0},{0, 0, 0, 0}};
41163 static swig_cast_info _swigc__p_wxFileDataObject[] = { {&_swigt__p_wxFileDataObject, 0, 0, 0},{0, 0, 0, 0}};
41164 static swig_cast_info _swigc__p_wxFileHistory[] = { {&_swigt__p_wxFileHistory, 0, 0, 0},{0, 0, 0, 0}};
41165 static swig_cast_info _swigc__p_wxFileType[] = { {&_swigt__p_wxFileType, 0, 0, 0},{0, 0, 0, 0}};
41166 static swig_cast_info _swigc__p_wxFileTypeInfo[] = { {&_swigt__p_wxFileTypeInfo, 0, 0, 0},{0, 0, 0, 0}};
41167 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
41168 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
41169 static swig_cast_info _swigc__p_wxIcon[] = { {&_swigt__p_wxIcon, 0, 0, 0},{0, 0, 0, 0}};
41170 static swig_cast_info _swigc__p_wxJoystick[] = { {&_swigt__p_wxJoystick, 0, 0, 0},{0, 0, 0, 0}};
41171 static swig_cast_info _swigc__p_wxJoystickEvent[] = { {&_swigt__p_wxJoystickEvent, 0, 0, 0},{0, 0, 0, 0}};
41172 static swig_cast_info _swigc__p_wxKillError[] = { {&_swigt__p_wxKillError, 0, 0, 0},{0, 0, 0, 0}};
41173 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}};
41174 static swig_cast_info _swigc__p_wxLogBuffer[] = { {&_swigt__p_wxLogBuffer, 0, 0, 0},{0, 0, 0, 0}};
41175 static swig_cast_info _swigc__p_wxLogChain[] = { {&_swigt__p_wxLogChain, 0, 0, 0},{0, 0, 0, 0}};
41176 static swig_cast_info _swigc__p_wxLogGui[] = { {&_swigt__p_wxLogGui, 0, 0, 0},{0, 0, 0, 0}};
41177 static swig_cast_info _swigc__p_wxLogNull[] = { {&_swigt__p_wxLogNull, 0, 0, 0},{0, 0, 0, 0}};
41178 static swig_cast_info _swigc__p_wxLogStderr[] = { {&_swigt__p_wxLogStderr, 0, 0, 0},{0, 0, 0, 0}};
41179 static swig_cast_info _swigc__p_wxLogTextCtrl[] = { {&_swigt__p_wxLogTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
41180 static swig_cast_info _swigc__p_wxLogWindow[] = { {&_swigt__p_wxLogWindow, 0, 0, 0},{0, 0, 0, 0}};
41181 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
41182 static swig_cast_info _swigc__p_wxMetafileDataObject[] = { {&_swigt__p_wxMetafileDataObject, 0, 0, 0},{0, 0, 0, 0}};
41183 static swig_cast_info _swigc__p_wxMimeTypesManager[] = { {&_swigt__p_wxMimeTypesManager, 0, 0, 0},{0, 0, 0, 0}};
41184 static swig_cast_info _swigc__p_wxMouseState[] = { {&_swigt__p_wxMouseState, 0, 0, 0},{0, 0, 0, 0}};
41185 static swig_cast_info _swigc__p_wxMutexGuiLocker[] = { {&_swigt__p_wxMutexGuiLocker, 0, 0, 0},{0, 0, 0, 0}};
41186 static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
41187 static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
41188 static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
41189 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
41190 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
41191 static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
41192 static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
41193 static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
41194 static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
41195 static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
41196 static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
41197 static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
41198 static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
41199 static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
41200 static swig_cast_info _swigc__p_wxTGAHandler[] = {{&_swigt__p_wxTGAHandler, 0, 0, 0},{0, 0, 0, 0}};
41201 static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
41202 static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
41203 static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
41204 static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
41205 static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
41206 static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
41207 static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
41208 static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
41209 static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
41210 static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
41211 static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
41212 static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
41213 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
41214 static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
41215 static swig_cast_info _swigc__p_wxImage[] = {{&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
41216 static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
41217 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxEventBlocker, _p_wxEventBlockerTo_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_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_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_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_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_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTGAHandler, _p_wxTGAHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_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}};
41218 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
41219 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
41220 static swig_cast_info _swigc__p_wxPlatformInfo[] = { {&_swigt__p_wxPlatformInfo, 0, 0, 0},{0, 0, 0, 0}};
41221 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
41222 static swig_cast_info _swigc__p_wxPowerEvent[] = { {&_swigt__p_wxPowerEvent, 0, 0, 0},{0, 0, 0, 0}};
41223 static swig_cast_info _swigc__p_wxProcessEvent[] = { {&_swigt__p_wxProcessEvent, 0, 0, 0},{0, 0, 0, 0}};
41224 static swig_cast_info _swigc__p_wxPyArtProvider[] = { {&_swigt__p_wxPyArtProvider, 0, 0, 0},{0, 0, 0, 0}};
41225 static swig_cast_info _swigc__p_wxPyBitmapDataObject[] = { {&_swigt__p_wxPyBitmapDataObject, 0, 0, 0},{0, 0, 0, 0}};
41226 static swig_cast_info _swigc__p_wxPyDataObjectSimple[] = { {&_swigt__p_wxPyDataObjectSimple, 0, 0, 0},{0, 0, 0, 0}};
41227 static swig_cast_info _swigc__p_wxPyDropSource[] = { {&_swigt__p_wxPyDropSource, 0, 0, 0},{0, 0, 0, 0}};
41228 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}};
41229 static swig_cast_info _swigc__p_wxPyFileDropTarget[] = { {&_swigt__p_wxPyFileDropTarget, 0, 0, 0},{0, 0, 0, 0}};
41230 static swig_cast_info _swigc__p_wxPyLog[] = { {&_swigt__p_wxPyLog, 0, 0, 0},{0, 0, 0, 0}};
41231 static swig_cast_info _swigc__p_wxPyProcess[] = { {&_swigt__p_wxPyProcess, 0, 0, 0},{0, 0, 0, 0}};
41232 static swig_cast_info _swigc__p_wxPyTextDataObject[] = { {&_swigt__p_wxPyTextDataObject, 0, 0, 0},{0, 0, 0, 0}};
41233 static swig_cast_info _swigc__p_wxPyTextDropTarget[] = { {&_swigt__p_wxPyTextDropTarget, 0, 0, 0},{0, 0, 0, 0}};
41234 static swig_cast_info _swigc__p_wxPyTimer[] = { {&_swigt__p_wxPyTimer, 0, 0, 0},{0, 0, 0, 0}};
41235 static swig_cast_info _swigc__p_wxPyTipProvider[] = { {&_swigt__p_wxPyTipProvider, 0, 0, 0},{0, 0, 0, 0}};
41236 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
41237 static swig_cast_info _swigc__p_wxSingleInstanceChecker[] = { {&_swigt__p_wxSingleInstanceChecker, 0, 0, 0},{0, 0, 0, 0}};
41238 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
41239 static swig_cast_info _swigc__p_wxSound[] = { {&_swigt__p_wxSound, 0, 0, 0},{0, 0, 0, 0}};
41240 static swig_cast_info _swigc__p_wxStandardPaths[] = { {&_swigt__p_wxStandardPaths, 0, 0, 0},{0, 0, 0, 0}};
41241 static swig_cast_info _swigc__p_wxStopWatch[] = { {&_swigt__p_wxStopWatch, 0, 0, 0},{0, 0, 0, 0}};
41242 static swig_cast_info _swigc__p_wxString[] = { {&_swigt__p_wxString, 0, 0, 0},{0, 0, 0, 0}};
41243 static swig_cast_info _swigc__p_wxSystemOptions[] = { {&_swigt__p_wxSystemOptions, 0, 0, 0},{0, 0, 0, 0}};
41244 static swig_cast_info _swigc__p_wxSystemSettings[] = { {&_swigt__p_wxSystemSettings, 0, 0, 0},{0, 0, 0, 0}};
41245 static swig_cast_info _swigc__p_wxTextCtrl[] = { {&_swigt__p_wxTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
41246 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}};
41247 static swig_cast_info _swigc__p_wxTimeSpan[] = { {&_swigt__p_wxTimeSpan, 0, 0, 0},{0, 0, 0, 0}};
41248 static swig_cast_info _swigc__p_wxTimer[] = { {&_swigt__p_wxTimer, 0, 0, 0},{0, 0, 0, 0}};
41249 static swig_cast_info _swigc__p_wxTimerEvent[] = { {&_swigt__p_wxTimerEvent, 0, 0, 0},{0, 0, 0, 0}};
41250 static swig_cast_info _swigc__p_wxTimerRunner[] = { {&_swigt__p_wxTimerRunner, 0, 0, 0},{0, 0, 0, 0}};
41251 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}};
41252 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
41253 static swig_cast_info _swigc__p_wxURLDataObject[] = { {&_swigt__p_wxURLDataObject, 0, 0, 0},{0, 0, 0, 0}};
41254 static swig_cast_info _swigc__p_wxVideoMode[] = { {&_swigt__p_wxVideoMode, 0, 0, 0},{0, 0, 0, 0}};
41255 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}};
41256 static swig_cast_info _swigc__p_wxWindowDisabler[] = { {&_swigt__p_wxWindowDisabler, 0, 0, 0},{0, 0, 0, 0}};
41257
41258 static swig_cast_info *swig_cast_initial[] = {
41259 _swigc__p_char,
41260 _swigc__p_form_ops_t,
41261 _swigc__p_int,
41262 _swigc__p_unsigned_char,
41263 _swigc__p_unsigned_int,
41264 _swigc__p_unsigned_long,
41265 _swigc__p_void,
41266 _swigc__p_wxANIHandler,
41267 _swigc__p_wxAboutDialogInfo,
41268 _swigc__p_wxAcceleratorTable,
41269 _swigc__p_wxActivateEvent,
41270 _swigc__p_wxArrayString,
41271 _swigc__p_wxBMPHandler,
41272 _swigc__p_wxBitmap,
41273 _swigc__p_wxBitmapDataObject,
41274 _swigc__p_wxBoxSizer,
41275 _swigc__p_wxBusyCursor,
41276 _swigc__p_wxBusyInfo,
41277 _swigc__p_wxCURHandler,
41278 _swigc__p_wxCaret,
41279 _swigc__p_wxChar,
41280 _swigc__p_wxChildFocusEvent,
41281 _swigc__p_wxClipboard,
41282 _swigc__p_wxClipboardLocker,
41283 _swigc__p_wxClipboardTextEvent,
41284 _swigc__p_wxCloseEvent,
41285 _swigc__p_wxColour,
41286 _swigc__p_wxCommandEvent,
41287 _swigc__p_wxConfig,
41288 _swigc__p_wxConfigBase,
41289 _swigc__p_wxConfigPathChanger,
41290 _swigc__p_wxContextMenuEvent,
41291 _swigc__p_wxControl,
41292 _swigc__p_wxControlWithItems,
41293 _swigc__p_wxCursor,
41294 _swigc__p_wxCustomDataObject,
41295 _swigc__p_wxDC,
41296 _swigc__p_wxDataFormat,
41297 _swigc__p_wxDataObject,
41298 _swigc__p_wxDataObjectComposite,
41299 _swigc__p_wxDataObjectSimple,
41300 _swigc__p_wxDateEvent,
41301 _swigc__p_wxDateSpan,
41302 _swigc__p_wxDateTime,
41303 _swigc__p_wxDateTime__TimeZone,
41304 _swigc__p_wxDisplay,
41305 _swigc__p_wxDisplayChangedEvent,
41306 _swigc__p_wxDropFilesEvent,
41307 _swigc__p_wxDuplexMode,
41308 _swigc__p_wxEraseEvent,
41309 _swigc__p_wxEvent,
41310 _swigc__p_wxEventBlocker,
41311 _swigc__p_wxEvtHandler,
41312 _swigc__p_wxFSFile,
41313 _swigc__p_wxFileConfig,
41314 _swigc__p_wxFileDataObject,
41315 _swigc__p_wxFileHistory,
41316 _swigc__p_wxFileSystem,
41317 _swigc__p_wxFileType,
41318 _swigc__p_wxFileTypeInfo,
41319 _swigc__p_wxFlexGridSizer,
41320 _swigc__p_wxFocusEvent,
41321 _swigc__p_wxFont,
41322 _swigc__p_wxFrame,
41323 _swigc__p_wxGBSizerItem,
41324 _swigc__p_wxGIFHandler,
41325 _swigc__p_wxGridBagSizer,
41326 _swigc__p_wxGridSizer,
41327 _swigc__p_wxICOHandler,
41328 _swigc__p_wxIcon,
41329 _swigc__p_wxIconizeEvent,
41330 _swigc__p_wxIdleEvent,
41331 _swigc__p_wxImage,
41332 _swigc__p_wxImageHandler,
41333 _swigc__p_wxIndividualLayoutConstraint,
41334 _swigc__p_wxInitDialogEvent,
41335 _swigc__p_wxJPEGHandler,
41336 _swigc__p_wxJoystick,
41337 _swigc__p_wxJoystickEvent,
41338 _swigc__p_wxKeyEvent,
41339 _swigc__p_wxKillError,
41340 _swigc__p_wxLayoutConstraints,
41341 _swigc__p_wxLog,
41342 _swigc__p_wxLogBuffer,
41343 _swigc__p_wxLogChain,
41344 _swigc__p_wxLogGui,
41345 _swigc__p_wxLogNull,
41346 _swigc__p_wxLogStderr,
41347 _swigc__p_wxLogTextCtrl,
41348 _swigc__p_wxLogWindow,
41349 _swigc__p_wxMaximizeEvent,
41350 _swigc__p_wxMenu,
41351 _swigc__p_wxMenuBar,
41352 _swigc__p_wxMenuEvent,
41353 _swigc__p_wxMenuItem,
41354 _swigc__p_wxMetafileDataObject,
41355 _swigc__p_wxMimeTypesManager,
41356 _swigc__p_wxMouseCaptureChangedEvent,
41357 _swigc__p_wxMouseCaptureLostEvent,
41358 _swigc__p_wxMouseEvent,
41359 _swigc__p_wxMouseState,
41360 _swigc__p_wxMoveEvent,
41361 _swigc__p_wxMutexGuiLocker,
41362 _swigc__p_wxNavigationKeyEvent,
41363 _swigc__p_wxNcPaintEvent,
41364 _swigc__p_wxNotifyEvent,
41365 _swigc__p_wxObject,
41366 _swigc__p_wxOutputStream,
41367 _swigc__p_wxPCXHandler,
41368 _swigc__p_wxPNGHandler,
41369 _swigc__p_wxPNMHandler,
41370 _swigc__p_wxPaintEvent,
41371 _swigc__p_wxPaletteChangedEvent,
41372 _swigc__p_wxPaperSize,
41373 _swigc__p_wxPlatformInfo,
41374 _swigc__p_wxPoint,
41375 _swigc__p_wxPowerEvent,
41376 _swigc__p_wxProcessEvent,
41377 _swigc__p_wxPyApp,
41378 _swigc__p_wxPyArtProvider,
41379 _swigc__p_wxPyBitmapDataObject,
41380 _swigc__p_wxPyCommandEvent,
41381 _swigc__p_wxPyDataObjectSimple,
41382 _swigc__p_wxPyDropSource,
41383 _swigc__p_wxPyDropTarget,
41384 _swigc__p_wxPyEvent,
41385 _swigc__p_wxPyFileDropTarget,
41386 _swigc__p_wxPyImageHandler,
41387 _swigc__p_wxPyLog,
41388 _swigc__p_wxPyProcess,
41389 _swigc__p_wxPySizer,
41390 _swigc__p_wxPyTextDataObject,
41391 _swigc__p_wxPyTextDropTarget,
41392 _swigc__p_wxPyTimer,
41393 _swigc__p_wxPyTipProvider,
41394 _swigc__p_wxPyValidator,
41395 _swigc__p_wxQueryNewPaletteEvent,
41396 _swigc__p_wxRect,
41397 _swigc__p_wxScrollEvent,
41398 _swigc__p_wxScrollWinEvent,
41399 _swigc__p_wxSetCursorEvent,
41400 _swigc__p_wxShowEvent,
41401 _swigc__p_wxSingleInstanceChecker,
41402 _swigc__p_wxSize,
41403 _swigc__p_wxSizeEvent,
41404 _swigc__p_wxSizer,
41405 _swigc__p_wxSizerItem,
41406 _swigc__p_wxSound,
41407 _swigc__p_wxStandardPaths,
41408 _swigc__p_wxStaticBoxSizer,
41409 _swigc__p_wxStdDialogButtonSizer,
41410 _swigc__p_wxStopWatch,
41411 _swigc__p_wxString,
41412 _swigc__p_wxSysColourChangedEvent,
41413 _swigc__p_wxSystemOptions,
41414 _swigc__p_wxSystemSettings,
41415 _swigc__p_wxTGAHandler,
41416 _swigc__p_wxTIFFHandler,
41417 _swigc__p_wxTextCtrl,
41418 _swigc__p_wxTextDataObject,
41419 _swigc__p_wxTimeSpan,
41420 _swigc__p_wxTimer,
41421 _swigc__p_wxTimerEvent,
41422 _swigc__p_wxTimerRunner,
41423 _swigc__p_wxTipProvider,
41424 _swigc__p_wxToolTip,
41425 _swigc__p_wxURLDataObject,
41426 _swigc__p_wxUpdateUIEvent,
41427 _swigc__p_wxValidator,
41428 _swigc__p_wxVideoMode,
41429 _swigc__p_wxWindow,
41430 _swigc__p_wxWindowCreateEvent,
41431 _swigc__p_wxWindowDestroyEvent,
41432 _swigc__p_wxWindowDisabler,
41433 _swigc__p_wxXPMHandler,
41434 };
41435
41436
41437 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
41438
41439 static swig_const_info swig_const_table[] = {
41440 {0, 0, 0, 0.0, 0, 0}};
41441
41442 #ifdef __cplusplus
41443 }
41444 #endif
41445 /* -----------------------------------------------------------------------------
41446 * Type initialization:
41447 * This problem is tough by the requirement that no dynamic
41448 * memory is used. Also, since swig_type_info structures store pointers to
41449 * swig_cast_info structures and swig_cast_info structures store pointers back
41450 * to swig_type_info structures, we need some lookup code at initialization.
41451 * The idea is that swig generates all the structures that are needed.
41452 * The runtime then collects these partially filled structures.
41453 * The SWIG_InitializeModule function takes these initial arrays out of
41454 * swig_module, and does all the lookup, filling in the swig_module.types
41455 * array with the correct data and linking the correct swig_cast_info
41456 * structures together.
41457 *
41458 * The generated swig_type_info structures are assigned staticly to an initial
41459 * array. We just loop though that array, and handle each type individually.
41460 * First we lookup if this type has been already loaded, and if so, use the
41461 * loaded structure instead of the generated one. Then we have to fill in the
41462 * cast linked list. The cast data is initially stored in something like a
41463 * two-dimensional array. Each row corresponds to a type (there are the same
41464 * number of rows as there are in the swig_type_initial array). Each entry in
41465 * a column is one of the swig_cast_info structures for that type.
41466 * The cast_initial array is actually an array of arrays, because each row has
41467 * a variable number of columns. So to actually build the cast linked list,
41468 * we find the array of casts associated with the type, and loop through it
41469 * adding the casts to the list. The one last trick we need to do is making
41470 * sure the type pointer in the swig_cast_info struct is correct.
41471 *
41472 * First off, we lookup the cast->type name to see if it is already loaded.
41473 * There are three cases to handle:
41474 * 1) If the cast->type has already been loaded AND the type we are adding
41475 * casting info to has not been loaded (it is in this module), THEN we
41476 * replace the cast->type pointer with the type pointer that has already
41477 * been loaded.
41478 * 2) If BOTH types (the one we are adding casting info to, and the
41479 * cast->type) are loaded, THEN the cast info has already been loaded by
41480 * the previous module so we just ignore it.
41481 * 3) Finally, if cast->type has not already been loaded, then we add that
41482 * swig_cast_info to the linked list (because the cast->type) pointer will
41483 * be correct.
41484 * ----------------------------------------------------------------------------- */
41485
41486 #ifdef __cplusplus
41487 extern "C" {
41488 #if 0
41489 } /* c-mode */
41490 #endif
41491 #endif
41492
41493 #if 0
41494 #define SWIGRUNTIME_DEBUG
41495 #endif
41496
41497 SWIGRUNTIME void
41498 SWIG_InitializeModule(void *clientdata) {
41499 size_t i;
41500 swig_module_info *module_head;
41501 static int init_run = 0;
41502
41503 clientdata = clientdata;
41504
41505 if (init_run) return;
41506 init_run = 1;
41507
41508 /* Initialize the swig_module */
41509 swig_module.type_initial = swig_type_initial;
41510 swig_module.cast_initial = swig_cast_initial;
41511
41512 /* Try and load any already created modules */
41513 module_head = SWIG_GetModule(clientdata);
41514 if (module_head) {
41515 swig_module.next = module_head->next;
41516 module_head->next = &swig_module;
41517 } else {
41518 /* This is the first module loaded */
41519 swig_module.next = &swig_module;
41520 SWIG_SetModule(clientdata, &swig_module);
41521 }
41522
41523 /* Now work on filling in swig_module.types */
41524 #ifdef SWIGRUNTIME_DEBUG
41525 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
41526 #endif
41527 for (i = 0; i < swig_module.size; ++i) {
41528 swig_type_info *type = 0;
41529 swig_type_info *ret;
41530 swig_cast_info *cast;
41531
41532 #ifdef SWIGRUNTIME_DEBUG
41533 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
41534 #endif
41535
41536 /* if there is another module already loaded */
41537 if (swig_module.next != &swig_module) {
41538 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
41539 }
41540 if (type) {
41541 /* Overwrite clientdata field */
41542 #ifdef SWIGRUNTIME_DEBUG
41543 printf("SWIG_InitializeModule: found type %s\n", type->name);
41544 #endif
41545 if (swig_module.type_initial[i]->clientdata) {
41546 type->clientdata = swig_module.type_initial[i]->clientdata;
41547 #ifdef SWIGRUNTIME_DEBUG
41548 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
41549 #endif
41550 }
41551 } else {
41552 type = swig_module.type_initial[i];
41553 }
41554
41555 /* Insert casting types */
41556 cast = swig_module.cast_initial[i];
41557 while (cast->type) {
41558 /* Don't need to add information already in the list */
41559 ret = 0;
41560 #ifdef SWIGRUNTIME_DEBUG
41561 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
41562 #endif
41563 if (swig_module.next != &swig_module) {
41564 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
41565 #ifdef SWIGRUNTIME_DEBUG
41566 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
41567 #endif
41568 }
41569 if (ret) {
41570 if (type == swig_module.type_initial[i]) {
41571 #ifdef SWIGRUNTIME_DEBUG
41572 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
41573 #endif
41574 cast->type = ret;
41575 ret = 0;
41576 } else {
41577 /* Check for casting already in the list */
41578 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
41579 #ifdef SWIGRUNTIME_DEBUG
41580 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
41581 #endif
41582 if (!ocast) ret = 0;
41583 }
41584 }
41585
41586 if (!ret) {
41587 #ifdef SWIGRUNTIME_DEBUG
41588 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
41589 #endif
41590 if (type->cast) {
41591 type->cast->prev = cast;
41592 cast->next = type->cast;
41593 }
41594 type->cast = cast;
41595 }
41596 cast++;
41597 }
41598 /* Set entry in modules->types array equal to the type */
41599 swig_module.types[i] = type;
41600 }
41601 swig_module.types[i] = 0;
41602
41603 #ifdef SWIGRUNTIME_DEBUG
41604 printf("**** SWIG_InitializeModule: Cast List ******\n");
41605 for (i = 0; i < swig_module.size; ++i) {
41606 int j = 0;
41607 swig_cast_info *cast = swig_module.cast_initial[i];
41608 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
41609 while (cast->type) {
41610 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
41611 cast++;
41612 ++j;
41613 }
41614 printf("---- Total casts: %d\n",j);
41615 }
41616 printf("**** SWIG_InitializeModule: Cast List ******\n");
41617 #endif
41618 }
41619
41620 /* This function will propagate the clientdata field of type to
41621 * any new swig_type_info structures that have been added into the list
41622 * of equivalent types. It is like calling
41623 * SWIG_TypeClientData(type, clientdata) a second time.
41624 */
41625 SWIGRUNTIME void
41626 SWIG_PropagateClientData(void) {
41627 size_t i;
41628 swig_cast_info *equiv;
41629 static int init_run = 0;
41630
41631 if (init_run) return;
41632 init_run = 1;
41633
41634 for (i = 0; i < swig_module.size; i++) {
41635 if (swig_module.types[i]->clientdata) {
41636 equiv = swig_module.types[i]->cast;
41637 while (equiv) {
41638 if (!equiv->converter) {
41639 if (equiv->type && !equiv->type->clientdata)
41640 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
41641 }
41642 equiv = equiv->next;
41643 }
41644 }
41645 }
41646 }
41647
41648 #ifdef __cplusplus
41649 #if 0
41650 {
41651 /* c-mode */
41652 #endif
41653 }
41654 #endif
41655
41656
41657
41658 #ifdef __cplusplus
41659 extern "C" {
41660 #endif
41661
41662 /* Python-specific SWIG API */
41663 #define SWIG_newvarlink() SWIG_Python_newvarlink()
41664 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
41665 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
41666
41667 /* -----------------------------------------------------------------------------
41668 * global variable support code.
41669 * ----------------------------------------------------------------------------- */
41670
41671 typedef struct swig_globalvar {
41672 char *name; /* Name of global variable */
41673 PyObject *(*get_attr)(void); /* Return the current value */
41674 int (*set_attr)(PyObject *); /* Set the value */
41675 struct swig_globalvar *next;
41676 } swig_globalvar;
41677
41678 typedef struct swig_varlinkobject {
41679 PyObject_HEAD
41680 swig_globalvar *vars;
41681 } swig_varlinkobject;
41682
41683 SWIGINTERN PyObject *
41684 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
41685 return PyString_FromString("<Swig global variables>");
41686 }
41687
41688 SWIGINTERN PyObject *
41689 swig_varlink_str(swig_varlinkobject *v) {
41690 PyObject *str = PyString_FromString("(");
41691 swig_globalvar *var;
41692 for (var = v->vars; var; var=var->next) {
41693 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
41694 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
41695 }
41696 PyString_ConcatAndDel(&str,PyString_FromString(")"));
41697 return str;
41698 }
41699
41700 SWIGINTERN int
41701 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
41702 PyObject *str = swig_varlink_str(v);
41703 fprintf(fp,"Swig global variables ");
41704 fprintf(fp,"%s\n", PyString_AsString(str));
41705 Py_DECREF(str);
41706 return 0;
41707 }
41708
41709 SWIGINTERN void
41710 swig_varlink_dealloc(swig_varlinkobject *v) {
41711 swig_globalvar *var = v->vars;
41712 while (var) {
41713 swig_globalvar *n = var->next;
41714 free(var->name);
41715 free(var);
41716 var = n;
41717 }
41718 }
41719
41720 SWIGINTERN PyObject *
41721 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
41722 PyObject *res = NULL;
41723 swig_globalvar *var = v->vars;
41724 while (var) {
41725 if (strcmp(var->name,n) == 0) {
41726 res = (*var->get_attr)();
41727 break;
41728 }
41729 var = var->next;
41730 }
41731 if (res == NULL && !PyErr_Occurred()) {
41732 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
41733 }
41734 return res;
41735 }
41736
41737 SWIGINTERN int
41738 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
41739 int res = 1;
41740 swig_globalvar *var = v->vars;
41741 while (var) {
41742 if (strcmp(var->name,n) == 0) {
41743 res = (*var->set_attr)(p);
41744 break;
41745 }
41746 var = var->next;
41747 }
41748 if (res == 1 && !PyErr_Occurred()) {
41749 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
41750 }
41751 return res;
41752 }
41753
41754 SWIGINTERN PyTypeObject*
41755 swig_varlink_type(void) {
41756 static char varlink__doc__[] = "Swig var link object";
41757 static PyTypeObject varlink_type;
41758 static int type_init = 0;
41759 if (!type_init) {
41760 const PyTypeObject tmp
41761 = {
41762 PyObject_HEAD_INIT(NULL)
41763 0, /* Number of items in variable part (ob_size) */
41764 (char *)"swigvarlink", /* Type name (tp_name) */
41765 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
41766 0, /* Itemsize (tp_itemsize) */
41767 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
41768 (printfunc) swig_varlink_print, /* Print (tp_print) */
41769 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
41770 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
41771 0, /* tp_compare */
41772 (reprfunc) swig_varlink_repr, /* tp_repr */
41773 0, /* tp_as_number */
41774 0, /* tp_as_sequence */
41775 0, /* tp_as_mapping */
41776 0, /* tp_hash */
41777 0, /* tp_call */
41778 (reprfunc)swig_varlink_str, /* tp_str */
41779 0, /* tp_getattro */
41780 0, /* tp_setattro */
41781 0, /* tp_as_buffer */
41782 0, /* tp_flags */
41783 varlink__doc__, /* tp_doc */
41784 0, /* tp_traverse */
41785 0, /* tp_clear */
41786 0, /* tp_richcompare */
41787 0, /* tp_weaklistoffset */
41788 #if PY_VERSION_HEX >= 0x02020000
41789 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
41790 #endif
41791 #if PY_VERSION_HEX >= 0x02030000
41792 0, /* tp_del */
41793 #endif
41794 #ifdef COUNT_ALLOCS
41795 0,0,0,0 /* tp_alloc -> tp_next */
41796 #endif
41797 };
41798 varlink_type = tmp;
41799 varlink_type.ob_type = &PyType_Type;
41800 type_init = 1;
41801 }
41802 return &varlink_type;
41803 }
41804
41805 /* Create a variable linking object for use later */
41806 SWIGINTERN PyObject *
41807 SWIG_Python_newvarlink(void) {
41808 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
41809 if (result) {
41810 result->vars = 0;
41811 }
41812 return ((PyObject*) result);
41813 }
41814
41815 SWIGINTERN void
41816 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
41817 swig_varlinkobject *v = (swig_varlinkobject *) p;
41818 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
41819 if (gv) {
41820 size_t size = strlen(name)+1;
41821 gv->name = (char *)malloc(size);
41822 if (gv->name) {
41823 strncpy(gv->name,name,size);
41824 gv->get_attr = get_attr;
41825 gv->set_attr = set_attr;
41826 gv->next = v->vars;
41827 }
41828 }
41829 v->vars = gv;
41830 }
41831
41832 SWIGINTERN PyObject *
41833 SWIG_globals() {
41834 static PyObject *_SWIG_globals = 0;
41835 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
41836 return _SWIG_globals;
41837 }
41838
41839 /* -----------------------------------------------------------------------------
41840 * constants/methods manipulation
41841 * ----------------------------------------------------------------------------- */
41842
41843 /* Install Constants */
41844 SWIGINTERN void
41845 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
41846 PyObject *obj = 0;
41847 size_t i;
41848 for (i = 0; constants[i].type; ++i) {
41849 switch(constants[i].type) {
41850 case SWIG_PY_POINTER:
41851 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
41852 break;
41853 case SWIG_PY_BINARY:
41854 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
41855 break;
41856 default:
41857 obj = 0;
41858 break;
41859 }
41860 if (obj) {
41861 PyDict_SetItemString(d, constants[i].name, obj);
41862 Py_DECREF(obj);
41863 }
41864 }
41865 }
41866
41867 /* -----------------------------------------------------------------------------*/
41868 /* Fix SwigMethods to carry the callback ptrs when needed */
41869 /* -----------------------------------------------------------------------------*/
41870
41871 SWIGINTERN void
41872 SWIG_Python_FixMethods(PyMethodDef *methods,
41873 swig_const_info *const_table,
41874 swig_type_info **types,
41875 swig_type_info **types_initial) {
41876 size_t i;
41877 for (i = 0; methods[i].ml_name; ++i) {
41878 const char *c = methods[i].ml_doc;
41879 if (c && (c = strstr(c, "swig_ptr: "))) {
41880 int j;
41881 swig_const_info *ci = 0;
41882 const char *name = c + 10;
41883 for (j = 0; const_table[j].type; ++j) {
41884 if (strncmp(const_table[j].name, name,
41885 strlen(const_table[j].name)) == 0) {
41886 ci = &(const_table[j]);
41887 break;
41888 }
41889 }
41890 if (ci) {
41891 size_t shift = (ci->ptype) - types;
41892 swig_type_info *ty = types_initial[shift];
41893 size_t ldoc = (c - methods[i].ml_doc);
41894 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
41895 char *ndoc = (char*)malloc(ldoc + lptr + 10);
41896 if (ndoc) {
41897 char *buff = ndoc;
41898 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
41899 if (ptr) {
41900 strncpy(buff, methods[i].ml_doc, ldoc);
41901 buff += ldoc;
41902 strncpy(buff, "swig_ptr: ", 10);
41903 buff += 10;
41904 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
41905 methods[i].ml_doc = ndoc;
41906 }
41907 }
41908 }
41909 }
41910 }
41911 }
41912
41913 #ifdef __cplusplus
41914 }
41915 #endif
41916
41917 /* -----------------------------------------------------------------------------*
41918 * Partial Init method
41919 * -----------------------------------------------------------------------------*/
41920
41921 #ifdef __cplusplus
41922 extern "C"
41923 #endif
41924 SWIGEXPORT void SWIG_init(void) {
41925 PyObject *m, *d;
41926
41927 /* Fix SwigMethods to carry the callback ptrs when needed */
41928 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
41929
41930 m = Py_InitModule((char *) SWIG_name, SwigMethods);
41931 d = PyModule_GetDict(m);
41932
41933 SWIG_InitializeModule(0);
41934 SWIG_InstallConstants(d,swig_const_table);
41935
41936
41937 SWIG_Python_SetConstant(d, "SYS_OEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_OEM_FIXED_FONT)));
41938 SWIG_Python_SetConstant(d, "SYS_ANSI_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_FIXED_FONT)));
41939 SWIG_Python_SetConstant(d, "SYS_ANSI_VAR_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_VAR_FONT)));
41940 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FONT)));
41941 SWIG_Python_SetConstant(d, "SYS_DEVICE_DEFAULT_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEVICE_DEFAULT_FONT)));
41942 SWIG_Python_SetConstant(d, "SYS_DEFAULT_PALETTE",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_PALETTE)));
41943 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FIXED_FONT)));
41944 SWIG_Python_SetConstant(d, "SYS_DEFAULT_GUI_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_GUI_FONT)));
41945 SWIG_Python_SetConstant(d, "SYS_ICONTITLE_FONT",SWIG_From_int(static_cast< int >(wxSYS_ICONTITLE_FONT)));
41946 SWIG_Python_SetConstant(d, "SYS_COLOUR_SCROLLBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_SCROLLBAR)));
41947 SWIG_Python_SetConstant(d, "SYS_COLOUR_BACKGROUND",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BACKGROUND)));
41948 SWIG_Python_SetConstant(d, "SYS_COLOUR_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_DESKTOP)));
41949 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVECAPTION)));
41950 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTION)));
41951 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENU",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENU)));
41952 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOW)));
41953 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWFRAME",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWFRAME)));
41954 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUTEXT)));
41955 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWTEXT)));
41956 SWIG_Python_SetConstant(d, "SYS_COLOUR_CAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_CAPTIONTEXT)));
41957 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVEBORDER)));
41958 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVEBORDER)));
41959 SWIG_Python_SetConstant(d, "SYS_COLOUR_APPWORKSPACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_APPWORKSPACE)));
41960 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHT)));
41961 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHTTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHTTEXT)));
41962 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNFACE)));
41963 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DFACE)));
41964 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNSHADOW)));
41965 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DSHADOW)));
41966 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRAYTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRAYTEXT)));
41967 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNTEXT)));
41968 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
41969 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHIGHLIGHT)));
41970 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHILIGHT)));
41971 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHIGHLIGHT)));
41972 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHILIGHT)));
41973 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DDKSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DDKSHADOW)));
41974 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DLIGHT)));
41975 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOTEXT)));
41976 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOBK",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOBK)));
41977 SWIG_Python_SetConstant(d, "SYS_COLOUR_LISTBOX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_LISTBOX)));
41978 SWIG_Python_SetConstant(d, "SYS_COLOUR_HOTLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HOTLIGHT)));
41979 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
41980 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTINACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
41981 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUHILIGHT)));
41982 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUBAR)));
41983 SWIG_Python_SetConstant(d, "SYS_COLOUR_MAX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MAX)));
41984 SWIG_Python_SetConstant(d, "SYS_MOUSE_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_MOUSE_BUTTONS)));
41985 SWIG_Python_SetConstant(d, "SYS_BORDER_X",SWIG_From_int(static_cast< int >(wxSYS_BORDER_X)));
41986 SWIG_Python_SetConstant(d, "SYS_BORDER_Y",SWIG_From_int(static_cast< int >(wxSYS_BORDER_Y)));
41987 SWIG_Python_SetConstant(d, "SYS_CURSOR_X",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_X)));
41988 SWIG_Python_SetConstant(d, "SYS_CURSOR_Y",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_Y)));
41989 SWIG_Python_SetConstant(d, "SYS_DCLICK_X",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_X)));
41990 SWIG_Python_SetConstant(d, "SYS_DCLICK_Y",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_Y)));
41991 SWIG_Python_SetConstant(d, "SYS_DRAG_X",SWIG_From_int(static_cast< int >(wxSYS_DRAG_X)));
41992 SWIG_Python_SetConstant(d, "SYS_DRAG_Y",SWIG_From_int(static_cast< int >(wxSYS_DRAG_Y)));
41993 SWIG_Python_SetConstant(d, "SYS_EDGE_X",SWIG_From_int(static_cast< int >(wxSYS_EDGE_X)));
41994 SWIG_Python_SetConstant(d, "SYS_EDGE_Y",SWIG_From_int(static_cast< int >(wxSYS_EDGE_Y)));
41995 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_X)));
41996 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_Y)));
41997 SWIG_Python_SetConstant(d, "SYS_HTHUMB_X",SWIG_From_int(static_cast< int >(wxSYS_HTHUMB_X)));
41998 SWIG_Python_SetConstant(d, "SYS_ICON_X",SWIG_From_int(static_cast< int >(wxSYS_ICON_X)));
41999 SWIG_Python_SetConstant(d, "SYS_ICON_Y",SWIG_From_int(static_cast< int >(wxSYS_ICON_Y)));
42000 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_X",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_X)));
42001 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_Y",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_Y)));
42002 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_X",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_X)));
42003 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_Y",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_Y)));
42004 SWIG_Python_SetConstant(d, "SYS_SCREEN_X",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_X)));
42005 SWIG_Python_SetConstant(d, "SYS_SCREEN_Y",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_Y)));
42006 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_X",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_X)));
42007 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_Y",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_Y)));
42008 SWIG_Python_SetConstant(d, "SYS_SMALLICON_X",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_X)));
42009 SWIG_Python_SetConstant(d, "SYS_SMALLICON_Y",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_Y)));
42010 SWIG_Python_SetConstant(d, "SYS_HSCROLL_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_Y)));
42011 SWIG_Python_SetConstant(d, "SYS_VSCROLL_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_X)));
42012 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_X)));
42013 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_Y)));
42014 SWIG_Python_SetConstant(d, "SYS_VTHUMB_Y",SWIG_From_int(static_cast< int >(wxSYS_VTHUMB_Y)));
42015 SWIG_Python_SetConstant(d, "SYS_CAPTION_Y",SWIG_From_int(static_cast< int >(wxSYS_CAPTION_Y)));
42016 SWIG_Python_SetConstant(d, "SYS_MENU_Y",SWIG_From_int(static_cast< int >(wxSYS_MENU_Y)));
42017 SWIG_Python_SetConstant(d, "SYS_NETWORK_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_NETWORK_PRESENT)));
42018 SWIG_Python_SetConstant(d, "SYS_PENWINDOWS_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_PENWINDOWS_PRESENT)));
42019 SWIG_Python_SetConstant(d, "SYS_SHOW_SOUNDS",SWIG_From_int(static_cast< int >(wxSYS_SHOW_SOUNDS)));
42020 SWIG_Python_SetConstant(d, "SYS_SWAP_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_SWAP_BUTTONS)));
42021 SWIG_Python_SetConstant(d, "SYS_CAN_DRAW_FRAME_DECORATIONS",SWIG_From_int(static_cast< int >(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
42022 SWIG_Python_SetConstant(d, "SYS_CAN_ICONIZE_FRAME",SWIG_From_int(static_cast< int >(wxSYS_CAN_ICONIZE_FRAME)));
42023 SWIG_Python_SetConstant(d, "SYS_TABLET_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_TABLET_PRESENT)));
42024 SWIG_Python_SetConstant(d, "SYS_SCREEN_NONE",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_NONE)));
42025 SWIG_Python_SetConstant(d, "SYS_SCREEN_TINY",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_TINY)));
42026 SWIG_Python_SetConstant(d, "SYS_SCREEN_PDA",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_PDA)));
42027 SWIG_Python_SetConstant(d, "SYS_SCREEN_SMALL",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_SMALL)));
42028 SWIG_Python_SetConstant(d, "SYS_SCREEN_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_DESKTOP)));
42029 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
42030 SWIG_addvarlink(SWIG_globals(),(char*)"WINDOW_DEFAULT_VARIANT",WINDOW_DEFAULT_VARIANT_get, WINDOW_DEFAULT_VARIANT_set);
42031 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorPromptStr",FileSelectorPromptStr_get, FileSelectorPromptStr_set);
42032 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorDefaultWildcardStr",FileSelectorDefaultWildcardStr_get, FileSelectorDefaultWildcardStr_set);
42033 SWIG_addvarlink(SWIG_globals(),(char*)"DirSelectorPromptStr",DirSelectorPromptStr_get, DirSelectorPromptStr_set);
42034 SWIG_Python_SetConstant(d, "STOCK_NOFLAGS",SWIG_From_int(static_cast< int >(wxSTOCK_NOFLAGS)));
42035 SWIG_Python_SetConstant(d, "STOCK_WITH_MNEMONIC",SWIG_From_int(static_cast< int >(wxSTOCK_WITH_MNEMONIC)));
42036 SWIG_Python_SetConstant(d, "STOCK_WITH_ACCELERATOR",SWIG_From_int(static_cast< int >(wxSTOCK_WITH_ACCELERATOR)));
42037 SWIG_Python_SetConstant(d, "STOCK_MENU",SWIG_From_int(static_cast< int >(wxSTOCK_MENU)));
42038 SWIG_Python_SetConstant(d, "SHUTDOWN_POWEROFF",SWIG_From_int(static_cast< int >(wxSHUTDOWN_POWEROFF)));
42039 SWIG_Python_SetConstant(d, "SHUTDOWN_REBOOT",SWIG_From_int(static_cast< int >(wxSHUTDOWN_REBOOT)));
42040 SWIG_Python_SetConstant(d, "OS_UNKNOWN",SWIG_From_int(static_cast< int >(wxOS_UNKNOWN)));
42041 SWIG_Python_SetConstant(d, "OS_MAC_OS",SWIG_From_int(static_cast< int >(wxOS_MAC_OS)));
42042 SWIG_Python_SetConstant(d, "OS_MAC_OSX_DARWIN",SWIG_From_int(static_cast< int >(wxOS_MAC_OSX_DARWIN)));
42043 SWIG_Python_SetConstant(d, "OS_MAC",SWIG_From_int(static_cast< int >(wxOS_MAC)));
42044 SWIG_Python_SetConstant(d, "OS_WINDOWS_9X",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_9X)));
42045 SWIG_Python_SetConstant(d, "OS_WINDOWS_NT",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_NT)));
42046 SWIG_Python_SetConstant(d, "OS_WINDOWS_MICRO",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_MICRO)));
42047 SWIG_Python_SetConstant(d, "OS_WINDOWS_CE",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_CE)));
42048 SWIG_Python_SetConstant(d, "OS_WINDOWS",SWIG_From_int(static_cast< int >(wxOS_WINDOWS)));
42049 SWIG_Python_SetConstant(d, "OS_UNIX_LINUX",SWIG_From_int(static_cast< int >(wxOS_UNIX_LINUX)));
42050 SWIG_Python_SetConstant(d, "OS_UNIX_FREEBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_FREEBSD)));
42051 SWIG_Python_SetConstant(d, "OS_UNIX_OPENBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_OPENBSD)));
42052 SWIG_Python_SetConstant(d, "OS_UNIX_NETBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_NETBSD)));
42053 SWIG_Python_SetConstant(d, "OS_UNIX_SOLARIS",SWIG_From_int(static_cast< int >(wxOS_UNIX_SOLARIS)));
42054 SWIG_Python_SetConstant(d, "OS_UNIX_AIX",SWIG_From_int(static_cast< int >(wxOS_UNIX_AIX)));
42055 SWIG_Python_SetConstant(d, "OS_UNIX_HPUX",SWIG_From_int(static_cast< int >(wxOS_UNIX_HPUX)));
42056 SWIG_Python_SetConstant(d, "OS_UNIX",SWIG_From_int(static_cast< int >(wxOS_UNIX)));
42057 SWIG_Python_SetConstant(d, "OS_DOS",SWIG_From_int(static_cast< int >(wxOS_DOS)));
42058 SWIG_Python_SetConstant(d, "OS_OS2",SWIG_From_int(static_cast< int >(wxOS_OS2)));
42059 SWIG_Python_SetConstant(d, "PORT_UNKNOWN",SWIG_From_int(static_cast< int >(wxPORT_UNKNOWN)));
42060 SWIG_Python_SetConstant(d, "PORT_BASE",SWIG_From_int(static_cast< int >(wxPORT_BASE)));
42061 SWIG_Python_SetConstant(d, "PORT_MSW",SWIG_From_int(static_cast< int >(wxPORT_MSW)));
42062 SWIG_Python_SetConstant(d, "PORT_MOTIF",SWIG_From_int(static_cast< int >(wxPORT_MOTIF)));
42063 SWIG_Python_SetConstant(d, "PORT_GTK",SWIG_From_int(static_cast< int >(wxPORT_GTK)));
42064 SWIG_Python_SetConstant(d, "PORT_MGL",SWIG_From_int(static_cast< int >(wxPORT_MGL)));
42065 SWIG_Python_SetConstant(d, "PORT_X11",SWIG_From_int(static_cast< int >(wxPORT_X11)));
42066 SWIG_Python_SetConstant(d, "PORT_PM",SWIG_From_int(static_cast< int >(wxPORT_PM)));
42067 SWIG_Python_SetConstant(d, "PORT_OS2",SWIG_From_int(static_cast< int >(wxPORT_OS2)));
42068 SWIG_Python_SetConstant(d, "PORT_MAC",SWIG_From_int(static_cast< int >(wxPORT_MAC)));
42069 SWIG_Python_SetConstant(d, "PORT_COCOA",SWIG_From_int(static_cast< int >(wxPORT_COCOA)));
42070 SWIG_Python_SetConstant(d, "PORT_WINCE",SWIG_From_int(static_cast< int >(wxPORT_WINCE)));
42071 SWIG_Python_SetConstant(d, "PORT_PALMOS",SWIG_From_int(static_cast< int >(wxPORT_PALMOS)));
42072 SWIG_Python_SetConstant(d, "PORT_DFB",SWIG_From_int(static_cast< int >(wxPORT_DFB)));
42073 SWIG_Python_SetConstant(d, "ARCH_INVALID",SWIG_From_int(static_cast< int >(wxARCH_INVALID)));
42074 SWIG_Python_SetConstant(d, "ARCH_32",SWIG_From_int(static_cast< int >(wxARCH_32)));
42075 SWIG_Python_SetConstant(d, "ARCH_64",SWIG_From_int(static_cast< int >(wxARCH_64)));
42076 SWIG_Python_SetConstant(d, "ARCH_MAX",SWIG_From_int(static_cast< int >(wxARCH_MAX)));
42077 SWIG_Python_SetConstant(d, "ENDIAN_INVALID",SWIG_From_int(static_cast< int >(wxENDIAN_INVALID)));
42078 SWIG_Python_SetConstant(d, "ENDIAN_BIG",SWIG_From_int(static_cast< int >(wxENDIAN_BIG)));
42079 SWIG_Python_SetConstant(d, "ENDIAN_LITTLE",SWIG_From_int(static_cast< int >(wxENDIAN_LITTLE)));
42080 SWIG_Python_SetConstant(d, "ENDIAN_PDP",SWIG_From_int(static_cast< int >(wxENDIAN_PDP)));
42081 SWIG_Python_SetConstant(d, "ENDIAN_MAX",SWIG_From_int(static_cast< int >(wxENDIAN_MAX)));
42082 SWIG_Python_SetConstant(d, "TIMER_CONTINUOUS",SWIG_From_int(static_cast< int >(wxTIMER_CONTINUOUS)));
42083 SWIG_Python_SetConstant(d, "TIMER_ONE_SHOT",SWIG_From_int(static_cast< int >(wxTIMER_ONE_SHOT)));
42084 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
42085
42086 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
42087
42088 SWIG_Python_SetConstant(d, "LOG_FatalError",SWIG_From_int(static_cast< int >(wxLOG_FatalError)));
42089 SWIG_Python_SetConstant(d, "LOG_Error",SWIG_From_int(static_cast< int >(wxLOG_Error)));
42090 SWIG_Python_SetConstant(d, "LOG_Warning",SWIG_From_int(static_cast< int >(wxLOG_Warning)));
42091 SWIG_Python_SetConstant(d, "LOG_Message",SWIG_From_int(static_cast< int >(wxLOG_Message)));
42092 SWIG_Python_SetConstant(d, "LOG_Status",SWIG_From_int(static_cast< int >(wxLOG_Status)));
42093 SWIG_Python_SetConstant(d, "LOG_Info",SWIG_From_int(static_cast< int >(wxLOG_Info)));
42094 SWIG_Python_SetConstant(d, "LOG_Debug",SWIG_From_int(static_cast< int >(wxLOG_Debug)));
42095 SWIG_Python_SetConstant(d, "LOG_Trace",SWIG_From_int(static_cast< int >(wxLOG_Trace)));
42096 SWIG_Python_SetConstant(d, "LOG_Progress",SWIG_From_int(static_cast< int >(wxLOG_Progress)));
42097 SWIG_Python_SetConstant(d, "LOG_User",SWIG_From_int(static_cast< int >(wxLOG_User)));
42098 SWIG_Python_SetConstant(d, "LOG_Max",SWIG_From_int(static_cast< int >(wxLOG_Max)));
42099 SWIG_Python_SetConstant(d, "TRACE_MemAlloc",SWIG_FromCharPtr("memalloc"));
42100 SWIG_Python_SetConstant(d, "TRACE_Messages",SWIG_FromCharPtr("messages"));
42101 SWIG_Python_SetConstant(d, "TRACE_ResAlloc",SWIG_FromCharPtr("resalloc"));
42102 SWIG_Python_SetConstant(d, "TRACE_RefCount",SWIG_FromCharPtr("refcount"));
42103 SWIG_Python_SetConstant(d, "TRACE_OleCalls",SWIG_FromCharPtr("ole"));
42104 SWIG_Python_SetConstant(d, "TraceMemAlloc",SWIG_From_int(static_cast< int >(0x0001)));
42105 SWIG_Python_SetConstant(d, "TraceMessages",SWIG_From_int(static_cast< int >(0x0002)));
42106 SWIG_Python_SetConstant(d, "TraceResAlloc",SWIG_From_int(static_cast< int >(0x0004)));
42107 SWIG_Python_SetConstant(d, "TraceRefCount",SWIG_From_int(static_cast< int >(0x0008)));
42108 SWIG_Python_SetConstant(d, "TraceOleCalls",SWIG_From_int(static_cast< int >(0x0100)));
42109 SWIG_Python_SetConstant(d, "PROCESS_DEFAULT",SWIG_From_int(static_cast< int >(wxPROCESS_DEFAULT)));
42110 SWIG_Python_SetConstant(d, "PROCESS_REDIRECT",SWIG_From_int(static_cast< int >(wxPROCESS_REDIRECT)));
42111 SWIG_Python_SetConstant(d, "KILL_OK",SWIG_From_int(static_cast< int >(wxKILL_OK)));
42112 SWIG_Python_SetConstant(d, "KILL_BAD_SIGNAL",SWIG_From_int(static_cast< int >(wxKILL_BAD_SIGNAL)));
42113 SWIG_Python_SetConstant(d, "KILL_ACCESS_DENIED",SWIG_From_int(static_cast< int >(wxKILL_ACCESS_DENIED)));
42114 SWIG_Python_SetConstant(d, "KILL_NO_PROCESS",SWIG_From_int(static_cast< int >(wxKILL_NO_PROCESS)));
42115 SWIG_Python_SetConstant(d, "KILL_ERROR",SWIG_From_int(static_cast< int >(wxKILL_ERROR)));
42116 SWIG_Python_SetConstant(d, "KILL_NOCHILDREN",SWIG_From_int(static_cast< int >(wxKILL_NOCHILDREN)));
42117 SWIG_Python_SetConstant(d, "KILL_CHILDREN",SWIG_From_int(static_cast< int >(wxKILL_CHILDREN)));
42118 SWIG_Python_SetConstant(d, "SIGNONE",SWIG_From_int(static_cast< int >(wxSIGNONE)));
42119 SWIG_Python_SetConstant(d, "SIGHUP",SWIG_From_int(static_cast< int >(wxSIGHUP)));
42120 SWIG_Python_SetConstant(d, "SIGINT",SWIG_From_int(static_cast< int >(wxSIGINT)));
42121 SWIG_Python_SetConstant(d, "SIGQUIT",SWIG_From_int(static_cast< int >(wxSIGQUIT)));
42122 SWIG_Python_SetConstant(d, "SIGILL",SWIG_From_int(static_cast< int >(wxSIGILL)));
42123 SWIG_Python_SetConstant(d, "SIGTRAP",SWIG_From_int(static_cast< int >(wxSIGTRAP)));
42124 SWIG_Python_SetConstant(d, "SIGABRT",SWIG_From_int(static_cast< int >(wxSIGABRT)));
42125 SWIG_Python_SetConstant(d, "SIGIOT",SWIG_From_int(static_cast< int >(wxSIGIOT)));
42126 SWIG_Python_SetConstant(d, "SIGEMT",SWIG_From_int(static_cast< int >(wxSIGEMT)));
42127 SWIG_Python_SetConstant(d, "SIGFPE",SWIG_From_int(static_cast< int >(wxSIGFPE)));
42128 SWIG_Python_SetConstant(d, "SIGKILL",SWIG_From_int(static_cast< int >(wxSIGKILL)));
42129 SWIG_Python_SetConstant(d, "SIGBUS",SWIG_From_int(static_cast< int >(wxSIGBUS)));
42130 SWIG_Python_SetConstant(d, "SIGSEGV",SWIG_From_int(static_cast< int >(wxSIGSEGV)));
42131 SWIG_Python_SetConstant(d, "SIGSYS",SWIG_From_int(static_cast< int >(wxSIGSYS)));
42132 SWIG_Python_SetConstant(d, "SIGPIPE",SWIG_From_int(static_cast< int >(wxSIGPIPE)));
42133 SWIG_Python_SetConstant(d, "SIGALRM",SWIG_From_int(static_cast< int >(wxSIGALRM)));
42134 SWIG_Python_SetConstant(d, "SIGTERM",SWIG_From_int(static_cast< int >(wxSIGTERM)));
42135 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
42136 SWIG_Python_SetConstant(d, "EXEC_ASYNC",SWIG_From_int(static_cast< int >(wxEXEC_ASYNC)));
42137 SWIG_Python_SetConstant(d, "EXEC_SYNC",SWIG_From_int(static_cast< int >(wxEXEC_SYNC)));
42138 SWIG_Python_SetConstant(d, "EXEC_NOHIDE",SWIG_From_int(static_cast< int >(wxEXEC_NOHIDE)));
42139 SWIG_Python_SetConstant(d, "EXEC_MAKE_GROUP_LEADER",SWIG_From_int(static_cast< int >(wxEXEC_MAKE_GROUP_LEADER)));
42140 SWIG_Python_SetConstant(d, "EXEC_NODISABLE",SWIG_From_int(static_cast< int >(wxEXEC_NODISABLE)));
42141
42142 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
42143
42144 SWIG_Python_SetConstant(d, "JOYSTICK1",SWIG_From_int(static_cast< int >(wxJOYSTICK1)));
42145 SWIG_Python_SetConstant(d, "JOYSTICK2",SWIG_From_int(static_cast< int >(wxJOYSTICK2)));
42146 SWIG_Python_SetConstant(d, "JOY_BUTTON_ANY",SWIG_From_int(static_cast< int >(wxJOY_BUTTON_ANY)));
42147 SWIG_Python_SetConstant(d, "JOY_BUTTON1",SWIG_From_int(static_cast< int >(wxJOY_BUTTON1)));
42148 SWIG_Python_SetConstant(d, "JOY_BUTTON2",SWIG_From_int(static_cast< int >(wxJOY_BUTTON2)));
42149 SWIG_Python_SetConstant(d, "JOY_BUTTON3",SWIG_From_int(static_cast< int >(wxJOY_BUTTON3)));
42150 SWIG_Python_SetConstant(d, "JOY_BUTTON4",SWIG_From_int(static_cast< int >(wxJOY_BUTTON4)));
42151 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
42152 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
42153 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
42154 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
42155 SWIG_Python_SetConstant(d, "SOUND_SYNC",SWIG_From_int(static_cast< int >(wxSOUND_SYNC)));
42156 SWIG_Python_SetConstant(d, "SOUND_ASYNC",SWIG_From_int(static_cast< int >(wxSOUND_ASYNC)));
42157 SWIG_Python_SetConstant(d, "SOUND_LOOP",SWIG_From_int(static_cast< int >(wxSOUND_LOOP)));
42158 SWIG_Python_SetConstant(d, "MAILCAP_STANDARD",SWIG_From_int(static_cast< int >(wxMAILCAP_STANDARD)));
42159 SWIG_Python_SetConstant(d, "MAILCAP_NETSCAPE",SWIG_From_int(static_cast< int >(wxMAILCAP_NETSCAPE)));
42160 SWIG_Python_SetConstant(d, "MAILCAP_KDE",SWIG_From_int(static_cast< int >(wxMAILCAP_KDE)));
42161 SWIG_Python_SetConstant(d, "MAILCAP_GNOME",SWIG_From_int(static_cast< int >(wxMAILCAP_GNOME)));
42162 SWIG_Python_SetConstant(d, "MAILCAP_ALL",SWIG_From_int(static_cast< int >(wxMAILCAP_ALL)));
42163 SWIG_addvarlink(SWIG_globals(),(char*)"TheMimeTypesManager",TheMimeTypesManager_get, TheMimeTypesManager_set);
42164 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TOOLBAR",ART_TOOLBAR_get, ART_TOOLBAR_set);
42165 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MENU",ART_MENU_get, ART_MENU_set);
42166 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FRAME_ICON",ART_FRAME_ICON_get, ART_FRAME_ICON_set);
42167 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CMN_DIALOG",ART_CMN_DIALOG_get, ART_CMN_DIALOG_set);
42168 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BROWSER",ART_HELP_BROWSER_get, ART_HELP_BROWSER_set);
42169 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MESSAGE_BOX",ART_MESSAGE_BOX_get, ART_MESSAGE_BOX_set);
42170 SWIG_addvarlink(SWIG_globals(),(char*)"ART_BUTTON",ART_BUTTON_get, ART_BUTTON_set);
42171 SWIG_addvarlink(SWIG_globals(),(char*)"ART_OTHER",ART_OTHER_get, ART_OTHER_set);
42172 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ADD_BOOKMARK",ART_ADD_BOOKMARK_get, ART_ADD_BOOKMARK_set);
42173 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DEL_BOOKMARK",ART_DEL_BOOKMARK_get, ART_DEL_BOOKMARK_set);
42174 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SIDE_PANEL",ART_HELP_SIDE_PANEL_get, ART_HELP_SIDE_PANEL_set);
42175 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SETTINGS",ART_HELP_SETTINGS_get, ART_HELP_SETTINGS_set);
42176 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BOOK",ART_HELP_BOOK_get, ART_HELP_BOOK_set);
42177 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_FOLDER",ART_HELP_FOLDER_get, ART_HELP_FOLDER_set);
42178 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_PAGE",ART_HELP_PAGE_get, ART_HELP_PAGE_set);
42179 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_BACK",ART_GO_BACK_get, ART_GO_BACK_set);
42180 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_FORWARD",ART_GO_FORWARD_get, ART_GO_FORWARD_set);
42181 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_UP",ART_GO_UP_get, ART_GO_UP_set);
42182 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DOWN",ART_GO_DOWN_get, ART_GO_DOWN_set);
42183 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_TO_PARENT",ART_GO_TO_PARENT_get, ART_GO_TO_PARENT_set);
42184 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_HOME",ART_GO_HOME_get, ART_GO_HOME_set);
42185 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_OPEN",ART_FILE_OPEN_get, ART_FILE_OPEN_set);
42186 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE",ART_FILE_SAVE_get, ART_FILE_SAVE_set);
42187 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE_AS",ART_FILE_SAVE_AS_get, ART_FILE_SAVE_AS_set);
42188 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PRINT",ART_PRINT_get, ART_PRINT_set);
42189 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP",ART_HELP_get, ART_HELP_set);
42190 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TIP",ART_TIP_get, ART_TIP_set);
42191 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REPORT_VIEW",ART_REPORT_VIEW_get, ART_REPORT_VIEW_set);
42192 SWIG_addvarlink(SWIG_globals(),(char*)"ART_LIST_VIEW",ART_LIST_VIEW_get, ART_LIST_VIEW_set);
42193 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW_DIR",ART_NEW_DIR_get, ART_NEW_DIR_set);
42194 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HARDDISK",ART_HARDDISK_get, ART_HARDDISK_set);
42195 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FLOPPY",ART_FLOPPY_get, ART_FLOPPY_set);
42196 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CDROM",ART_CDROM_get, ART_CDROM_set);
42197 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REMOVABLE",ART_REMOVABLE_get, ART_REMOVABLE_set);
42198 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER",ART_FOLDER_get, ART_FOLDER_set);
42199 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER_OPEN",ART_FOLDER_OPEN_get, ART_FOLDER_OPEN_set);
42200 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DIR_UP",ART_GO_DIR_UP_get, ART_GO_DIR_UP_set);
42201 SWIG_addvarlink(SWIG_globals(),(char*)"ART_EXECUTABLE_FILE",ART_EXECUTABLE_FILE_get, ART_EXECUTABLE_FILE_set);
42202 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NORMAL_FILE",ART_NORMAL_FILE_get, ART_NORMAL_FILE_set);
42203 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TICK_MARK",ART_TICK_MARK_get, ART_TICK_MARK_set);
42204 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CROSS_MARK",ART_CROSS_MARK_get, ART_CROSS_MARK_set);
42205 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ERROR",ART_ERROR_get, ART_ERROR_set);
42206 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUESTION",ART_QUESTION_get, ART_QUESTION_set);
42207 SWIG_addvarlink(SWIG_globals(),(char*)"ART_WARNING",ART_WARNING_get, ART_WARNING_set);
42208 SWIG_addvarlink(SWIG_globals(),(char*)"ART_INFORMATION",ART_INFORMATION_get, ART_INFORMATION_set);
42209 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MISSING_IMAGE",ART_MISSING_IMAGE_get, ART_MISSING_IMAGE_set);
42210 SWIG_addvarlink(SWIG_globals(),(char*)"ART_COPY",ART_COPY_get, ART_COPY_set);
42211 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CUT",ART_CUT_get, ART_CUT_set);
42212 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PASTE",ART_PASTE_get, ART_PASTE_set);
42213 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DELETE",ART_DELETE_get, ART_DELETE_set);
42214 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW",ART_NEW_get, ART_NEW_set);
42215 SWIG_addvarlink(SWIG_globals(),(char*)"ART_UNDO",ART_UNDO_get, ART_UNDO_set);
42216 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REDO",ART_REDO_get, ART_REDO_set);
42217 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUIT",ART_QUIT_get, ART_QUIT_set);
42218 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND",ART_FIND_get, ART_FIND_set);
42219 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND_AND_REPLACE",ART_FIND_AND_REPLACE_get, ART_FIND_AND_REPLACE_set);
42220
42221 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
42222
42223 SWIG_Python_SetConstant(d, "CONFIG_USE_LOCAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_LOCAL_FILE)));
42224 SWIG_Python_SetConstant(d, "CONFIG_USE_GLOBAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_GLOBAL_FILE)));
42225 SWIG_Python_SetConstant(d, "CONFIG_USE_RELATIVE_PATH",SWIG_From_int(static_cast< int >(wxCONFIG_USE_RELATIVE_PATH)));
42226 SWIG_Python_SetConstant(d, "CONFIG_USE_NO_ESCAPE_CHARACTERS",SWIG_From_int(static_cast< int >(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
42227 SWIG_Python_SetConstant(d, "ConfigBase_Type_Unknown",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Unknown)));
42228 SWIG_Python_SetConstant(d, "ConfigBase_Type_String",SWIG_From_int(static_cast< int >(wxConfigBase::Type_String)));
42229 SWIG_Python_SetConstant(d, "ConfigBase_Type_Boolean",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Boolean)));
42230 SWIG_Python_SetConstant(d, "ConfigBase_Type_Integer",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Integer)));
42231 SWIG_Python_SetConstant(d, "ConfigBase_Type_Float",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Float)));
42232 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTimeFormat",DefaultDateTimeFormat_get, DefaultDateTimeFormat_set);
42233 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultTimeSpanFormat",DefaultTimeSpanFormat_get, DefaultTimeSpanFormat_set);
42234 SWIG_Python_SetConstant(d, "DateTime_Local",SWIG_From_int(static_cast< int >(wxDateTime::Local)));
42235 SWIG_Python_SetConstant(d, "DateTime_GMT_12",SWIG_From_int(static_cast< int >(wxDateTime::GMT_12)));
42236 SWIG_Python_SetConstant(d, "DateTime_GMT_11",SWIG_From_int(static_cast< int >(wxDateTime::GMT_11)));
42237 SWIG_Python_SetConstant(d, "DateTime_GMT_10",SWIG_From_int(static_cast< int >(wxDateTime::GMT_10)));
42238 SWIG_Python_SetConstant(d, "DateTime_GMT_9",SWIG_From_int(static_cast< int >(wxDateTime::GMT_9)));
42239 SWIG_Python_SetConstant(d, "DateTime_GMT_8",SWIG_From_int(static_cast< int >(wxDateTime::GMT_8)));
42240 SWIG_Python_SetConstant(d, "DateTime_GMT_7",SWIG_From_int(static_cast< int >(wxDateTime::GMT_7)));
42241 SWIG_Python_SetConstant(d, "DateTime_GMT_6",SWIG_From_int(static_cast< int >(wxDateTime::GMT_6)));
42242 SWIG_Python_SetConstant(d, "DateTime_GMT_5",SWIG_From_int(static_cast< int >(wxDateTime::GMT_5)));
42243 SWIG_Python_SetConstant(d, "DateTime_GMT_4",SWIG_From_int(static_cast< int >(wxDateTime::GMT_4)));
42244 SWIG_Python_SetConstant(d, "DateTime_GMT_3",SWIG_From_int(static_cast< int >(wxDateTime::GMT_3)));
42245 SWIG_Python_SetConstant(d, "DateTime_GMT_2",SWIG_From_int(static_cast< int >(wxDateTime::GMT_2)));
42246 SWIG_Python_SetConstant(d, "DateTime_GMT_1",SWIG_From_int(static_cast< int >(wxDateTime::GMT_1)));
42247 SWIG_Python_SetConstant(d, "DateTime_GMT0",SWIG_From_int(static_cast< int >(wxDateTime::GMT0)));
42248 SWIG_Python_SetConstant(d, "DateTime_GMT1",SWIG_From_int(static_cast< int >(wxDateTime::GMT1)));
42249 SWIG_Python_SetConstant(d, "DateTime_GMT2",SWIG_From_int(static_cast< int >(wxDateTime::GMT2)));
42250 SWIG_Python_SetConstant(d, "DateTime_GMT3",SWIG_From_int(static_cast< int >(wxDateTime::GMT3)));
42251 SWIG_Python_SetConstant(d, "DateTime_GMT4",SWIG_From_int(static_cast< int >(wxDateTime::GMT4)));
42252 SWIG_Python_SetConstant(d, "DateTime_GMT5",SWIG_From_int(static_cast< int >(wxDateTime::GMT5)));
42253 SWIG_Python_SetConstant(d, "DateTime_GMT6",SWIG_From_int(static_cast< int >(wxDateTime::GMT6)));
42254 SWIG_Python_SetConstant(d, "DateTime_GMT7",SWIG_From_int(static_cast< int >(wxDateTime::GMT7)));
42255 SWIG_Python_SetConstant(d, "DateTime_GMT8",SWIG_From_int(static_cast< int >(wxDateTime::GMT8)));
42256 SWIG_Python_SetConstant(d, "DateTime_GMT9",SWIG_From_int(static_cast< int >(wxDateTime::GMT9)));
42257 SWIG_Python_SetConstant(d, "DateTime_GMT10",SWIG_From_int(static_cast< int >(wxDateTime::GMT10)));
42258 SWIG_Python_SetConstant(d, "DateTime_GMT11",SWIG_From_int(static_cast< int >(wxDateTime::GMT11)));
42259 SWIG_Python_SetConstant(d, "DateTime_GMT12",SWIG_From_int(static_cast< int >(wxDateTime::GMT12)));
42260 SWIG_Python_SetConstant(d, "DateTime_GMT13",SWIG_From_int(static_cast< int >(wxDateTime::GMT13)));
42261 SWIG_Python_SetConstant(d, "DateTime_WET",SWIG_From_int(static_cast< int >(wxDateTime::WET)));
42262 SWIG_Python_SetConstant(d, "DateTime_WEST",SWIG_From_int(static_cast< int >(wxDateTime::WEST)));
42263 SWIG_Python_SetConstant(d, "DateTime_CET",SWIG_From_int(static_cast< int >(wxDateTime::CET)));
42264 SWIG_Python_SetConstant(d, "DateTime_CEST",SWIG_From_int(static_cast< int >(wxDateTime::CEST)));
42265 SWIG_Python_SetConstant(d, "DateTime_EET",SWIG_From_int(static_cast< int >(wxDateTime::EET)));
42266 SWIG_Python_SetConstant(d, "DateTime_EEST",SWIG_From_int(static_cast< int >(wxDateTime::EEST)));
42267 SWIG_Python_SetConstant(d, "DateTime_MSK",SWIG_From_int(static_cast< int >(wxDateTime::MSK)));
42268 SWIG_Python_SetConstant(d, "DateTime_MSD",SWIG_From_int(static_cast< int >(wxDateTime::MSD)));
42269 SWIG_Python_SetConstant(d, "DateTime_AST",SWIG_From_int(static_cast< int >(wxDateTime::AST)));
42270 SWIG_Python_SetConstant(d, "DateTime_ADT",SWIG_From_int(static_cast< int >(wxDateTime::ADT)));
42271 SWIG_Python_SetConstant(d, "DateTime_EST",SWIG_From_int(static_cast< int >(wxDateTime::EST)));
42272 SWIG_Python_SetConstant(d, "DateTime_EDT",SWIG_From_int(static_cast< int >(wxDateTime::EDT)));
42273 SWIG_Python_SetConstant(d, "DateTime_CST",SWIG_From_int(static_cast< int >(wxDateTime::CST)));
42274 SWIG_Python_SetConstant(d, "DateTime_CDT",SWIG_From_int(static_cast< int >(wxDateTime::CDT)));
42275 SWIG_Python_SetConstant(d, "DateTime_MST",SWIG_From_int(static_cast< int >(wxDateTime::MST)));
42276 SWIG_Python_SetConstant(d, "DateTime_MDT",SWIG_From_int(static_cast< int >(wxDateTime::MDT)));
42277 SWIG_Python_SetConstant(d, "DateTime_PST",SWIG_From_int(static_cast< int >(wxDateTime::PST)));
42278 SWIG_Python_SetConstant(d, "DateTime_PDT",SWIG_From_int(static_cast< int >(wxDateTime::PDT)));
42279 SWIG_Python_SetConstant(d, "DateTime_HST",SWIG_From_int(static_cast< int >(wxDateTime::HST)));
42280 SWIG_Python_SetConstant(d, "DateTime_AKST",SWIG_From_int(static_cast< int >(wxDateTime::AKST)));
42281 SWIG_Python_SetConstant(d, "DateTime_AKDT",SWIG_From_int(static_cast< int >(wxDateTime::AKDT)));
42282 SWIG_Python_SetConstant(d, "DateTime_A_WST",SWIG_From_int(static_cast< int >(wxDateTime::A_WST)));
42283 SWIG_Python_SetConstant(d, "DateTime_A_CST",SWIG_From_int(static_cast< int >(wxDateTime::A_CST)));
42284 SWIG_Python_SetConstant(d, "DateTime_A_EST",SWIG_From_int(static_cast< int >(wxDateTime::A_EST)));
42285 SWIG_Python_SetConstant(d, "DateTime_A_ESST",SWIG_From_int(static_cast< int >(wxDateTime::A_ESST)));
42286 SWIG_Python_SetConstant(d, "DateTime_NZST",SWIG_From_int(static_cast< int >(wxDateTime::NZST)));
42287 SWIG_Python_SetConstant(d, "DateTime_NZDT",SWIG_From_int(static_cast< int >(wxDateTime::NZDT)));
42288 SWIG_Python_SetConstant(d, "DateTime_UTC",SWIG_From_int(static_cast< int >(wxDateTime::UTC)));
42289 SWIG_Python_SetConstant(d, "DateTime_Gregorian",SWIG_From_int(static_cast< int >(wxDateTime::Gregorian)));
42290 SWIG_Python_SetConstant(d, "DateTime_Julian",SWIG_From_int(static_cast< int >(wxDateTime::Julian)));
42291 SWIG_Python_SetConstant(d, "DateTime_Gr_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Unknown)));
42292 SWIG_Python_SetConstant(d, "DateTime_Gr_Standard",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Standard)));
42293 SWIG_Python_SetConstant(d, "DateTime_Gr_Alaska",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Alaska)));
42294 SWIG_Python_SetConstant(d, "DateTime_Gr_Albania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Albania)));
42295 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria)));
42296 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Brixen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Brixen)));
42297 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Salzburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Salzburg)));
42298 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Tyrol",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Tyrol)));
42299 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Carinthia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Carinthia)));
42300 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Styria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Styria)));
42301 SWIG_Python_SetConstant(d, "DateTime_Gr_Belgium",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Belgium)));
42302 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria)));
42303 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_1)));
42304 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_2)));
42305 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_3)));
42306 SWIG_Python_SetConstant(d, "DateTime_Gr_Canada",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Canada)));
42307 SWIG_Python_SetConstant(d, "DateTime_Gr_China",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China)));
42308 SWIG_Python_SetConstant(d, "DateTime_Gr_China_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_1)));
42309 SWIG_Python_SetConstant(d, "DateTime_Gr_China_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_2)));
42310 SWIG_Python_SetConstant(d, "DateTime_Gr_Czechoslovakia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Czechoslovakia)));
42311 SWIG_Python_SetConstant(d, "DateTime_Gr_Denmark",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Denmark)));
42312 SWIG_Python_SetConstant(d, "DateTime_Gr_Egypt",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Egypt)));
42313 SWIG_Python_SetConstant(d, "DateTime_Gr_Estonia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Estonia)));
42314 SWIG_Python_SetConstant(d, "DateTime_Gr_Finland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Finland)));
42315 SWIG_Python_SetConstant(d, "DateTime_Gr_France",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France)));
42316 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Alsace",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Alsace)));
42317 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Lorraine",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Lorraine)));
42318 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Strasbourg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Strasbourg)));
42319 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany)));
42320 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Catholic)));
42321 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Prussia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Prussia)));
42322 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Protestant)));
42323 SWIG_Python_SetConstant(d, "DateTime_Gr_GreatBritain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_GreatBritain)));
42324 SWIG_Python_SetConstant(d, "DateTime_Gr_Greece",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Greece)));
42325 SWIG_Python_SetConstant(d, "DateTime_Gr_Hungary",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Hungary)));
42326 SWIG_Python_SetConstant(d, "DateTime_Gr_Ireland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Ireland)));
42327 SWIG_Python_SetConstant(d, "DateTime_Gr_Italy",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Italy)));
42328 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan)));
42329 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_1)));
42330 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_2)));
42331 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_3)));
42332 SWIG_Python_SetConstant(d, "DateTime_Gr_Latvia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Latvia)));
42333 SWIG_Python_SetConstant(d, "DateTime_Gr_Lithuania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Lithuania)));
42334 SWIG_Python_SetConstant(d, "DateTime_Gr_Luxemburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Luxemburg)));
42335 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands)));
42336 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Groningen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Groningen)));
42337 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Gelderland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Gelderland)));
42338 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Utrecht",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Utrecht)));
42339 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Friesland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Friesland)));
42340 SWIG_Python_SetConstant(d, "DateTime_Gr_Norway",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Norway)));
42341 SWIG_Python_SetConstant(d, "DateTime_Gr_Poland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Poland)));
42342 SWIG_Python_SetConstant(d, "DateTime_Gr_Portugal",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Portugal)));
42343 SWIG_Python_SetConstant(d, "DateTime_Gr_Romania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Romania)));
42344 SWIG_Python_SetConstant(d, "DateTime_Gr_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Russia)));
42345 SWIG_Python_SetConstant(d, "DateTime_Gr_Scotland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Scotland)));
42346 SWIG_Python_SetConstant(d, "DateTime_Gr_Spain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Spain)));
42347 SWIG_Python_SetConstant(d, "DateTime_Gr_Sweden",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Sweden)));
42348 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland)));
42349 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Catholic)));
42350 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Protestant)));
42351 SWIG_Python_SetConstant(d, "DateTime_Gr_Turkey",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Turkey)));
42352 SWIG_Python_SetConstant(d, "DateTime_Gr_USA",SWIG_From_int(static_cast< int >(wxDateTime::Gr_USA)));
42353 SWIG_Python_SetConstant(d, "DateTime_Gr_Wales",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Wales)));
42354 SWIG_Python_SetConstant(d, "DateTime_Gr_Yugoslavia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Yugoslavia)));
42355 SWIG_Python_SetConstant(d, "DateTime_Country_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Country_Unknown)));
42356 SWIG_Python_SetConstant(d, "DateTime_Country_Default",SWIG_From_int(static_cast< int >(wxDateTime::Country_Default)));
42357 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_Start",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_Start)));
42358 SWIG_Python_SetConstant(d, "DateTime_Country_EEC",SWIG_From_int(static_cast< int >(wxDateTime::Country_EEC)));
42359 SWIG_Python_SetConstant(d, "DateTime_France",SWIG_From_int(static_cast< int >(wxDateTime::France)));
42360 SWIG_Python_SetConstant(d, "DateTime_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Germany)));
42361 SWIG_Python_SetConstant(d, "DateTime_UK",SWIG_From_int(static_cast< int >(wxDateTime::UK)));
42362 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_End",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_End)));
42363 SWIG_Python_SetConstant(d, "DateTime_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Russia)));
42364 SWIG_Python_SetConstant(d, "DateTime_USA",SWIG_From_int(static_cast< int >(wxDateTime::USA)));
42365 SWIG_Python_SetConstant(d, "DateTime_Jan",SWIG_From_int(static_cast< int >(wxDateTime::Jan)));
42366 SWIG_Python_SetConstant(d, "DateTime_Feb",SWIG_From_int(static_cast< int >(wxDateTime::Feb)));
42367 SWIG_Python_SetConstant(d, "DateTime_Mar",SWIG_From_int(static_cast< int >(wxDateTime::Mar)));
42368 SWIG_Python_SetConstant(d, "DateTime_Apr",SWIG_From_int(static_cast< int >(wxDateTime::Apr)));
42369 SWIG_Python_SetConstant(d, "DateTime_May",SWIG_From_int(static_cast< int >(wxDateTime::May)));
42370 SWIG_Python_SetConstant(d, "DateTime_Jun",SWIG_From_int(static_cast< int >(wxDateTime::Jun)));
42371 SWIG_Python_SetConstant(d, "DateTime_Jul",SWIG_From_int(static_cast< int >(wxDateTime::Jul)));
42372 SWIG_Python_SetConstant(d, "DateTime_Aug",SWIG_From_int(static_cast< int >(wxDateTime::Aug)));
42373 SWIG_Python_SetConstant(d, "DateTime_Sep",SWIG_From_int(static_cast< int >(wxDateTime::Sep)));
42374 SWIG_Python_SetConstant(d, "DateTime_Oct",SWIG_From_int(static_cast< int >(wxDateTime::Oct)));
42375 SWIG_Python_SetConstant(d, "DateTime_Nov",SWIG_From_int(static_cast< int >(wxDateTime::Nov)));
42376 SWIG_Python_SetConstant(d, "DateTime_Dec",SWIG_From_int(static_cast< int >(wxDateTime::Dec)));
42377 SWIG_Python_SetConstant(d, "DateTime_Inv_Month",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Month)));
42378 SWIG_Python_SetConstant(d, "DateTime_Sun",SWIG_From_int(static_cast< int >(wxDateTime::Sun)));
42379 SWIG_Python_SetConstant(d, "DateTime_Mon",SWIG_From_int(static_cast< int >(wxDateTime::Mon)));
42380 SWIG_Python_SetConstant(d, "DateTime_Tue",SWIG_From_int(static_cast< int >(wxDateTime::Tue)));
42381 SWIG_Python_SetConstant(d, "DateTime_Wed",SWIG_From_int(static_cast< int >(wxDateTime::Wed)));
42382 SWIG_Python_SetConstant(d, "DateTime_Thu",SWIG_From_int(static_cast< int >(wxDateTime::Thu)));
42383 SWIG_Python_SetConstant(d, "DateTime_Fri",SWIG_From_int(static_cast< int >(wxDateTime::Fri)));
42384 SWIG_Python_SetConstant(d, "DateTime_Sat",SWIG_From_int(static_cast< int >(wxDateTime::Sat)));
42385 SWIG_Python_SetConstant(d, "DateTime_Inv_WeekDay",SWIG_From_int(static_cast< int >(wxDateTime::Inv_WeekDay)));
42386 SWIG_Python_SetConstant(d, "DateTime_Inv_Year",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Year)));
42387 SWIG_Python_SetConstant(d, "DateTime_Name_Full",SWIG_From_int(static_cast< int >(wxDateTime::Name_Full)));
42388 SWIG_Python_SetConstant(d, "DateTime_Name_Abbr",SWIG_From_int(static_cast< int >(wxDateTime::Name_Abbr)));
42389 SWIG_Python_SetConstant(d, "DateTime_Default_First",SWIG_From_int(static_cast< int >(wxDateTime::Default_First)));
42390 SWIG_Python_SetConstant(d, "DateTime_Monday_First",SWIG_From_int(static_cast< int >(wxDateTime::Monday_First)));
42391 SWIG_Python_SetConstant(d, "DateTime_Sunday_First",SWIG_From_int(static_cast< int >(wxDateTime::Sunday_First)));
42392 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTime",DefaultDateTime_get, DefaultDateTime_set);
42393 SWIG_Python_SetConstant(d, "DF_INVALID",SWIG_From_int(static_cast< int >(wxDF_INVALID)));
42394 SWIG_Python_SetConstant(d, "DF_TEXT",SWIG_From_int(static_cast< int >(wxDF_TEXT)));
42395 SWIG_Python_SetConstant(d, "DF_BITMAP",SWIG_From_int(static_cast< int >(wxDF_BITMAP)));
42396 SWIG_Python_SetConstant(d, "DF_METAFILE",SWIG_From_int(static_cast< int >(wxDF_METAFILE)));
42397 SWIG_Python_SetConstant(d, "DF_SYLK",SWIG_From_int(static_cast< int >(wxDF_SYLK)));
42398 SWIG_Python_SetConstant(d, "DF_DIF",SWIG_From_int(static_cast< int >(wxDF_DIF)));
42399 SWIG_Python_SetConstant(d, "DF_TIFF",SWIG_From_int(static_cast< int >(wxDF_TIFF)));
42400 SWIG_Python_SetConstant(d, "DF_OEMTEXT",SWIG_From_int(static_cast< int >(wxDF_OEMTEXT)));
42401 SWIG_Python_SetConstant(d, "DF_DIB",SWIG_From_int(static_cast< int >(wxDF_DIB)));
42402 SWIG_Python_SetConstant(d, "DF_PALETTE",SWIG_From_int(static_cast< int >(wxDF_PALETTE)));
42403 SWIG_Python_SetConstant(d, "DF_PENDATA",SWIG_From_int(static_cast< int >(wxDF_PENDATA)));
42404 SWIG_Python_SetConstant(d, "DF_RIFF",SWIG_From_int(static_cast< int >(wxDF_RIFF)));
42405 SWIG_Python_SetConstant(d, "DF_WAVE",SWIG_From_int(static_cast< int >(wxDF_WAVE)));
42406 SWIG_Python_SetConstant(d, "DF_UNICODETEXT",SWIG_From_int(static_cast< int >(wxDF_UNICODETEXT)));
42407 SWIG_Python_SetConstant(d, "DF_ENHMETAFILE",SWIG_From_int(static_cast< int >(wxDF_ENHMETAFILE)));
42408 SWIG_Python_SetConstant(d, "DF_FILENAME",SWIG_From_int(static_cast< int >(wxDF_FILENAME)));
42409 SWIG_Python_SetConstant(d, "DF_LOCALE",SWIG_From_int(static_cast< int >(wxDF_LOCALE)));
42410 SWIG_Python_SetConstant(d, "DF_PRIVATE",SWIG_From_int(static_cast< int >(wxDF_PRIVATE)));
42411 SWIG_Python_SetConstant(d, "DF_HTML",SWIG_From_int(static_cast< int >(wxDF_HTML)));
42412 SWIG_Python_SetConstant(d, "DF_MAX",SWIG_From_int(static_cast< int >(wxDF_MAX)));
42413 SWIG_addvarlink(SWIG_globals(),(char*)"FormatInvalid",FormatInvalid_get, FormatInvalid_set);
42414 SWIG_Python_SetConstant(d, "DataObject_Get",SWIG_From_int(static_cast< int >(wxDataObject::Get)));
42415 SWIG_Python_SetConstant(d, "DataObject_Set",SWIG_From_int(static_cast< int >(wxDataObject::Set)));
42416 SWIG_Python_SetConstant(d, "DataObject_Both",SWIG_From_int(static_cast< int >(wxDataObject::Both)));
42417 SWIG_Python_SetConstant(d, "Drag_CopyOnly",SWIG_From_int(static_cast< int >(wxDrag_CopyOnly)));
42418 SWIG_Python_SetConstant(d, "Drag_AllowMove",SWIG_From_int(static_cast< int >(wxDrag_AllowMove)));
42419 SWIG_Python_SetConstant(d, "Drag_DefaultMove",SWIG_From_int(static_cast< int >(wxDrag_DefaultMove)));
42420 SWIG_Python_SetConstant(d, "DragError",SWIG_From_int(static_cast< int >(wxDragError)));
42421 SWIG_Python_SetConstant(d, "DragNone",SWIG_From_int(static_cast< int >(wxDragNone)));
42422 SWIG_Python_SetConstant(d, "DragCopy",SWIG_From_int(static_cast< int >(wxDragCopy)));
42423 SWIG_Python_SetConstant(d, "DragMove",SWIG_From_int(static_cast< int >(wxDragMove)));
42424 SWIG_Python_SetConstant(d, "DragLink",SWIG_From_int(static_cast< int >(wxDragLink)));
42425 SWIG_Python_SetConstant(d, "DragCancel",SWIG_From_int(static_cast< int >(wxDragCancel)));
42426
42427 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
42428 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
42429 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
42430 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
42431
42432 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultVideoMode",DefaultVideoMode_get, DefaultVideoMode_set);
42433 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_None",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_None)));
42434 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Messages",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Messages)));
42435 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Max",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Max)));
42436 SWIG_Python_SetConstant(d, "POWER_SOCKET",SWIG_From_int(static_cast< int >(wxPOWER_SOCKET)));
42437 SWIG_Python_SetConstant(d, "POWER_BATTERY",SWIG_From_int(static_cast< int >(wxPOWER_BATTERY)));
42438 SWIG_Python_SetConstant(d, "POWER_UNKNOWN",SWIG_From_int(static_cast< int >(wxPOWER_UNKNOWN)));
42439 SWIG_Python_SetConstant(d, "BATTERY_NORMAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_NORMAL_STATE)));
42440 SWIG_Python_SetConstant(d, "BATTERY_LOW_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_LOW_STATE)));
42441 SWIG_Python_SetConstant(d, "BATTERY_CRITICAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_CRITICAL_STATE)));
42442 SWIG_Python_SetConstant(d, "BATTERY_SHUTDOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_SHUTDOWN_STATE)));
42443 SWIG_Python_SetConstant(d, "BATTERY_UNKNOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_UNKNOWN_STATE)));
42444 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDING", PyInt_FromLong(wxEVT_POWER_SUSPENDING));
42445 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDED", PyInt_FromLong(wxEVT_POWER_SUSPENDED));
42446 PyDict_SetItemString(d, "wxEVT_POWER_SUSPEND_CANCEL", PyInt_FromLong(wxEVT_POWER_SUSPEND_CANCEL));
42447 PyDict_SetItemString(d, "wxEVT_POWER_RESUME", PyInt_FromLong(wxEVT_POWER_RESUME));
42448 }
42449
wxWidgets (Impactor)